pax_global_header 0000666 0000000 0000000 00000000064 14744245500 0014517 g ustar 00root root 0000000 0000000 52 comment=2c6824768b483ea030ba312972e508c23e62d75c
go-git-5.13.2/ 0000775 0000000 0000000 00000000000 14744245500 0012775 5 ustar 00root root 0000000 0000000 go-git-5.13.2/.github/ 0000775 0000000 0000000 00000000000 14744245500 0014335 5 ustar 00root root 0000000 0000000 go-git-5.13.2/.github/dependabot.yaml 0000664 0000000 0000000 00000000773 14744245500 0017335 0 ustar 00root root 0000000 0000000 version: 2
updates:
- package-ecosystem: "github-actions"
directory: "/"
schedule:
interval: "weekly"
commit-message:
prefix: "build"
- package-ecosystem: "gomod"
directory: "/"
schedule:
interval: "daily"
commit-message:
prefix: "build"
groups:
golang.org:
patterns:
- "golang.org/*"
- package-ecosystem: "gomod"
directory: "/cli/go-git"
schedule:
interval: "daily"
commit-message:
prefix: "build"
go-git-5.13.2/.github/workflows/ 0000775 0000000 0000000 00000000000 14744245500 0016372 5 ustar 00root root 0000000 0000000 go-git-5.13.2/.github/workflows/cifuzz.yml 0000664 0000000 0000000 00000001751 14744245500 0020433 0 ustar 00root root 0000000 0000000 name: CIFuzz
on: [pull_request]
permissions: {}
jobs:
Fuzzing:
runs-on: ubuntu-latest
permissions:
security-events: write
steps:
- name: Build Fuzzers
id: build
uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
with:
oss-fuzz-project-name: 'go-git'
language: go
- name: Run Fuzzers
uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
with:
oss-fuzz-project-name: 'go-git'
language: go
fuzz-seconds: 300
output-sarif: true
- name: Upload Crash
uses: actions/upload-artifact@v4
if: failure() && steps.build.outcome == 'success'
with:
name: artifacts
path: ./out/artifacts
- name: Upload Sarif
if: always() && steps.build.outcome == 'success'
uses: github/codeql-action/upload-sarif@v3.28.1
with:
# Path to SARIF file relative to the root of the repository
sarif_file: cifuzz-sarif/results.sarif
checkout_path: cifuzz-sarif
go-git-5.13.2/.github/workflows/codeql.yml 0000664 0000000 0000000 00000002367 14744245500 0020374 0 ustar 00root root 0000000 0000000 name: "CodeQL"
on:
push:
branches: [ "master" ]
pull_request:
branches: [ "master" ]
schedule:
- cron: '00 5 * * 1'
jobs:
analyze:
name: Analyze
runs-on: ubuntu-latest
permissions:
actions: read
contents: read
security-events: write
strategy:
fail-fast: false
matrix:
language: [ 'go' ]
steps:
- name: Checkout code
uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
# Initializes the CodeQL tools for scanning.
- name: Initialize CodeQL
uses: github/codeql-action/init@1f86f55dce064513e2111b0d4fc7cfb11444c092 # v2.22.11
with:
languages: ${{ matrix.language }}
# xref: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
# xref: https://codeql.github.com/codeql-query-help/go/
queries: security-and-quality
- name: Manual Build
run: go build ./...
- name: Perform CodeQL Analysis
uses: github/codeql-action/analyze@1f86f55dce064513e2111b0d4fc7cfb11444c092 # v2.22.11
with:
category: "/language:${{matrix.language}}"
go-git-5.13.2/.github/workflows/git.yml 0000664 0000000 0000000 00000002330 14744245500 0017676 0 ustar 00root root 0000000 0000000 on: [push, pull_request]
name: Git Compatibility
permissions:
contents: read
jobs:
test:
strategy:
fail-fast: false
matrix:
git: [[master, ubuntu-latest], [v2.11.0, ubuntu-latest]]
runs-on: ${{ matrix.git[1] }}
env:
GIT_VERSION: ${{ matrix.git[0] }}
GIT_DIST_PATH: .git-dist/${{ matrix.git[0] }}
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Install Go
uses: actions/setup-go@v5
with:
go-version: 1.23.x
- name: Install build dependencies
run: sudo apt-get update && sudo apt-get install gettext libcurl4-openssl-dev
- name: Git Build
run: make build-git
- name: Set Git config
run: |
export GIT_DIST_PATH=.git-dist/${{ matrix.git[0] }}
export GIT_EXEC_PATH=${{ github.workspace }}/$GIT_DIST_PATH
export PATH=$GIT_EXEC_PATH:$PATH
git --exec-path
git config --global user.email "gha@example.com"
git config --global user.name "GitHub Actions"
- name: Test
run: make test-coverage
- name: Test SHA256
run: make test-sha256
- name: Build go-git with CGO disabled
run: go build ./...
env:
CGO_ENABLED: 0
go-git-5.13.2/.github/workflows/pr-validation.yml 0000664 0000000 0000000 00000001520 14744245500 0021664 0 ustar 00root root 0000000 0000000 name: 'PR Validation'
on:
pull_request:
types:
- opened
- edited
- reopened
- synchronize
permissions:
contents: read
jobs:
check-commit-message:
name: Check Commit Messages
runs-on: ubuntu-latest
steps:
- name: Check Package Prefix
uses: gsactions/commit-message-checker@v2
with:
pattern: '^(\*|docs|git|plumbing|utils|config|_examples|internal|storage|cli|build): .+'
error: |
Commit message(s) does not align with contribution acceptance criteria.
Refer to https://github.com/go-git/go-git/blob/master/CONTRIBUTING.md#format-of-the-commit-message for more information.
excludeDescription: 'true'
excludeTitle: 'true'
checkAllCommitMessages: 'true'
accessToken: ${{ secrets.GITHUB_TOKEN }}
go-git-5.13.2/.github/workflows/stale-issues-bot.yaml 0000664 0000000 0000000 00000002101 14744245500 0022453 0 ustar 00root root 0000000 0000000 name: "stale issues bot"
on:
schedule:
- cron: "0 7 * * *"
permissions:
issues: write
pull-requests: write
jobs:
stale-bot:
runs-on: ubuntu-latest
steps:
- uses: actions/stale@v9
with:
ascending: true
operations-per-run: 30
days-before-stale: 180
days-before-close: 30
stale-issue-label: stale
stale-pr-label: stale
exempt-issue-labels: no-autoclose
repo-token: ${{ secrets.GITHUB_TOKEN }}
stale-issue-message: |
To help us keep things tidy and focus on the active tasks, we've introduced a stale bot to spot issues/PRs that haven't had any activity in a while.
This particular issue hasn't had any updates or activity in the past 90 days, so it's been labeled as 'stale'. If it remains inactive for the next 30 days, it'll be automatically closed.
We understand everyone's busy, but if this issue is still important to you, please feel free to add a comment or make an update to keep it active.
Thanks for your understanding and cooperation!
go-git-5.13.2/.github/workflows/test.yml 0000664 0000000 0000000 00000001732 14744245500 0020077 0 ustar 00root root 0000000 0000000 on: [push, pull_request]
name: Test
permissions:
contents: read
jobs:
version-matrix:
strategy:
fail-fast: false
matrix:
go-version: [1.21.x, 1.22.x, 1.23.x]
platform: [ubuntu-latest, macos-latest, windows-latest]
runs-on: ${{ matrix.platform }}
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Install Go
uses: actions/setup-go@v5
with:
go-version: ${{ matrix.go-version }}
- name: Configure known hosts
if: matrix.platform != 'ubuntu-latest'
run: |
mkdir -p ~/.ssh
ssh-keyscan -H github.com > ~/.ssh/known_hosts
- name: Set Git config
run: |
git config --global user.email "gha@example.com"
git config --global user.name "GitHub Actions"
- name: Test
run: make test-coverage
- name: Test Examples
run: go test -timeout 30s -v -run '^TestExamples$' github.com/go-git/go-git/v5/_examples --examples
go-git-5.13.2/.gitignore 0000664 0000000 0000000 00000000102 14744245500 0014756 0 ustar 00root root 0000000 0000000 coverage.out
*~
coverage.txt
profile.out
.tmp/
.git-dist/
.vscode
go-git-5.13.2/CODE_OF_CONDUCT.md 0000664 0000000 0000000 00000006235 14744245500 0015602 0 ustar 00root root 0000000 0000000 # Contributor Covenant Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as
contributors and maintainers pledge to making participation in our project and
our community a harassment-free experience for everyone, regardless of age, body
size, disability, ethnicity, gender identity and expression, level of experience,
education, socio-economic status, nationality, personal appearance, race,
religion, or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment
include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or
advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic
address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable
behavior and are expected to take appropriate and fair corrective action in
response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or
reject comments, commits, code, wiki edits, issues, and other contributions
that are not aligned to this Code of Conduct, or to ban temporarily or
permanently any contributor for other behaviors that they deem inappropriate,
threatening, offensive, or harmful.
## Scope
This Code of Conduct applies both within project spaces and in public spaces
when an individual is representing the project or its community. Examples of
representing a project or community include using an official project e-mail
address, posting via an official social media account, or acting as an appointed
representative at an online or offline event. Representation of a project may be
further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported by contacting the project team at conduct@sourced.tech. All
complaints will be reviewed and investigated and will result in a response that
is deemed necessary and appropriate to the circumstances. The project team is
obligated to maintain confidentiality with regard to the reporter of an incident.
Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good
faith may face temporary or permanent repercussions as determined by other
members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
[homepage]: https://www.contributor-covenant.org
go-git-5.13.2/COMPATIBILITY.md 0000664 0000000 0000000 00000052321 14744245500 0015333 0 ustar 00root root 0000000 0000000 # Supported Features
Here is a non-comprehensive table of git commands and features and their
compatibility status with go-git.
## Getting and creating repositories
| Feature | Sub-feature | Status | Notes | Examples |
| ------- | ------------------------------------------------------------------------------------------------------------------ | ------ | ----- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `init` | | ✅ | | |
| `init` | `--bare` | ✅ | | |
| `init` | `--template`
`--separate-git-dir`
`--shared` | ❌ | | |
| `clone` | | ✅ | | - [PlainClone](_examples/clone/main.go) |
| `clone` | Authentication:
- none
- access token
- username + password
- ssh | ✅ | | - [clone ssh (private_key)](_examples/clone/auth/ssh/private_key/main.go)
- [clone ssh (ssh_agent)](_examples/clone/auth/ssh/ssh_agent/main.go)
- [clone access token](_examples/clone/auth/basic/access_token/main.go)
- [clone user + password](_examples/clone/auth/basic/username_password/main.go) |
| `clone` | `--progress`
`--single-branch`
`--depth`
`--origin`
`--recurse-submodules`
`--shared` | ✅ | | - [recurse submodules](_examples/clone/main.go)
- [progress](_examples/progress/main.go) |
## Basic snapshotting
| Feature | Sub-feature | Status | Notes | Examples |
| -------- | ----------- | ------ | -------------------------------------------------------- | ------------------------------------ |
| `add` | | ✅ | Plain add is supported. Any other flags aren't supported | |
| `status` | | ✅ | | |
| `commit` | | ✅ | | - [commit](_examples/commit/main.go) |
| `reset` | | ✅ | | |
| `rm` | | ✅ | | |
| `mv` | | ✅ | | |
## Branching and merging
| Feature | Sub-feature | Status | Notes | Examples |
| ----------- | ----------- | ------------ | --------------------------------------- | ----------------------------------------------------------------------------------------------- |
| `branch` | | ✅ | | - [branch](_examples/branch/main.go) |
| `checkout` | | ✅ | Basic usages of checkout are supported. | - [checkout](_examples/checkout/main.go) |
| `merge` | | ⚠️ (partial) | Fast-forward only | |
| `mergetool` | | ❌ | | |
| `stash` | | ❌ | | |
| `sparse-checkout` | | ✅ | | - [sparse-checkout](_examples/sparse-checkout/main.go) |
| `tag` | | ✅ | | - [tag](_examples/tag/main.go)
- [tag create and push](_examples/tag-create-push/main.go) |
## Sharing and updating projects
| Feature | Sub-feature | Status | Notes | Examples |
| ----------- | ----------- | ------ | ----------------------------------------------------------------------- | ------------------------------------------ |
| `fetch` | | ✅ | | |
| `pull` | | ✅ | Only supports merges where the merge can be resolved as a fast-forward. | - [pull](_examples/pull/main.go) |
| `push` | | ✅ | | - [push](_examples/push/main.go) |
| `remote` | | ✅ | | - [remotes](_examples/remotes/main.go) |
| `submodule` | | ✅ | | - [submodule](_examples/submodule/main.go) |
| `submodule` | deinit | ❌ | | |
## Inspection and comparison
| Feature | Sub-feature | Status | Notes | Examples |
| ---------- | ----------- | --------- | ----- | ------------------------------ |
| `show` | | ✅ | | |
| `log` | | ✅ | | - [log](_examples/log/main.go) |
| `shortlog` | | (see log) | | |
| `describe` | | ❌ | | |
## Patching
| Feature | Sub-feature | Status | Notes | Examples |
| ------------- | ----------- | ------ | ---------------------------------------------------- | -------- |
| `apply` | | ❌ | | |
| `cherry-pick` | | ❌ | | |
| `diff` | | ✅ | Patch object with UnifiedDiff output representation. | |
| `rebase` | | ❌ | | |
| `revert` | | ❌ | | |
## Debugging
| Feature | Sub-feature | Status | Notes | Examples |
| -------- | ----------- | ------ | ----- | ---------------------------------- |
| `bisect` | | ❌ | | |
| `blame` | | ✅ | | - [blame](_examples/blame/main.go) |
| `grep` | | ✅ | | |
## Email
| Feature | Sub-feature | Status | Notes | Examples |
| -------------- | ----------- | ------ | ----- | -------- |
| `am` | | ❌ | | |
| `apply` | | ❌ | | |
| `format-patch` | | ❌ | | |
| `send-email` | | ❌ | | |
| `request-pull` | | ❌ | | |
## External systems
| Feature | Sub-feature | Status | Notes | Examples |
| ------------- | ----------- | ------ | ----- | -------- |
| `svn` | | ❌ | | |
| `fast-import` | | ❌ | | |
| `lfs` | | ❌ | | |
## Administration
| Feature | Sub-feature | Status | Notes | Examples |
| --------------- | ----------- | ------ | ----- | -------- |
| `clean` | | ✅ | | |
| `gc` | | ❌ | | |
| `fsck` | | ❌ | | |
| `reflog` | | ❌ | | |
| `filter-branch` | | ❌ | | |
| `instaweb` | | ❌ | | |
| `archive` | | ❌ | | |
| `bundle` | | ❌ | | |
| `prune` | | ❌ | | |
| `repack` | | ❌ | | |
## Server admin
| Feature | Sub-feature | Status | Notes | Examples |
| -------------------- | ----------- | ------ | ----- | ----------------------------------------- |
| `daemon` | | ❌ | | |
| `update-server-info` | | ✅ | | [cli](./cli/go-git/update_server_info.go) |
## Advanced
| Feature | Sub-feature | Status | Notes | Examples |
| ---------- | ----------- | ----------- | ----- | -------- |
| `notes` | | ❌ | | |
| `replace` | | ❌ | | |
| `worktree` | | ❌ | | |
| `annotate` | | (see blame) | | |
## GPG
| Feature | Sub-feature | Status | Notes | Examples |
| ------------------- | ----------- | ------ | ----- | -------- |
| `git-verify-commit` | | ✅ | | |
| `git-verify-tag` | | ✅ | | |
## Plumbing commands
| Feature | Sub-feature | Status | Notes | Examples |
| --------------- | ------------------------------------- | ------------ | --------------------------------------------------- | -------------------------------------------- |
| `cat-file` | | ✅ | | |
| `check-ignore` | | ❌ | | |
| `commit-tree` | | ❌ | | |
| `count-objects` | | ❌ | | |
| `diff-index` | | ❌ | | |
| `for-each-ref` | | ✅ | | |
| `hash-object` | | ✅ | | |
| `ls-files` | | ✅ | | |
| `ls-remote` | | ✅ | | - [ls-remote](_examples/ls-remote/main.go) |
| `merge-base` | `--independent`
`--is-ancestor` | ⚠️ (partial) | Calculates the merge-base only between two commits. | - [merge-base](_examples/merge_base/main.go) |
| `merge-base` | `--fork-point`
`--octopus` | ❌ | | |
| `read-tree` | | ❌ | | |
| `rev-list` | | ✅ | | |
| `rev-parse` | | ❌ | | |
| `show-ref` | | ✅ | | |
| `symbolic-ref` | | ✅ | | |
| `update-index` | | ❌ | | |
| `update-ref` | | ❌ | | |
| `verify-pack` | | ❌ | | |
| `write-tree` | | ❌ | | |
## Indexes and Git Protocols
| Feature | Version | Status | Notes |
| -------------------- | ------------------------------------------------------------------------------- | ------ | ----- |
| index | [v1](https://github.com/git/git/blob/master/Documentation/gitformat-index.txt) | ❌ | |
| index | [v2](https://github.com/git/git/blob/master/Documentation/gitformat-index.txt) | ✅ | |
| index | [v3](https://github.com/git/git/blob/master/Documentation/gitformat-index.txt) | ❌ | |
| pack-protocol | [v1](https://github.com/git/git/blob/master/Documentation/gitprotocol-pack.txt) | ✅ | |
| pack-protocol | [v2](https://github.com/git/git/blob/master/Documentation/gitprotocol-v2.txt) | ❌ | |
| multi-pack-index | [v1](https://github.com/git/git/blob/master/Documentation/gitformat-pack.txt) | ❌ | |
| pack-\*.rev files | [v1](https://github.com/git/git/blob/master/Documentation/gitformat-pack.txt) | ❌ | |
| pack-\*.mtimes files | [v1](https://github.com/git/git/blob/master/Documentation/gitformat-pack.txt) | ❌ | |
| cruft packs | | ❌ | |
## Capabilities
| Feature | Status | Notes |
| ------------------------------ | ------------ | ----- |
| `multi_ack` | ❌ | |
| `multi_ack_detailed` | ❌ | |
| `no-done` | ❌ | |
| `thin-pack` | ❌ | |
| `side-band` | ⚠️ (partial) | |
| `side-band-64k` | ⚠️ (partial) | |
| `ofs-delta` | ✅ | |
| `agent` | ✅ | |
| `object-format` | ❌ | |
| `symref` | ✅ | |
| `shallow` | ✅ | |
| `deepen-since` | ✅ | |
| `deepen-not` | ❌ | |
| `deepen-relative` | ❌ | |
| `no-progress` | ✅ | |
| `include-tag` | ✅ | |
| `report-status` | ✅ | |
| `report-status-v2` | ❌ | |
| `delete-refs` | ✅ | |
| `quiet` | ❌ | |
| `atomic` | ✅ | |
| `push-options` | ✅ | |
| `allow-tip-sha1-in-want` | ✅ | |
| `allow-reachable-sha1-in-want` | ❌ | |
| `push-cert=` | ❌ | |
| `filter` | ❌ | |
| `session-id=` | ❌ | |
## Transport Schemes
| Scheme | Status | Notes | Examples |
| -------------------- | ------------ | ---------------------------------------------------------------------- | ---------------------------------------------- |
| `http(s)://` (dumb) | ❌ | | |
| `http(s)://` (smart) | ✅ | | |
| `git://` | ✅ | | |
| `ssh://` | ✅ | | |
| `file://` | ⚠️ (partial) | Warning: this is not pure Golang. This shells out to the `git` binary. | |
| Custom | ✅ | All existing schemes can be replaced by custom implementations. | - [custom_http](_examples/custom_http/main.go) |
## SHA256
| Feature | Sub-feature | Status | Notes | Examples |
| -------- | ----------- | ------ | ---------------------------------- | ------------------------------------ |
| `init` | | ✅ | Requires building with tag sha256. | - [init](_examples/sha256/main.go) |
| `commit` | | ✅ | Requires building with tag sha256. | - [commit](_examples/sha256/main.go) |
| `pull` | | ❌ | | |
| `fetch` | | ❌ | | |
| `push` | | ❌ | | |
## Other features
| Feature | Sub-feature | Status | Notes | Examples |
| --------------- | --------------------------- | ------ | ---------------------------------------------- | -------- |
| `config` | `--local` | ✅ | Read and write per-repository (`.git/config`). | |
| `config` | `--global`
`--system` | ✅ | Read-only. | |
| `gitignore` | | ✅ | | |
| `gitattributes` | | ✅ | | |
| `git-worktree` | | ❌ | Multiple worktrees are not supported. | |
go-git-5.13.2/CONTRIBUTING.md 0000664 0000000 0000000 00000005322 14744245500 0015230 0 ustar 00root root 0000000 0000000 # Contributing Guidelines
source{d} go-git project is [Apache 2.0 licensed](LICENSE) and accepts
contributions via GitHub pull requests. This document outlines some of the
conventions on development workflow, commit message formatting, contact points,
and other resources to make it easier to get your contribution accepted.
## Support Channels
The official support channels, for both users and contributors, are:
- [StackOverflow go-git tag](https://stackoverflow.com/questions/tagged/go-git) for user questions.
- GitHub [Issues](https://github.com/src-d/go-git/issues)* for bug reports and feature requests.
*Before opening a new issue or submitting a new pull request, it's helpful to
search the project - it's likely that another user has already reported the
issue you're facing, or it's a known issue that we're already aware of.
## How to Contribute
Pull Requests (PRs) are the main and exclusive way to contribute to the official go-git project.
In order for a PR to be accepted it needs to pass a list of requirements:
- You should be able to run the same query using `git`. We don't accept features that are not implemented in the official git implementation.
- The expected behavior must match the [official git implementation](https://github.com/git/git).
- The actual behavior must be correctly explained with natural language and providing a minimum working example in Go that reproduces it.
- All PRs must be written in idiomatic Go, formatted according to [gofmt](https://golang.org/cmd/gofmt/), and without any warnings from [go lint](https://github.com/golang/lint) nor [go vet](https://golang.org/cmd/vet/).
- They should in general include tests, and those shall pass.
- If the PR is a bug fix, it has to include a suite of unit tests for the new functionality.
- If the PR is a new feature, it has to come with a suite of unit tests, that tests the new functionality.
- In any case, all the PRs have to pass the personal evaluation of at least one of the maintainers of go-git.
### Branches
The `master` branch is currently used for maintaining the `v5` major release only. The accepted changes would
be dependency bumps, bug fixes and small changes that aren't needed for `v6`. New development should target the
`v6-exp` branch, and if agreed with at least one go-git maintainer, it can be back ported to `v5` by creating
a new PR that targets `master`.
### Format of the commit message
Every commit message should describe what was changed, under which context and, if applicable, the GitHub issue it relates to:
```
plumbing: packp, Skip argument validations for unknown capabilities. Fixes #623
```
The format can be described more formally as follows:
```
: , . [Fixes #]
```
go-git-5.13.2/EXTENDING.md 0000664 0000000 0000000 00000006302 14744245500 0014645 0 ustar 00root root 0000000 0000000 # Extending go-git
`go-git` was built in a highly extensible manner, which enables some of its functionalities to be changed or extended without the need of changing its codebase. Here are the key extensibility features:
## Dot Git Storers
Dot git storers are the components responsible for storing the Git internal files, including objects and references.
The built-in storer implementations include [memory](storage/memory) and [filesystem](storage/filesystem). The `memory` storer stores all the data in memory, and its use look like this:
```go
r, err := git.Init(memory.NewStorage(), nil)
```
The `filesystem` storer stores the data in the OS filesystem, and can be used as follows:
```go
r, err := git.Init(filesystem.NewStorage(osfs.New("/tmp/foo")), nil)
```
New implementations can be created by implementing the [storage.Storer interface](storage/storer.go#L16).
## Filesystem
Git repository worktrees are managed using a filesystem abstraction based on [go-billy](https://github.com/go-git/go-billy). The Git operations will take place against the specific filesystem implementation. Initialising a repository in Memory can be done as follows:
```go
fs := memfs.New()
r, err := git.Init(memory.NewStorage(), fs)
```
The same operation can be done against the OS filesystem:
```go
fs := osfs.New("/tmp/foo")
r, err := git.Init(memory.NewStorage(), fs)
```
New filesystems (e.g. cloud based storage) could be created by implementing `go-billy`'s [Filesystem interface](https://github.com/go-git/go-billy/blob/326c59f064021b821a55371d57794fbfb86d4cb3/fs.go#L52).
## Transport Schemes
Git supports various transport schemes, including `http`, `https`, `ssh`, `git`, `file`. `go-git` defines the [transport.Transport interface](plumbing/transport/common.go#L48) to represent them.
The built-in implementations can be replaced by calling `client.InstallProtocol`.
An example of changing the built-in `https` implementation to skip TLS could look like this:
```go
customClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
client.InstallProtocol("https", githttp.NewClient(customClient))
```
Some internal implementations enables code reuse amongst the different transport implementations. Some of these may be made public in the future (e.g. `plumbing/transport/internal/common`).
## Cache
Several different operations across `go-git` lean on caching of objects in order to achieve optimal performance. The caching functionality is defined by the [cache.Object interface](plumbing/cache/common.go#L17).
Two built-in implementations are `cache.ObjectLRU` and `cache.BufferLRU`. However, the caching functionality can be customized by implementing the interface `cache.Object` interface.
## Hash
`go-git` uses the `crypto.Hash` interface to represent hash functions. The built-in implementations are `github.com/pjbgf/sha1cd` for SHA1 and Go's `crypto/SHA256`.
The default hash functions can be changed by calling `hash.RegisterHash`.
```go
func init() {
hash.RegisterHash(crypto.SHA1, sha1.New)
}
```
New `SHA1` or `SHA256` hash functions that implement the `hash.RegisterHash` interface can be registered by calling `RegisterHash`.
go-git-5.13.2/LICENSE 0000664 0000000 0000000 00000026134 14744245500 0014010 0 ustar 00root root 0000000 0000000 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
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2018 Sourced Technologies, S.L.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
go-git-5.13.2/Makefile 0000664 0000000 0000000 00000002717 14744245500 0014444 0 ustar 00root root 0000000 0000000 # General
WORKDIR = $(PWD)
# Go parameters
GOCMD = go
GOTEST = $(GOCMD) test
# Git config
GIT_VERSION ?=
GIT_DIST_PATH ?= $(PWD)/.git-dist
GIT_REPOSITORY = http://github.com/git/git.git
# Coverage
COVERAGE_REPORT = coverage.out
COVERAGE_MODE = count
build-git:
@if [ -f $(GIT_DIST_PATH)/git ]; then \
echo "nothing to do, using cache $(GIT_DIST_PATH)"; \
else \
git clone $(GIT_REPOSITORY) -b $(GIT_VERSION) --depth 1 --single-branch $(GIT_DIST_PATH); \
cd $(GIT_DIST_PATH); \
make configure; \
./configure; \
make all; \
fi
test:
@echo "running against `git version`"; \
$(GOTEST) -race ./...
$(GOTEST) -v _examples/common_test.go _examples/common.go --examples
TEMP_REPO := $(shell mktemp)
test-sha256:
$(GOCMD) run -tags sha256 _examples/sha256/main.go $(TEMP_REPO)
cd $(TEMP_REPO) && git fsck
rm -rf $(TEMP_REPO)
test-coverage:
@echo "running against `git version`"; \
echo "" > $(COVERAGE_REPORT); \
$(GOTEST) -coverprofile=$(COVERAGE_REPORT) -coverpkg=./... -covermode=$(COVERAGE_MODE) ./...
clean:
rm -rf $(GIT_DIST_PATH)
fuzz:
@go test -fuzz=FuzzParser $(PWD)/internal/revision
@go test -fuzz=FuzzDecoder $(PWD)/plumbing/format/config
@go test -fuzz=FuzzPatchDelta $(PWD)/plumbing/format/packfile
@go test -fuzz=FuzzParseSignedBytes $(PWD)/plumbing/object
@go test -fuzz=FuzzDecode $(PWD)/plumbing/object
@go test -fuzz=FuzzDecoder $(PWD)/plumbing/protocol/packp
@go test -fuzz=FuzzNewEndpoint $(PWD)/plumbing/transport
go-git-5.13.2/README.md 0000664 0000000 0000000 00000011461 14744245500 0014257 0 ustar 00root root 0000000 0000000 
[](https://pkg.go.dev/github.com/go-git/go-git/v5) [](https://github.com/go-git/go-git/actions) [](https://goreportcard.com/report/github.com/go-git/go-git)
*go-git* is a highly extensible git implementation library written in **pure Go**.
It can be used to manipulate git repositories at low level *(plumbing)* or high level *(porcelain)*, through an idiomatic Go API. It also supports several types of storage, such as in-memory filesystems, or custom implementations, thanks to the [`Storer`](https://pkg.go.dev/github.com/go-git/go-git/v5/plumbing/storer) interface.
It's being actively developed since 2015 and is being used extensively by [Keybase](https://keybase.io/blog/encrypted-git-for-everyone), [Gitea](https://gitea.io/en-us/) or [Pulumi](https://github.com/search?q=org%3Apulumi+go-git&type=Code), and by many other libraries and tools.
Project Status
--------------
After the legal issues with the [`src-d`](https://github.com/src-d) organization, the lack of update for four months and the requirement to make a hard fork, the project is **now back to normality**.
The project is currently actively maintained by individual contributors, including several of the original authors, but also backed by a new company, [gitsight](https://github.com/gitsight), where `go-git` is a critical component used at scale.
Comparison with git
-------------------
*go-git* aims to be fully compatible with [git](https://github.com/git/git), all the *porcelain* operations are implemented to work exactly as *git* does.
*git* is a humongous project with years of development by thousands of contributors, making it challenging for *go-git* to implement all the features. You can find a comparison of *go-git* vs *git* in the [compatibility documentation](COMPATIBILITY.md).
Installation
------------
The recommended way to install *go-git* is:
```go
import "github.com/go-git/go-git/v5" // with go modules enabled (GO111MODULE=on or outside GOPATH)
import "github.com/go-git/go-git" // with go modules disabled
```
Examples
--------
> Please note that the `CheckIfError` and `Info` functions used in the examples are from the [examples package](https://github.com/go-git/go-git/blob/master/_examples/common.go#L19) just to be used in the examples.
### Basic example
A basic example that mimics the standard `git clone` command
```go
// Clone the given repository to the given directory
Info("git clone https://github.com/go-git/go-git")
_, err := git.PlainClone("/tmp/foo", false, &git.CloneOptions{
URL: "https://github.com/go-git/go-git",
Progress: os.Stdout,
})
CheckIfError(err)
```
Outputs:
```
Counting objects: 4924, done.
Compressing objects: 100% (1333/1333), done.
Total 4924 (delta 530), reused 6 (delta 6), pack-reused 3533
```
### In-memory example
Cloning a repository into memory and printing the history of HEAD, just like `git log` does
```go
// Clones the given repository in memory, creating the remote, the local
// branches and fetching the objects, exactly as:
Info("git clone https://github.com/go-git/go-billy")
r, err := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
URL: "https://github.com/go-git/go-billy",
})
CheckIfError(err)
// Gets the HEAD history from HEAD, just like this command:
Info("git log")
// ... retrieves the branch pointed by HEAD
ref, err := r.Head()
CheckIfError(err)
// ... retrieves the commit history
cIter, err := r.Log(&git.LogOptions{From: ref.Hash()})
CheckIfError(err)
// ... just iterates over the commits, printing it
err = cIter.ForEach(func(c *object.Commit) error {
fmt.Println(c)
return nil
})
CheckIfError(err)
```
Outputs:
```
commit ded8054fd0c3994453e9c8aacaf48d118d42991e
Author: Santiago M. Mola
Date: Sat Nov 12 21:18:41 2016 +0100
index: ReadFrom/WriteTo returns IndexReadError/IndexWriteError. (#9)
commit df707095626f384ce2dc1a83b30f9a21d69b9dfc
Author: Santiago M. Mola
Date: Fri Nov 11 13:23:22 2016 +0100
readwriter: fix bug when writing index. (#10)
When using ReadWriter on an existing siva file, absolute offset for
index entries was not being calculated correctly.
...
```
You can find this [example](_examples/log/main.go) and many others in the [examples](_examples) folder.
Contribute
----------
[Contributions](https://github.com/go-git/go-git/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) are more than welcome, if you are interested please take a look to
our [Contributing Guidelines](CONTRIBUTING.md).
License
-------
Apache License Version 2.0, see [LICENSE](LICENSE)
go-git-5.13.2/SECURITY.md 0000664 0000000 0000000 00000003263 14744245500 0014572 0 ustar 00root root 0000000 0000000 # go-git Security Policy
The purpose of this security policy is to outline `go-git`'s process
for reporting, handling and disclosing security sensitive information.
## Supported Versions
The project follows a version support policy where only the latest minor
release is actively supported. Therefore, only issues that impact the latest
minor release will be fixed. Users are encouraged to upgrade to the latest
minor/patch release to benefit from the most up-to-date features, bug fixes,
and security enhancements.
The supported versions policy applies to both the `go-git` library and its
associated repositories within the `go-git` org.
## Reporting Security Issues
Please report any security vulnerabilities or potential weaknesses in `go-git`
privately via go-git-security@googlegroups.com. Do not publicly disclose the
details of the vulnerability until a fix has been implemented and released.
During the process the project maintainers will investigate the report, so please
provide detailed information, including steps to reproduce, affected versions, and any mitigations if known.
The project maintainers will acknowledge the receipt of the report and work with
the reporter to validate and address the issue.
Please note that `go-git` does not have any bounty programs, and therefore do
not provide financial compensation for disclosures.
## Security Disclosure Process
The project maintainers will make every effort to promptly address security issues.
Once a security vulnerability is fixed, a security advisory will be published to notify users and provide appropriate mitigation measures.
All `go-git` advisories can be found at https://github.com/go-git/go-git/security/advisories.
go-git-5.13.2/_examples/ 0000775 0000000 0000000 00000000000 14744245500 0014752 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/README.md 0000664 0000000 0000000 00000004457 14744245500 0016243 0 ustar 00root root 0000000 0000000 # go-git: examples
Here you can find a list of annotated _go-git_ examples:
### Basic
- [showcase](showcase/main.go) - A small showcase of the capabilities of _go-git_.
- [open](open/main.go) - Opening a existing repository cloned by _git_.
- [clone](clone/main.go) - Cloning a repository.
- [username and password](clone/auth/basic/username_password/main.go) - Cloning a repository
using a username and password.
- [personal access token](clone/auth/basic/access_token/main.go) - Cloning
a repository using a GitHub personal access token.
- [ssh private key](clone/auth/ssh/private_key/main.go) - Cloning a repository using a ssh private key.
- [ssh agent](clone/auth/ssh/ssh_agent/main.go) - Cloning a repository using ssh-agent.
- [commit](commit/main.go) - Commit changes to the current branch to an existent repository.
- [push](push/main.go) - Push repository to default remote (origin).
- [pull](pull/main.go) - Pull changes from a remote repository.
- [checkout](checkout/main.go) - Check out a specific commit from a repository.
- [log](log/main.go) - Emulate `git log` command output iterating all the commit history from HEAD reference.
- [branch](branch/main.go) - How to create and remove branches or any other kind of reference.
- [tag](tag/main.go) - List/print repository tags.
- [tag create and push](tag-create-push/main.go) - Create and push a new tag.
- [tag find if head is tagged](find-if-any-tag-point-head/main.go) - Find if `HEAD` is tagged.
- [remotes](remotes/main.go) - Working with remotes: adding, removing, etc.
- [progress](progress/main.go) - Printing the progress information from the sideband.
- [revision](revision/main.go) - Solve a revision into a commit.
- [submodule](submodule/main.go) - Submodule update remote.
- [azure devops](azure_devops/main.go) - Cloning Azure DevOps repositories.
- [blame](blame/main.go) - Blame/annotate a commit.
- [ls-remote](ls-remote/main.go) - List remote tags without cloning a repository.
### Advanced
- [custom_http](custom_http/main.go) - Replacing the HTTP client using a custom one.
- [clone with context](context/main.go) - Cloning a repository with graceful cancellation.
- [storage](storage/README.md) - Implementing a custom storage system.
- [sha256](sha256/main.go) - Init and committing repositories that use sha256 as object format.
go-git-5.13.2/_examples/azure_devops/ 0000775 0000000 0000000 00000000000 14744245500 0017460 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/azure_devops/main.go 0000664 0000000 0000000 00000003257 14744245500 0020742 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
git "github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/http"
)
func main() {
CheckArgs("", "", "", "")
url, directory, username, password := os.Args[1], os.Args[2], os.Args[3], os.Args[4]
// Clone the given repository to the given directory
Info("git clone %s %s", url, directory)
// Azure DevOps requires capabilities multi_ack / multi_ack_detailed,
// which are not fully implemented and by default are included in
// transport.UnsupportedCapabilities.
//
// The initial clone operations require a full download of the repository,
// and therefore those unsupported capabilities are not as crucial, so
// by removing them from that list allows for the first clone to work
// successfully.
//
// Additional fetches will yield issues, therefore work always from a clean
// clone until those capabilities are fully supported.
//
// New commits and pushes against a remote worked without any issues.
transport.UnsupportedCapabilities = []capability.Capability{
capability.ThinPack,
}
r, err := git.PlainClone(directory, false, &git.CloneOptions{
Auth: &http.BasicAuth{
Username: username,
Password: password,
},
URL: url,
Progress: os.Stdout,
})
CheckIfError(err)
// ... retrieving the branch being pointed by HEAD
ref, err := r.Head()
CheckIfError(err)
// ... retrieving the commit object
commit, err := r.CommitObject(ref.Hash())
CheckIfError(err)
fmt.Println(commit)
}
go-git-5.13.2/_examples/blame/ 0000775 0000000 0000000 00000000000 14744245500 0016032 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/blame/main.go 0000664 0000000 0000000 00000001517 14744245500 0017311 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
)
// Basic example of how to blame a repository.
func main() {
CheckArgs("", "")
url := os.Args[1]
path := os.Args[2]
tmp, err := os.MkdirTemp("", "go-git-blame-*")
CheckIfError(err)
defer os.RemoveAll(tmp)
// Clone the given repository.
Info("git clone %s %s", url, tmp)
r, err := git.PlainClone(
tmp,
false,
&git.CloneOptions{
URL: url,
Tags: git.NoTags,
},
)
CheckIfError(err)
// Retrieve the branch's HEAD, to then get the HEAD commit.
ref, err := r.Head()
CheckIfError(err)
c, err := r.CommitObject(ref.Hash())
CheckIfError(err)
Info("git blame %s", path)
// Blame the given file/path.
br, err := git.Blame(c, path)
CheckIfError(err)
fmt.Printf("%s", br.String())
}
go-git-5.13.2/_examples/branch/ 0000775 0000000 0000000 00000000000 14744245500 0016207 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/branch/main.go 0000664 0000000 0000000 00000002344 14744245500 0017465 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing"
)
// An example of how to create and remove branches or any other kind of reference.
func main() {
CheckArgs("", "")
url, directory := os.Args[1], os.Args[2]
// Clone the given repository to the given directory
Info("git clone %s %s", url, directory)
r, err := git.PlainClone(directory, false, &git.CloneOptions{
URL: url,
})
CheckIfError(err)
// Create a new branch to the current HEAD
Info("git branch my-branch")
headRef, err := r.Head()
CheckIfError(err)
// Create a new plumbing.HashReference object with the name of the branch
// and the hash from the HEAD. The reference name should be a full reference
// name and not an abbreviated one, as is used on the git cli.
//
// For tags we should use `refs/tags/%s` instead of `refs/heads/%s` used
// for branches.
ref := plumbing.NewHashReference("refs/heads/my-branch", headRef.Hash())
// The created reference is saved in the storage.
err = r.Storer.SetReference(ref)
CheckIfError(err)
// Or deleted from it.
Info("git branch -D my-branch")
err = r.Storer.RemoveReference(ref.Name())
CheckIfError(err)
}
go-git-5.13.2/_examples/checkout-branch/ 0000775 0000000 0000000 00000000000 14744245500 0020012 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/checkout-branch/main.go 0000664 0000000 0000000 00000004156 14744245500 0021273 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
)
// Checkout a branch
func main() {
CheckArgs("", "", "")
url, directory, branch := os.Args[1], os.Args[2], os.Args[3]
// Clone the given repository to the given directory
Info("git clone %s %s", url, directory)
r, err := git.PlainClone(directory, false, &git.CloneOptions{
URL: url,
})
CheckIfError(err)
// ... retrieving the commit being pointed by HEAD
Info("git show-ref --head HEAD")
ref, err := r.Head()
CheckIfError(err)
fmt.Println(ref.Hash())
w, err := r.Worktree()
CheckIfError(err)
// ... checking out branch
Info("git checkout %s", branch)
branchRefName := plumbing.NewBranchReferenceName(branch)
branchCoOpts := git.CheckoutOptions{
Branch: plumbing.ReferenceName(branchRefName),
Force: true,
}
if err := w.Checkout(&branchCoOpts); err != nil {
Warning("local checkout of branch '%s' failed, will attempt to fetch remote branch of same name.", branch)
Warning("like `git checkout ` defaulting to `git checkout -b --track /`")
mirrorRemoteBranchRefSpec := fmt.Sprintf("refs/heads/%s:refs/heads/%s", branch, branch)
err = fetchOrigin(r, mirrorRemoteBranchRefSpec)
CheckIfError(err)
err = w.Checkout(&branchCoOpts)
CheckIfError(err)
}
CheckIfError(err)
Info("checked out branch: %s", branch)
// ... retrieving the commit being pointed by HEAD (branch now)
Info("git show-ref --head HEAD")
ref, err = r.Head()
CheckIfError(err)
fmt.Println(ref.Hash())
}
func fetchOrigin(repo *git.Repository, refSpecStr string) error {
remote, err := repo.Remote("origin")
CheckIfError(err)
var refSpecs []config.RefSpec
if refSpecStr != "" {
refSpecs = []config.RefSpec{config.RefSpec(refSpecStr)}
}
if err = remote.Fetch(&git.FetchOptions{
RefSpecs: refSpecs,
}); err != nil {
if err == git.NoErrAlreadyUpToDate {
fmt.Print("refs already up to date")
} else {
return fmt.Errorf("fetch origin failed: %v", err)
}
}
return nil
}
go-git-5.13.2/_examples/checkout/ 0000775 0000000 0000000 00000000000 14744245500 0016557 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/checkout/main.go 0000664 0000000 0000000 00000002144 14744245500 0020033 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing"
)
// Basic example of how to checkout a specific commit.
func main() {
CheckArgs("", "", "")
url, directory, commit := os.Args[1], os.Args[2], os.Args[3]
// Clone the given repository to the given directory
Info("git clone %s %s", url, directory)
r, err := git.PlainClone(directory, false, &git.CloneOptions{
URL: url,
})
CheckIfError(err)
// ... retrieving the commit being pointed by HEAD
Info("git show-ref --head HEAD")
ref, err := r.Head()
CheckIfError(err)
fmt.Println(ref.Hash())
w, err := r.Worktree()
CheckIfError(err)
// ... checking out to commit
Info("git checkout %s", commit)
err = w.Checkout(&git.CheckoutOptions{
Hash: plumbing.NewHash(commit),
})
CheckIfError(err)
// ... retrieving the commit being pointed by HEAD, it shows that the
// repository is pointing to the giving commit in detached mode
Info("git show-ref --head HEAD")
ref, err = r.Head()
CheckIfError(err)
fmt.Println(ref.Hash())
}
go-git-5.13.2/_examples/clone/ 0000775 0000000 0000000 00000000000 14744245500 0016052 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/clone/auth/ 0000775 0000000 0000000 00000000000 14744245500 0017013 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/clone/auth/basic/ 0000775 0000000 0000000 00000000000 14744245500 0020074 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/clone/auth/basic/access_token/ 0000775 0000000 0000000 00000000000 14744245500 0022535 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/clone/auth/basic/access_token/main.go 0000664 0000000 0000000 00000002117 14744245500 0024011 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
git "github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing/transport/http"
)
func main() {
CheckArgs("", "", "")
url, directory, token := os.Args[1], os.Args[2], os.Args[3]
// Clone the given repository to the given directory
Info("git clone %s %s", url, directory)
r, err := git.PlainClone(directory, false, &git.CloneOptions{
// The intended use of a GitHub personal access token is in replace of your password
// because access tokens can easily be revoked.
// https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/
Auth: &http.BasicAuth{
Username: "abc123", // yes, this can be anything except an empty string
Password: token,
},
URL: url,
Progress: os.Stdout,
})
CheckIfError(err)
// ... retrieving the branch being pointed by HEAD
ref, err := r.Head()
CheckIfError(err)
// ... retrieving the commit object
commit, err := r.CommitObject(ref.Hash())
CheckIfError(err)
fmt.Println(commit)
}
go-git-5.13.2/_examples/clone/auth/basic/username_password/ 0000775 0000000 0000000 00000000000 14744245500 0023635 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/clone/auth/basic/username_password/main.go 0000664 0000000 0000000 00000001542 14744245500 0025112 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
git "github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing/transport/http"
)
func main() {
CheckArgs("", "", "", "")
url, directory, username, password := os.Args[1], os.Args[2], os.Args[3], os.Args[4]
// Clone the given repository to the given directory
Info("git clone %s %s", url, directory)
r, err := git.PlainClone(directory, false, &git.CloneOptions{
Auth: &http.BasicAuth{
Username: username,
Password: password,
},
URL: url,
Progress: os.Stdout,
})
CheckIfError(err)
// ... retrieving the branch being pointed by HEAD
ref, err := r.Head()
CheckIfError(err)
// ... retrieving the commit object
commit, err := r.CommitObject(ref.Hash())
CheckIfError(err)
fmt.Println(commit)
}
go-git-5.13.2/_examples/clone/auth/ssh/ 0000775 0000000 0000000 00000000000 14744245500 0017610 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/clone/auth/ssh/private_key/ 0000775 0000000 0000000 00000000000 14744245500 0022132 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/clone/auth/ssh/private_key/main.go 0000664 0000000 0000000 00000002157 14744245500 0023412 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
git "github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing/transport/ssh"
)
func main() {
CheckArgs("", "", "")
url, directory, privateKeyFile := os.Args[1], os.Args[2], os.Args[3]
var password string
if len(os.Args) == 5 {
password = os.Args[4]
}
_, err := os.Stat(privateKeyFile)
if err != nil {
Warning("read file %s failed %s\n", privateKeyFile, err.Error())
return
}
// Clone the given repository to the given directory
Info("git clone %s ", url)
publicKeys, err := ssh.NewPublicKeysFromFile("git", privateKeyFile, password)
if err != nil {
Warning("generate publickeys failed: %s\n", err.Error())
return
}
r, err := git.PlainClone(directory, false, &git.CloneOptions{
Auth: publicKeys,
URL: url,
Progress: os.Stdout,
})
CheckIfError(err)
// ... retrieving the branch being pointed by HEAD
ref, err := r.Head()
CheckIfError(err)
// ... retrieving the commit object
commit, err := r.CommitObject(ref.Hash())
CheckIfError(err)
fmt.Println(commit)
}
go-git-5.13.2/_examples/clone/auth/ssh/ssh_agent/ 0000775 0000000 0000000 00000000000 14744245500 0021563 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/clone/auth/ssh/ssh_agent/main.go 0000664 0000000 0000000 00000001415 14744245500 0023037 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
git "github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing/transport/ssh"
)
func main() {
CheckArgs("", "")
url, directory := os.Args[1], os.Args[2]
authMethod, err := ssh.NewSSHAgentAuth("git")
CheckIfError(err)
// Clone the given repository to the given directory
Info("git clone %s ", url)
r, err := git.PlainClone(directory, false, &git.CloneOptions{
Auth: authMethod,
URL: url,
Progress: os.Stdout,
})
CheckIfError(err)
// ... retrieving the branch being pointed by HEAD
ref, err := r.Head()
CheckIfError(err)
// ... retrieving the commit object
commit, err := r.CommitObject(ref.Hash())
CheckIfError(err)
fmt.Println(commit)
}
go-git-5.13.2/_examples/clone/main.go 0000664 0000000 0000000 00000001402 14744245500 0017322 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
)
// Basic example of how to clone a repository using clone options.
func main() {
CheckArgs("", "")
url := os.Args[1]
directory := os.Args[2]
// Clone the given repository to the given directory
Info("git clone %s %s --recursive", url, directory)
r, err := git.PlainClone(directory, false, &git.CloneOptions{
URL: url,
RecurseSubmodules: git.DefaultSubmoduleRecursionDepth,
})
CheckIfError(err)
// ... retrieving the branch being pointed by HEAD
ref, err := r.Head()
CheckIfError(err)
// ... retrieving the commit object
commit, err := r.CommitObject(ref.Hash())
CheckIfError(err)
fmt.Println(commit)
}
go-git-5.13.2/_examples/commit/ 0000775 0000000 0000000 00000000000 14744245500 0016242 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/commit/main.go 0000664 0000000 0000000 00000003366 14744245500 0017525 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"path/filepath"
"time"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing/object"
)
// Basic example of how to commit changes to the current branch to an existing
// repository.
func main() {
CheckArgs("")
directory := os.Args[1]
// Opens an already existing repository.
r, err := git.PlainOpen(directory)
CheckIfError(err)
w, err := r.Worktree()
CheckIfError(err)
// ... we need a file to commit so let's create a new file inside of the
// worktree of the project using the go standard library.
Info("echo \"hello world!\" > example-git-file")
filename := filepath.Join(directory, "example-git-file")
err = os.WriteFile(filename, []byte("hello world!"), 0644)
CheckIfError(err)
// Adds the new file to the staging area.
Info("git add example-git-file")
_, err = w.Add("example-git-file")
CheckIfError(err)
// We can verify the current status of the worktree using the method Status.
Info("git status --porcelain")
status, err := w.Status()
CheckIfError(err)
fmt.Println(status)
// Commits the current staging area to the repository, with the new file
// just created. We should provide the object.Signature of Author of the
// commit Since version 5.0.1, we can omit the Author signature, being read
// from the git config files.
Info("git commit -m \"example go-git commit\"")
commit, err := w.Commit("example go-git commit", &git.CommitOptions{
Author: &object.Signature{
Name: "John Doe",
Email: "john@doe.org",
When: time.Now(),
},
})
CheckIfError(err)
// Prints the current HEAD to verify that all worked well.
Info("git show -s")
obj, err := r.CommitObject(commit)
CheckIfError(err)
fmt.Println(obj)
}
go-git-5.13.2/_examples/common.go 0000664 0000000 0000000 00000001576 14744245500 0016602 0 ustar 00root root 0000000 0000000 package examples
import (
"fmt"
"os"
"strings"
)
// CheckArgs should be used to ensure the right command line arguments are
// passed before executing an example.
func CheckArgs(arg ...string) {
if len(os.Args) < len(arg)+1 {
Warning("Usage: %s %s", os.Args[0], strings.Join(arg, " "))
os.Exit(1)
}
}
// CheckIfError should be used to naively panics if an error is not nil.
func CheckIfError(err error) {
if err == nil {
return
}
fmt.Printf("\x1b[31;1m%s\x1b[0m\n", fmt.Sprintf("error: %s", err))
os.Exit(1)
}
// Info should be used to describe the example commands that are about to run.
func Info(format string, args ...interface{}) {
fmt.Printf("\x1b[34;1m%s\x1b[0m\n", fmt.Sprintf(format, args...))
}
// Warning should be used to display a warning
func Warning(format string, args ...interface{}) {
fmt.Printf("\x1b[36;1m%s\x1b[0m\n", fmt.Sprintf(format, args...))
}
go-git-5.13.2/_examples/common_test.go 0000664 0000000 0000000 00000010366 14744245500 0017636 0 ustar 00root root 0000000 0000000 package examples
import (
"flag"
"os"
"os/exec"
"path/filepath"
"runtime"
"testing"
)
var examplesTest = flag.Bool("examples", false, "run the examples tests")
var defaultURL = "https://github.com/git-fixtures/basic.git"
var args = map[string][]string{
"blame": {defaultURL, "CHANGELOG"},
"branch": {defaultURL, tempFolder()},
"checkout": {defaultURL, tempFolder(), "35e85108805c84807bc66a02d91535e1e24b38b9"},
"checkout-branch": {defaultURL, tempFolder(), "branch"},
"clone": {defaultURL, tempFolder()},
"commit": {cloneRepository(defaultURL, tempFolder())},
"context": {defaultURL, tempFolder()},
"custom_http": {defaultURL},
"find-if-any-tag-point-head": {cloneRepository(defaultURL, tempFolder())},
"ls": {cloneRepository(defaultURL, tempFolder()), "HEAD", "vendor"},
"ls-remote": {defaultURL},
"merge_base": {cloneRepository(defaultURL, tempFolder()), "--is-ancestor", "HEAD~3", "HEAD^"},
"open": {cloneRepository(defaultURL, tempFolder())},
"progress": {defaultURL, tempFolder()},
"pull": {createRepositoryWithRemote(tempFolder(), defaultURL)},
"push": {setEmptyRemote(cloneRepository(defaultURL, tempFolder()))},
"restore": {cloneRepository(defaultURL, tempFolder())},
"revision": {cloneRepository(defaultURL, tempFolder()), "master~2^"},
"sha256": {tempFolder()},
"showcase": {defaultURL, tempFolder()},
"sparse-checkout": {defaultURL, "vendor", tempFolder()},
"tag": {cloneRepository(defaultURL, tempFolder())},
}
// tests not working / set-up
var ignored = map[string]bool{
"azure_devops": true,
"ls": true,
"sha256": true,
"submodule": true,
"tag-create-push": true,
}
var (
tempFolders = []string{}
_, callingFile, _, _ = runtime.Caller(0)
basepath = filepath.Dir(callingFile)
)
func TestExamples(t *testing.T) {
flag.Parse()
if !*examplesTest && os.Getenv("CI") == "" {
t.Skip("skipping examples tests, pass --examples to execute it")
return
}
defer deleteTempFolders()
exampleMains, err := filepath.Glob(filepath.Join(basepath, "*", "main.go"))
if err != nil {
t.Errorf("error finding tests: %s", err)
}
for _, main := range exampleMains {
dir := filepath.Dir(main)
_, name := filepath.Split(dir)
if ignored[name] {
continue
}
t.Run(name, func(t *testing.T) {
testExample(t, name, dir)
})
}
}
func tempFolder() string {
path, err := os.MkdirTemp("", "")
CheckIfError(err)
tempFolders = append(tempFolders, path)
return path
}
func cloneRepository(url, folder string) string {
cmd := exec.Command("git", "clone", url, folder)
err := cmd.Run()
CheckIfError(err)
return folder
}
func createBareRepository(dir string) string {
return createRepository(dir, true)
}
func createRepository(dir string, isBare bool) string {
var cmd *exec.Cmd
if isBare {
cmd = exec.Command("git", "init", "--bare", dir)
} else {
cmd = exec.Command("git", "init", dir)
}
err := cmd.Run()
CheckIfError(err)
return dir
}
func createRepositoryWithRemote(local, remote string) string {
createRepository(local, false)
addRemote(local, remote)
return local
}
func setEmptyRemote(dir string) string {
remote := createBareRepository(tempFolder())
setRemote(dir, remote)
return dir
}
func setRemote(local, remote string) {
cmd := exec.Command("git", "remote", "set-url", "origin", remote)
cmd.Dir = local
err := cmd.Run()
CheckIfError(err)
}
func addRemote(local, remote string) {
cmd := exec.Command("git", "remote", "add", "origin", remote)
cmd.Dir = local
err := cmd.Run()
CheckIfError(err)
}
func testExample(t *testing.T, name, dir string) {
arguments := append([]string{"run", dir}, args[name]...)
cmd := exec.Command("go", arguments...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
t.Errorf("error running cmd %q", err)
}
}
func deleteTempFolders() {
for _, folder := range tempFolders {
err := os.RemoveAll(folder)
CheckIfError(err)
}
}
go-git-5.13.2/_examples/context/ 0000775 0000000 0000000 00000000000 14744245500 0016436 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/context/main.go 0000664 0000000 0000000 00000002224 14744245500 0017711 0 ustar 00root root 0000000 0000000 package main
import (
"context"
"os"
"os/signal"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
)
// Graceful cancellation example of a basic git operation such as Clone.
func main() {
CheckArgs("", "")
url := os.Args[1]
directory := os.Args[2]
// Clone the given repository to the given directory
Info("git clone %s %s", url, directory)
stop := make(chan os.Signal, 1)
signal.Notify(stop, os.Interrupt)
// The context is the mechanism used by go-git, to support deadlines and
// cancellation signals.
ctx, cancel := context.WithCancel(context.Background())
defer cancel() // cancel when we are finished consuming integers
go func() {
<-stop
Warning("\nSignal detected, canceling operation...")
cancel()
}()
Warning("To gracefully stop the clone operation, push Crtl-C.")
// Using PlainCloneContext we can provide to a context, if the context
// is cancelled, the clone operation stops gracefully.
_, err := git.PlainCloneContext(ctx, directory, false, &git.CloneOptions{
URL: url,
Progress: os.Stdout,
})
// If the context was cancelled, an error is returned.
CheckIfError(err)
}
go-git-5.13.2/_examples/custom_http/ 0000775 0000000 0000000 00000000000 14744245500 0017323 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/custom_http/main.go 0000664 0000000 0000000 00000002467 14744245500 0020607 0 ustar 00root root 0000000 0000000 package main
import (
"crypto/tls"
"fmt"
"net/http"
"os"
"time"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing/transport/client"
githttp "github.com/go-git/go-git/v5/plumbing/transport/http"
"github.com/go-git/go-git/v5/storage/memory"
)
// Here is an example to configure http client according to our own needs.
func main() {
CheckArgs("")
url := os.Args[1]
// Create a custom http(s) client with your config
customClient := &http.Client{
// accept any certificate (might be useful for testing)
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
// 15 second timeout
Timeout: 15 * time.Second,
// don't follow redirect
CheckRedirect: func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
},
}
// Override http(s) default protocol to use our custom client
client.InstallProtocol("https", githttp.NewClient(customClient))
// Clone repository using the new client if the protocol is https://
Info("git clone %s", url)
r, err := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{URL: url})
CheckIfError(err)
// Retrieve the branch pointed by HEAD
Info("git rev-parse HEAD")
head, err := r.Head()
CheckIfError(err)
fmt.Println(head.Hash())
}
go-git-5.13.2/_examples/find-if-any-tag-point-head/ 0000775 0000000 0000000 00000000000 14744245500 0021652 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/find-if-any-tag-point-head/main.go 0000664 0000000 0000000 00000001760 14744245500 0023131 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing"
)
// Basic example of how to find if HEAD is tagged.
func main() {
CheckArgs("")
path := os.Args[1]
// We instantiate a new repository targeting the given path (the .git folder)
r, err := git.PlainOpen(path)
CheckIfError(err)
// Get HEAD reference to use for comparison later on.
ref, err := r.Head()
CheckIfError(err)
tags, err := r.Tags()
CheckIfError(err)
// List all tags, both lightweight tags and annotated tags and see if some tag points to HEAD reference.
err = tags.ForEach(func(t *plumbing.Reference) error {
// This technique should work for both lightweight and annotated tags.
revHash, err := r.ResolveRevision(plumbing.Revision(t.Name()))
CheckIfError(err)
if *revHash == ref.Hash() {
fmt.Printf("Found tag %s with hash %s pointing to HEAD %s\n", t.Name().Short(), revHash, ref.Hash())
}
return nil
})
}
go-git-5.13.2/_examples/log/ 0000775 0000000 0000000 00000000000 14744245500 0015533 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/log/main.go 0000664 0000000 0000000 00000002463 14744245500 0017013 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"time"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/storage/memory"
)
// Example of how to:
// - Clone a repository into memory
// - Get the HEAD reference
// - Using the HEAD reference, obtain the commit this reference is pointing to
// - Using the commit, obtain its history and print it
func main() {
// Clones the given repository, creating the remote, the local branches
// and fetching the objects, everything in memory:
Info("git clone https://github.com/src-d/go-siva")
r, err := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
URL: "https://github.com/src-d/go-siva",
})
CheckIfError(err)
// Gets the HEAD history from HEAD, just like this command:
Info("git log")
// ... retrieves the branch pointed by HEAD
ref, err := r.Head()
CheckIfError(err)
// ... retrieves the commit history
since := time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC)
until := time.Date(2019, 7, 30, 0, 0, 0, 0, time.UTC)
cIter, err := r.Log(&git.LogOptions{From: ref.Hash(), Since: &since, Until: &until})
CheckIfError(err)
// ... just iterates over the commits, printing it
err = cIter.ForEach(func(c *object.Commit) error {
fmt.Println(c)
return nil
})
CheckIfError(err)
}
go-git-5.13.2/_examples/ls-remote/ 0000775 0000000 0000000 00000000000 14744245500 0016661 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/ls-remote/main.go 0000664 0000000 0000000 00000002034 14744245500 0020133 0 ustar 00root root 0000000 0000000 package main
import (
"log"
"os"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/storage/memory"
. "github.com/go-git/go-git/v5/_examples"
)
// Retrieve remote tags without cloning repository
func main() {
CheckArgs("")
url := os.Args[1]
Info("git ls-remote --tags %s", url)
// Create the remote with repository URL
rem := git.NewRemote(memory.NewStorage(), &config.RemoteConfig{
Name: "origin",
URLs: []string{url},
})
log.Print("Fetching tags...")
// We can then use every Remote functions to retrieve wanted information
refs, err := rem.List(&git.ListOptions{
// Returns all references, including peeled references.
PeelingOption: git.AppendPeeled,
})
if err != nil {
log.Fatal(err)
}
// Filters the references list and only keeps tags
var tags []string
for _, ref := range refs {
if ref.Name().IsTag() {
tags = append(tags, ref.Name().Short())
}
}
if len(tags) == 0 {
log.Println("No tags!")
return
}
log.Printf("Tags found: %v", tags)
}
go-git-5.13.2/_examples/ls/ 0000775 0000000 0000000 00000000000 14744245500 0015370 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/ls/main.go 0000664 0000000 0000000 00000016474 14744245500 0016657 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"io"
"os"
"path"
"strings"
"github.com/emirpasic/gods/trees/binaryheap"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
commitgraph_fmt "github.com/go-git/go-git/v5/plumbing/format/commitgraph"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/object/commitgraph"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/osfs"
)
// Example how to resolve a revision into its commit counterpart
func main() {
CheckArgs("", "", "")
path := os.Args[1]
revision := os.Args[2]
treePath := os.Args[3]
// We instantiate a new repository targeting the given path (the .git folder)
fs := osfs.New(path)
if _, err := fs.Stat(git.GitDirName); err == nil {
fs, err = fs.Chroot(git.GitDirName)
CheckIfError(err)
}
s := filesystem.NewStorageWithOptions(fs, cache.NewObjectLRUDefault(), filesystem.Options{KeepDescriptors: true})
r, err := git.Open(s, fs)
CheckIfError(err)
defer s.Close()
// Resolve revision into a sha1 commit, only some revisions are resolved
// look at the doc to get more details
Info("git rev-parse %s", revision)
h, err := r.ResolveRevision(plumbing.Revision(revision))
CheckIfError(err)
commit, err := r.CommitObject(*h)
CheckIfError(err)
tree, err := commit.Tree()
CheckIfError(err)
if treePath != "" {
tree, err = tree.Tree(treePath)
CheckIfError(err)
}
var paths []string
for _, entry := range tree.Entries {
paths = append(paths, entry.Name)
}
commitNodeIndex, file := getCommitNodeIndex(r, fs)
if file != nil {
defer file.Close()
}
commitNode, err := commitNodeIndex.Get(*h)
CheckIfError(err)
revs, err := getLastCommitForPaths(commitNode, treePath, paths)
CheckIfError(err)
for path, rev := range revs {
// Print one line per file (name hash message)
hash := rev.Hash.String()
line := strings.Split(rev.Message, "\n")
fmt.Println(path, hash[:7], line[0])
}
}
func getCommitNodeIndex(r *git.Repository, fs billy.Filesystem) (commitgraph.CommitNodeIndex, io.ReadCloser) {
file, err := fs.Open(path.Join("objects", "info", "commit-graph"))
if err == nil {
index, err := commitgraph_fmt.OpenFileIndex(file)
if err == nil {
return commitgraph.NewGraphCommitNodeIndex(index, r.Storer), file
}
file.Close()
}
return commitgraph.NewObjectCommitNodeIndex(r.Storer), nil
}
type commitAndPaths struct {
commit commitgraph.CommitNode
// Paths that are still on the branch represented by commit
paths []string
// Set of hashes for the paths
hashes map[string]plumbing.Hash
}
func getCommitTree(c commitgraph.CommitNode, treePath string) (*object.Tree, error) {
tree, err := c.Tree()
if err != nil {
return nil, err
}
// Optimize deep traversals by focusing only on the specific tree
if treePath != "" {
tree, err = tree.Tree(treePath)
if err != nil {
return nil, err
}
}
return tree, nil
}
func getFullPath(treePath, path string) string {
if treePath != "" {
if path != "" {
return treePath + "/" + path
}
return treePath
}
return path
}
func getFileHashes(c commitgraph.CommitNode, treePath string, paths []string) (map[string]plumbing.Hash, error) {
tree, err := getCommitTree(c, treePath)
if err == object.ErrDirectoryNotFound {
// The whole tree didn't exist, so return empty map
return make(map[string]plumbing.Hash), nil
}
if err != nil {
return nil, err
}
hashes := make(map[string]plumbing.Hash)
for _, path := range paths {
if path != "" {
entry, err := tree.FindEntry(path)
if err == nil {
hashes[path] = entry.Hash
}
} else {
hashes[path] = tree.Hash
}
}
return hashes, nil
}
func getLastCommitForPaths(c commitgraph.CommitNode, treePath string, paths []string) (map[string]*object.Commit, error) {
// We do a tree traversal with nodes sorted by commit time
heap := binaryheap.NewWith(func(a, b interface{}) int {
if a.(*commitAndPaths).commit.CommitTime().Before(b.(*commitAndPaths).commit.CommitTime()) {
return 1
}
return -1
})
resultNodes := make(map[string]commitgraph.CommitNode)
initialHashes, err := getFileHashes(c, treePath, paths)
if err != nil {
return nil, err
}
// Start search from the root commit and with full set of paths
heap.Push(&commitAndPaths{c, paths, initialHashes})
for {
cIn, ok := heap.Pop()
if !ok {
break
}
current := cIn.(*commitAndPaths)
// Load the parent commits for the one we are currently examining
numParents := current.commit.NumParents()
var parents []commitgraph.CommitNode
for i := 0; i < numParents; i++ {
parent, err := current.commit.ParentNode(i)
if err != nil {
break
}
parents = append(parents, parent)
}
// Examine the current commit and set of interesting paths
pathUnchanged := make([]bool, len(current.paths))
parentHashes := make([]map[string]plumbing.Hash, len(parents))
for j, parent := range parents {
parentHashes[j], err = getFileHashes(parent, treePath, current.paths)
if err != nil {
break
}
for i, path := range current.paths {
if parentHashes[j][path] == current.hashes[path] {
pathUnchanged[i] = true
}
}
}
var remainingPaths []string
for i, path := range current.paths {
// The results could already contain some newer change for the same path,
// so don't override that and bail out on the file early.
if resultNodes[path] == nil {
if pathUnchanged[i] {
// The path existed with the same hash in at least one parent so it could
// not have been changed in this commit directly.
remainingPaths = append(remainingPaths, path)
} else {
// There are few possible cases how can we get here:
// - The path didn't exist in any parent, so it must have been created by
// this commit.
// - The path did exist in the parent commit, but the hash of the file has
// changed.
// - We are looking at a merge commit and the hash of the file doesn't
// match any of the hashes being merged. This is more common for directories,
// but it can also happen if a file is changed through conflict resolution.
resultNodes[path] = current.commit
}
}
}
if len(remainingPaths) > 0 {
// Add the parent nodes along with remaining paths to the heap for further
// processing.
for j, parent := range parents {
// Combine remainingPath with paths available on the parent branch
// and make union of them
remainingPathsForParent := make([]string, 0, len(remainingPaths))
newRemainingPaths := make([]string, 0, len(remainingPaths))
for _, path := range remainingPaths {
if parentHashes[j][path] == current.hashes[path] {
remainingPathsForParent = append(remainingPathsForParent, path)
} else {
newRemainingPaths = append(newRemainingPaths, path)
}
}
if remainingPathsForParent != nil {
heap.Push(&commitAndPaths{parent, remainingPathsForParent, parentHashes[j]})
}
if len(newRemainingPaths) == 0 {
break
} else {
remainingPaths = newRemainingPaths
}
}
}
}
// Post-processing
result := make(map[string]*object.Commit)
for path, commitNode := range resultNodes {
var err error
result[path], err = commitNode.Commit()
if err != nil {
return nil, err
}
}
return result, nil
}
go-git-5.13.2/_examples/merge_base/ 0000775 0000000 0000000 00000000000 14744245500 0017043 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/merge_base/help-long.msg.go 0000664 0000000 0000000 00000005361 14744245500 0022051 0 ustar 00root root 0000000 0000000 package main
const helpLongMsg = `
NAME:
%_COMMAND_NAME_% - Lists the best common ancestors of the two passed commit revisions
SYNOPSIS:
usage: %_COMMAND_NAME_%
or: %_COMMAND_NAME_% --independent ...
or: %_COMMAND_NAME_% --is-ancestor
params:
Path to the git repository
Git revision as supported by go-git
DESCRIPTION:
%_COMMAND_NAME_% finds the best common ancestor(s) between two commits. One common ancestor is better than another common ancestor if the latter is an ancestor of the former.
A common ancestor that does not have any better common ancestor is a best common ancestor, i.e. a merge base. Note that there can be more than one merge base for a pair of commits.
Commits that does not share a common history has no common ancestors.
OPTIONS:
As the most common special case, specifying only two commits on the command line means computing the merge base between the given two commits.
If there is no shared history between the passed commits, there won't be a merge-base, and the command will exit with status 1.
--independent
List the subgroup from the passed commits, that cannot be reached from any other of the passed ones. In other words, it prints a minimal subset of the supplied commits with the same ancestors.
--is-ancestor
Check if the first commit is an ancestor of the second one, and exit with status 0 if true, or with status 1 if not. Errors are signaled by a non-zero status that is not 1.
DISCUSSION:
Given two commits A and B, %_COMMAND_NAME_% A B will output a commit which is the best common ancestor of both, what means that is reachable from both A and B through the parent relationship.
For example, with this topology:
o---o---o---o---B
/ /
---3---2---o---1---o---A
the merge base between A and B is 1.
With the given topology 2 and 3 are also common ancestors of A and B, but they are not the best ones because they can be also reached from 1.
When the history involves cross-cross merges, there can be more than one best common ancestor for two commits. For example, with this topology:
---1---o---A
\ /
X
/ \
---2---o---o---B
When the history involves feature branches depending on other feature branches there can be also more than one common ancestor. For example:
o---o---o
/ \
1---o---A \
/ / \
---o---o---2---o---o---B
In both examples, both 1 and 2 are merge-bases of A and B for each situation.
Neither one is better than the other (both are best merge bases) because 1 cannot be reached from 2, nor the opposite.
`
go-git-5.13.2/_examples/merge_base/helpers.go 0000664 0000000 0000000 00000002315 14744245500 0021035 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"strings"
"github.com/go-git/go-git/v5/plumbing/object"
)
func checkIfError(err error, code exitCode, mainReason string, v ...interface{}) {
if err == nil {
return
}
printErr(wrapErr(err, mainReason, v...))
os.Exit(int(code))
}
func helpAndExit(s string, helpMsg string, code exitCode) {
if code == exitCodeSuccess {
printMsg("%s", s)
} else {
printErr(fmt.Errorf(s))
}
fmt.Println(strings.Replace(helpMsg, "%_COMMAND_NAME_%", os.Args[0], -1))
os.Exit(int(code))
}
func printErr(err error) {
fmt.Printf("\x1b[31;1m%s\x1b[0m\n", fmt.Sprintf("error: %s", err))
}
func printMsg(format string, args ...interface{}) {
fmt.Printf("%s\n", fmt.Sprintf(format, args...))
}
func printCommits(commits []*object.Commit) {
for _, commit := range commits {
if os.Getenv("LOG_LEVEL") == "verbose" {
fmt.Printf(
"\x1b[36;1m%s \x1b[90;21m%s\x1b[0m %s\n",
commit.Hash.String()[:7],
commit.Hash.String(),
strings.Split(commit.Message, "\n")[0],
)
} else {
fmt.Println(commit.Hash.String())
}
}
}
func wrapErr(err error, s string, v ...interface{}) error {
if err != nil {
return fmt.Errorf("%s\n %s", fmt.Sprintf(s, v...), err)
}
return nil
}
go-git-5.13.2/_examples/merge_base/main.go 0000664 0000000 0000000 00000006642 14744245500 0020326 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/object"
)
type exitCode int
const (
exitCodeSuccess exitCode = iota
exitCodeNotFound
exitCodeWrongSyntax
exitCodeCouldNotOpenRepository
exitCodeCouldNotParseRevision
exitCodeUnexpected
cmdDesc = "Returns the merge-base between two commits:"
helpShortMsg = `
usage: %_COMMAND_NAME_%
or: %_COMMAND_NAME_% --independent ...
or: %_COMMAND_NAME_% --is-ancestor
or: %_COMMAND_NAME_% --help
params:
path to the git repository
git revision as supported by go-git
options:
(no options) lists the best common ancestors of the two passed commits
--independent list commits not reachable from the others
--is-ancestor is the first one ancestor of the other?
--help show the full help message of %_COMMAND_NAME_%
`
)
// Command that mimics `git merge-base --all `
// Command that mimics `git merge-base --is-ancestor `
// Command that mimics `git merge-base --independent ...`
func main() {
if len(os.Args) == 1 {
helpAndExit("Returns the merge-base between two commits:", helpShortMsg, exitCodeSuccess)
}
if os.Args[1] == "--help" || os.Args[1] == "-h" {
helpAndExit("Returns the merge-base between two commits:", helpLongMsg, exitCodeSuccess)
}
if len(os.Args) < 4 {
helpAndExit("Wrong syntax", helpShortMsg, exitCodeWrongSyntax)
}
path := os.Args[1]
var modeIndependent, modeAncestor bool
var commitRevs []string
var res []*object.Commit
switch os.Args[2] {
case "--independent":
modeIndependent = true
commitRevs = os.Args[3:]
case "--is-ancestor":
modeAncestor = true
commitRevs = os.Args[3:]
if len(commitRevs) != 2 {
helpAndExit("Wrong syntax", helpShortMsg, exitCodeWrongSyntax)
}
default:
commitRevs = os.Args[2:]
if len(commitRevs) != 2 {
helpAndExit("Wrong syntax", helpShortMsg, exitCodeWrongSyntax)
}
}
// Open a git repository from current directory
repo, err := git.PlainOpen(path)
checkIfError(err, exitCodeCouldNotOpenRepository, "not in a git repository")
// Get the hashes of the passed revisions
var hashes []*plumbing.Hash
for _, rev := range commitRevs {
hash, err := repo.ResolveRevision(plumbing.Revision(rev))
checkIfError(err, exitCodeCouldNotParseRevision, "could not parse revision '%s'", rev)
hashes = append(hashes, hash)
}
// Get the commits identified by the passed hashes
var commits []*object.Commit
for _, hash := range hashes {
commit, err := repo.CommitObject(*hash)
checkIfError(err, exitCodeUnexpected, "could not find commit '%s'", hash.String())
commits = append(commits, commit)
}
if modeAncestor {
isAncestor, err := commits[0].IsAncestor(commits[1])
checkIfError(err, exitCodeUnexpected, "could not traverse the repository history")
if !isAncestor {
os.Exit(int(exitCodeNotFound))
}
os.Exit(int(exitCodeSuccess))
}
if modeIndependent {
res, err = object.Independents(commits)
checkIfError(err, exitCodeUnexpected, "could not traverse the repository history")
} else {
res, err = commits[0].MergeBase(commits[1])
checkIfError(err, exitCodeUnexpected, "could not traverse the repository history")
if len(res) == 0 {
os.Exit(int(exitCodeNotFound))
}
}
printCommits(res)
}
go-git-5.13.2/_examples/open/ 0000775 0000000 0000000 00000000000 14744245500 0015713 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/open/main.go 0000664 0000000 0000000 00000001507 14744245500 0017171 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing/object"
)
// Open an existing repository in a specific folder.
func main() {
CheckArgs("")
path := os.Args[1]
// We instantiate a new repository targeting the given path (the .git folder)
r, err := git.PlainOpen(path)
CheckIfError(err)
// Length of the HEAD history
Info("git rev-list HEAD --count")
// ... retrieving the HEAD reference
ref, err := r.Head()
CheckIfError(err)
// ... retrieves the commit history
cIter, err := r.Log(&git.LogOptions{From: ref.Hash()})
CheckIfError(err)
// ... just iterates over the commits
var cCount int
err = cIter.ForEach(func(c *object.Commit) error {
cCount++
return nil
})
CheckIfError(err)
fmt.Println(cCount)
}
go-git-5.13.2/_examples/progress/ 0000775 0000000 0000000 00000000000 14744245500 0016616 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/progress/main.go 0000664 0000000 0000000 00000001327 14744245500 0020074 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
)
// Example of how to show the progress when you do a basic clone operation.
func main() {
CheckArgs("", "")
url := os.Args[1]
directory := os.Args[2]
// Clone the given repository to the given directory
Info("git clone %s %s", url, directory)
_, err := git.PlainClone(directory, false, &git.CloneOptions{
URL: url,
Depth: 1,
// as git does, when you make a clone, pull or some other operations the
// server sends information via the sideband, this information can being
// collected providing a io.Writer to the CloneOptions options
Progress: os.Stdout,
})
CheckIfError(err)
}
go-git-5.13.2/_examples/pull/ 0000775 0000000 0000000 00000000000 14744245500 0015726 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/pull/main.go 0000664 0000000 0000000 00000001432 14744245500 0017201 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
)
// Pull changes from a remote repository
func main() {
CheckArgs("")
path := os.Args[1]
// We instantiate a new repository targeting the given path (the .git folder)
r, err := git.PlainOpen(path)
CheckIfError(err)
// Get the working directory for the repository
w, err := r.Worktree()
CheckIfError(err)
// Pull the latest changes from the origin remote and merge into the current branch
Info("git pull origin")
err = w.Pull(&git.PullOptions{RemoteName: "origin"})
CheckIfError(err)
// Print the latest commit that was just pulled
ref, err := r.Head()
CheckIfError(err)
commit, err := r.CommitObject(ref.Hash())
CheckIfError(err)
fmt.Println(commit)
}
go-git-5.13.2/_examples/push/ 0000775 0000000 0000000 00000000000 14744245500 0015731 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/push/main.go 0000664 0000000 0000000 00000000660 14744245500 0017206 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
)
// Example of how to open a repository in a specific path, and push to
// its default remote (origin).
func main() {
CheckArgs("")
path := os.Args[1]
r, err := git.PlainOpen(path)
CheckIfError(err)
Info("git push")
// push using default options
err = r.Push(&git.PushOptions{})
CheckIfError(err)
}
go-git-5.13.2/_examples/remotes/ 0000775 0000000 0000000 00000000000 14744245500 0016430 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/remotes/main.go 0000664 0000000 0000000 00000003305 14744245500 0017704 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/storage/memory"
)
// Example of how to:
// - Create a new in-memory repository
// - Create a new remote named "example"
// - List remotes and print them
// - Pull using the new remote "example"
// - Iterate the references again, but only showing hash references, not symbolic ones
// - Remove remote "example"
func main() {
// Create a new repository
Info("git init")
r, err := git.Init(memory.NewStorage(), nil)
CheckIfError(err)
// Add a new remote, with the default fetch refspec
Info("git remote add example https://github.com/git-fixtures/basic.git")
_, err = r.CreateRemote(&config.RemoteConfig{
Name: "example",
URLs: []string{"https://github.com/git-fixtures/basic.git"},
})
CheckIfError(err)
// List remotes from a repository
Info("git remote -v")
list, err := r.Remotes()
CheckIfError(err)
for _, r := range list {
fmt.Println(r)
}
// Fetch using the new remote
Info("git fetch example")
err = r.Fetch(&git.FetchOptions{
RemoteName: "example",
})
CheckIfError(err)
// List the branches
// > git show-ref
Info("git show-ref")
refs, err := r.References()
CheckIfError(err)
err = refs.ForEach(func(ref *plumbing.Reference) error {
// The HEAD is omitted in a `git show-ref` so we ignore the symbolic
// references, the HEAD
if ref.Type() == plumbing.SymbolicReference {
return nil
}
fmt.Println(ref)
return nil
})
CheckIfError(err)
// Delete the example remote
Info("git remote rm example")
err = r.DeleteRemote("example")
CheckIfError(err)
}
go-git-5.13.2/_examples/restore/ 0000775 0000000 0000000 00000000000 14744245500 0016435 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/restore/main.go 0000664 0000000 0000000 00000005447 14744245500 0017722 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"io/ioutil"
"os"
"path/filepath"
"time"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing/object"
)
func prepareRepo(w *git.Worktree, directory string) {
// We need a known state of files inside the worktree for testing revert a modify and delete
Info("echo \"hello world! Modify\" > for-modify")
err := ioutil.WriteFile(filepath.Join(directory, "for-modify"), []byte("hello world! Modify"), 0644)
CheckIfError(err)
Info("git add for-modify")
_, err = w.Add("for-modify")
CheckIfError(err)
Info("echo \"hello world! Delete\" > for-delete")
err = ioutil.WriteFile(filepath.Join(directory, "for-delete"), []byte("hello world! Delete"), 0644)
CheckIfError(err)
Info("git add for-delete")
_, err = w.Add("for-delete")
CheckIfError(err)
Info("git commit -m \"example go-git commit\"")
_, err = w.Commit("example go-git commit", &git.CommitOptions{
Author: &object.Signature{
Name: "John Doe",
Email: "john@doe.org",
When: time.Now(),
},
})
CheckIfError(err)
}
// An example of how to restore AKA unstage files
func main() {
CheckArgs("")
directory := os.Args[1]
// Opens an already existing repository.
r, err := git.PlainOpen(directory)
CheckIfError(err)
w, err := r.Worktree()
CheckIfError(err)
prepareRepo(w, directory)
// Perform the operation and stage them
Info("echo \"hello world! Modify 2\" > for-modify")
err = ioutil.WriteFile(filepath.Join(directory, "for-modify"), []byte("hello world! Modify 2"), 0644)
CheckIfError(err)
Info("git add for-modify")
_, err = w.Add("for-modify")
CheckIfError(err)
Info("echo \"hello world! Add\" > for-add")
err = ioutil.WriteFile(filepath.Join(directory, "for-add"), []byte("hello world! Add"), 0644)
CheckIfError(err)
Info("git add for-add")
_, err = w.Add("for-add")
CheckIfError(err)
Info("rm for-delete")
err = os.Remove(filepath.Join(directory, "for-delete"))
CheckIfError(err)
Info("git add for-delete")
_, err = w.Add("for-delete")
CheckIfError(err)
// We can verify the current status of the worktree using the method Status.
Info("git status --porcelain")
status, err := w.Status()
CheckIfError(err)
fmt.Println(status)
// Unstage a single file and see the status
Info("git restore --staged for-modify")
err = w.Restore(&git.RestoreOptions{Staged: true, Files: []string{"for-modify"}})
CheckIfError(err)
Info("git status --porcelain")
status, err = w.Status()
CheckIfError(err)
fmt.Println(status)
// Unstage the other 2 files and see the status
Info("git restore --staged for-add for-delete")
err = w.Restore(&git.RestoreOptions{Staged: true, Files: []string{"for-add", "for-delete"}})
CheckIfError(err)
Info("git status --porcelain")
status, err = w.Status()
CheckIfError(err)
fmt.Println(status)
}
go-git-5.13.2/_examples/revision/ 0000775 0000000 0000000 00000000000 14744245500 0016610 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/revision/main.go 0000664 0000000 0000000 00000001275 14744245500 0020070 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing"
)
// Example how to resolve a revision into its commit counterpart
func main() {
CheckArgs("", "")
path := os.Args[1]
revision := os.Args[2]
// We instantiate a new repository targeting the given path (the .git folder)
r, err := git.PlainOpen(path)
CheckIfError(err)
// Resolve revision into a sha1 commit, only some revisions are resolved
// look at the doc to get more details
Info("git rev-parse %s", revision)
h, err := r.ResolveRevision(plumbing.Revision(revision))
CheckIfError(err)
fmt.Println(h.String())
}
go-git-5.13.2/_examples/sha256/ 0000775 0000000 0000000 00000000000 14744245500 0015762 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/sha256/main.go 0000664 0000000 0000000 00000003523 14744245500 0017240 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"path/filepath"
"time"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing/format/config"
"github.com/go-git/go-git/v5/plumbing/object"
)
// This example requires building with the sha256 tag for it to work:
// go run -tags sha256 main.go /tmp/repository
// Basic example of how to initialise a repository using sha256 as the hashing algorithm.
func main() {
CheckArgs("")
directory := os.Args[1]
os.RemoveAll(directory)
// Init a new repository using the ObjectFormat SHA256.
r, err := git.PlainInitWithOptions(directory, &git.PlainInitOptions{ObjectFormat: config.SHA256})
CheckIfError(err)
w, err := r.Worktree()
CheckIfError(err)
// ... we need a file to commit so let's create a new file inside of the
// worktree of the project using the go standard library.
Info("echo \"hello world!\" > example-git-file")
filename := filepath.Join(directory, "example-git-file")
err = os.WriteFile(filename, []byte("hello world!"), 0644)
CheckIfError(err)
// Adds the new file to the staging area.
Info("git add example-git-file")
_, err = w.Add("example-git-file")
CheckIfError(err)
// Commits the current staging area to the repository, with the new file
// just created. We should provide the object.Signature of Author of the
// commit Since version 5.0.1, we can omit the Author signature, being read
// from the git config files.
Info("git commit -m \"example go-git commit\"")
commit, err := w.Commit("example go-git commit", &git.CommitOptions{
Author: &object.Signature{
Name: "John Doe",
Email: "john@doe.org",
When: time.Now(),
},
})
CheckIfError(err)
// Prints the current HEAD to verify that all worked well.
Info("git show -s")
obj, err := r.CommitObject(commit)
CheckIfError(err)
fmt.Println(obj)
}
go-git-5.13.2/_examples/showcase/ 0000775 0000000 0000000 00000000000 14744245500 0016566 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/showcase/main.go 0000664 0000000 0000000 00000003460 14744245500 0020044 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"strings"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing/object"
. "github.com/go-git/go-git/v5/_examples"
)
// Example of an specific use case:
// - Clone a repository in a specific path
// - Get the HEAD reference
// - Using the HEAD reference, obtain the commit this reference is pointing to
// - Print the commit content
// - Using the commit, iterate over all its files and print them
// - Print all the commit history with commit messages, short hash and the
// first line of the commit message
func main() {
CheckArgs(" ")
url := os.Args[1]
path := os.Args[2]
// Clone the given repository, creating the remote, the local branches
// and fetching the objects, exactly as:
Info("git clone %s %s", url, path)
r, err := git.PlainClone(path, false, &git.CloneOptions{URL: url})
CheckIfError(err)
// Getting the latest commit on the current branch
Info("git log -1")
// ... retrieving the branch being pointed by HEAD
ref, err := r.Head()
CheckIfError(err)
// ... retrieving the commit object
commit, err := r.CommitObject(ref.Hash())
CheckIfError(err)
fmt.Println(commit)
// List the tree from HEAD
Info("git ls-tree -r HEAD")
// ... retrieve the tree from the commit
tree, err := commit.Tree()
CheckIfError(err)
// ... get the files iterator and print the file
tree.Files().ForEach(func(f *object.File) error {
fmt.Printf("100644 blob %s %s\n", f.Hash, f.Name)
return nil
})
// List the history of the repository
Info("git log --oneline")
commitIter, err := r.Log(&git.LogOptions{From: commit.Hash})
CheckIfError(err)
err = commitIter.ForEach(func(c *object.Commit) error {
hash := c.Hash.String()
line := strings.Split(c.Message, "\n")
fmt.Println(hash[:7], line[0])
return nil
})
CheckIfError(err)
}
go-git-5.13.2/_examples/sparse-checkout/ 0000775 0000000 0000000 00000000000 14744245500 0020052 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/sparse-checkout/main.go 0000664 0000000 0000000 00000001060 14744245500 0021322 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
)
func main() {
CheckArgs("", "", "")
url := os.Args[1]
path := os.Args[2]
directory := os.Args[3]
Info("git clone %s %s", url, directory)
r, err := git.PlainClone(directory, false, &git.CloneOptions{
URL: url,
NoCheckout: true,
})
CheckIfError(err)
w, err := r.Worktree()
CheckIfError(err)
err = w.Checkout(&git.CheckoutOptions{
SparseCheckoutDirectories: []string{path},
})
CheckIfError(err)
}
go-git-5.13.2/_examples/storage/ 0000775 0000000 0000000 00000000000 14744245500 0016416 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/storage/README.md 0000664 0000000 0000000 00000011510 14744245500 0017673 0 ustar 00root root 0000000 0000000 # go-git + aerospike: a git repository backed by a database
This is an example of a [go-git](https://github.com/src-d/go-git) repository backed by [Aerospike](http://www.aerospike.com/).
### and what this means ...
*git* has a very well defined storage system, the `.git` directory, present on any repository. This is the place where `git` stores all the [`objects`](https://git-scm.com/book/en/v2/Git-Internals-Git-Objects), [`references`](https://git-scm.com/book/es/v2/Git-Internals-Git-References) and [`configuration`](https://git-scm.com/docs/git-config#_configuration_file). This information is stored in plain files.
Our original **go-git** version was designed to work in memory, some time after we added support to read the `.git`, and now we have added support for fully customized [storages](https://godoc.org/github.com/go-git/go-git/v5/storage#Storer).
This means that the internal database of any repository can be saved and accessed on any support, databases, distributed filesystems, etc. This functionality is pretty similar to the [libgit2 backends](http://blog.deveo.com/your-git-repository-in-a-database-pluggable-backends-in-libgit2/)
Installation
------------
What do you need? You need an *aerospike* server. The easiest way to get one for testing is running the official **docker** container provided by Aerospike:
```
docker run -d -p 3000:3000 --name aerospike aerospike/aerospike-server
```
Now, we need the sample code.
```
go get -u github.com/mcuadros/go-git-aerospike/...
```
Running this command will make the binary `go-git-aerospike`. if you have `GOPATH` on your `PATH`, you are ready to go. If not, this is a great moment.
Usage
-----
### Cloning the repository into the database
Running the command `go-git-aerospike` with the `clone` option followed by the URL of a git repository clones the repository into the database, storing all the git objects in it:
```sh
go-git-aerospike clone https://github.com/src-d/flamingo.git
```
The repository is stored in the aerospike database. This means that all the internal objects like commits, trees, blobs and tags are `records` in different `sets` in the `test` namespace:
```sql
aql> SELECT hash, type, url FROM test.commit
```
```
+--------------------------------------------+----------+-------+-----------------------------------+
| hash | type | blob | url |
+--------------------------------------------+----------+-------+-----------------------------------+
| "c94450c805876e49b38d2ff1103b8c09cdd2aef4" | "commit" | 00 00 | ...github.com/src-d/flamingo.git" |
| "7f71640877608ee9cfe584fac216f03f9aebb523" | "commit" | 00 00 | ...github.com/src-d/flamingo.git" |
| "255f097450dd91812c4eb7b9e0d3a4f034f2acaf" | "commit" | 00 00 | ...github.com/src-d/flamingo.git" |
+--------------------------------------------+----------+-------+-----------------------------------+
102 rows in set (0.071 secs)
```
And also the references and the configuration (remotes) are stored in it.
```sql
aql> SELECT name, target, url FROM test.reference
```
```
+------------------------------+--------------------------------------------+-----------------------+
| name | target | url |
+------------------------------+--------------------------------------------+-----------------------+
| "HEAD" | "ref: refs/heads/master" | ...rc-d/flamingo.git" |
| "refs/heads/master" | "ed3e1aa2e46584cb803ed356cb5d8855f6d05660" | ...rc-d/flamingo.git" |
| "refs/remotes/origin/master" | "ed3e1aa2e46584cb803ed356cb5d8855f6d05660" | ...rc-d/flamingo.git" |
+------------------------------+--------------------------------------------+-----------------------+
3 rows in set (0.046 secs)
```
### Reading the repository
Running the `log` command, a `git log --online` like result is printed:
```sh
go-git-aerospike log https://github.com/src-d/flamingo.git
```
The URL of the repository is the way we identify the objects in the `set`s, since we can clone several repositories to the same database.
```
ed3e1aa ID is also allowed in SendFormTo and SayTo
2031f3e Handle close of message channel in WaitForMessage
e784495 Add SendFormTo and SayTo
447748a Make text in attachments accept markdown
595b4e7 Form author name and author icon and text groupfield
0f2e315 Test for InvokeAction
0dc7c9a Handle closing of channel
b3f167b Implement InvokeAction
```
The process has read all the commits and all the needed objects from the aerospike sets.
### Playing with the database
If you want to explore the database, you can execute the `aql` tool and run some queries:
```sh
docker run -it aerospike/aerospike-tools aql -h 172.17.0.1
aql> SELECT * FROM test;
```
go-git-5.13.2/_examples/submodule/ 0000775 0000000 0000000 00000000000 14744245500 0016751 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/submodule/main.go 0000664 0000000 0000000 00000002017 14744245500 0020224 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
)
// Basic example of how to clone a repository including a submodule and
// updating submodule ref
func main() {
CheckArgs("", "", "")
url := os.Args[1]
directory := os.Args[2]
submodule := os.Args[3]
// Clone the given repository to the given directory
Info("git clone %s %s --recursive", url, directory)
r, err := git.PlainClone(directory, false, &git.CloneOptions{
URL: url,
RecurseSubmodules: git.DefaultSubmoduleRecursionDepth,
})
CheckIfError(err)
w, err := r.Worktree()
if err != nil {
CheckIfError(err)
}
sub, err := w.Submodule(submodule)
if err != nil {
CheckIfError(err)
}
sr, err := sub.Repository()
if err != nil {
CheckIfError(err)
}
sw, err := sr.Worktree()
if err != nil {
CheckIfError(err)
}
Info("git submodule update --remote")
err = sw.Pull(&git.PullOptions{
RemoteName: "origin",
})
if err != nil {
CheckIfError(err)
}
}
go-git-5.13.2/_examples/tag-create-push/ 0000775 0000000 0000000 00000000000 14744245500 0017743 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/tag-create-push/main.go 0000664 0000000 0000000 00000006026 14744245500 0021222 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"log"
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/transport/ssh"
)
// Example of how create a tag and push it to a remote.
func main() {
CheckArgs("", "", "", "", "", "")
url := os.Args[1]
directory := os.Args[2]
tag := os.Args[3]
key := os.Args[6]
r, err := cloneRepo(url, directory, key)
if err != nil {
log.Printf("clone repo error: %s", err)
return
}
created, err := setTag(r, tag)
if err != nil {
log.Printf("create tag error: %s", err)
return
}
if created {
err = pushTags(r, key)
if err != nil {
log.Printf("push tag error: %s", err)
return
}
}
}
func cloneRepo(url, dir, publicKeyPath string) (*git.Repository, error) {
log.Printf("cloning %s into %s", url, dir)
auth, keyErr := publicKey(publicKeyPath)
if keyErr != nil {
return nil, keyErr
}
Info("git clone %s", url)
r, err := git.PlainClone(dir, false, &git.CloneOptions{
Progress: os.Stdout,
URL: url,
Auth: auth,
})
if err != nil {
log.Printf("clone git repo error: %s", err)
return nil, err
}
return r, nil
}
func publicKey(filePath string) (*ssh.PublicKeys, error) {
var publicKey *ssh.PublicKeys
sshKey, _ := os.ReadFile(filePath)
publicKey, err := ssh.NewPublicKeys("git", []byte(sshKey), "")
if err != nil {
return nil, err
}
return publicKey, err
}
func tagExists(tag string, r *git.Repository) bool {
tagFoundErr := "tag was found"
Info("git show-ref --tag")
tags, err := r.TagObjects()
if err != nil {
log.Printf("get tags error: %s", err)
return false
}
res := false
err = tags.ForEach(func(t *object.Tag) error {
if t.Name == tag {
res = true
return fmt.Errorf(tagFoundErr)
}
return nil
})
if err != nil && err.Error() != tagFoundErr {
log.Printf("iterate tags error: %s", err)
return false
}
return res
}
func setTag(r *git.Repository, tag string) (bool, error) {
if tagExists(tag, r) {
log.Printf("tag %s already exists", tag)
return false, nil
}
log.Printf("Set tag %s", tag)
h, err := r.Head()
if err != nil {
log.Printf("get HEAD error: %s", err)
return false, err
}
Info("git tag -a %s %s -m \"%s\"", tag, h.Hash(), tag)
_, err = r.CreateTag(tag, h.Hash(), &git.CreateTagOptions{
Message: tag,
})
if err != nil {
log.Printf("create tag error: %s", err)
return false, err
}
return true, nil
}
func pushTags(r *git.Repository, publicKeyPath string) error {
auth, _ := publicKey(publicKeyPath)
po := &git.PushOptions{
RemoteName: "origin",
Progress: os.Stdout,
RefSpecs: []config.RefSpec{config.RefSpec("refs/tags/*:refs/tags/*")},
Auth: auth,
}
Info("git push --tags")
err := r.Push(po)
if err != nil {
if err == git.NoErrAlreadyUpToDate {
log.Print("origin remote was up to date, no push done")
return nil
}
log.Printf("push to remote origin error: %s", err)
return err
}
return nil
}
go-git-5.13.2/_examples/tag/ 0000775 0000000 0000000 00000000000 14744245500 0015525 5 ustar 00root root 0000000 0000000 go-git-5.13.2/_examples/tag/main.go 0000664 0000000 0000000 00000002005 14744245500 0016775 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"github.com/go-git/go-git/v5"
. "github.com/go-git/go-git/v5/_examples"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/object"
)
// Basic example of how to list tags.
func main() {
CheckArgs("")
path := os.Args[1]
// We instantiate a new repository targeting the given path (the .git folder)
r, err := git.PlainOpen(path)
CheckIfError(err)
// List all tag references, both lightweight tags and annotated tags
Info("git show-ref --tag")
tagrefs, err := r.Tags()
CheckIfError(err)
err = tagrefs.ForEach(func(t *plumbing.Reference) error {
fmt.Println(t)
return nil
})
CheckIfError(err)
// Print each annotated tag object (lightweight tags are not included)
Info("for t in $(git show-ref --tag); do if [ \"$(git cat-file -t $t)\" = \"tag\" ]; then git cat-file -p $t ; fi; done")
tags, err := r.TagObjects()
CheckIfError(err)
err = tags.ForEach(func(t *object.Tag) error {
fmt.Println(t)
return nil
})
CheckIfError(err)
}
go-git-5.13.2/blame.go 0000664 0000000 0000000 00000036227 14744245500 0014416 0 ustar 00root root 0000000 0000000 package git
import (
"bytes"
"container/heap"
"errors"
"fmt"
"io"
"strconv"
"time"
"unicode/utf8"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/utils/diff"
"github.com/sergi/go-diff/diffmatchpatch"
)
// BlameResult represents the result of a Blame operation.
type BlameResult struct {
// Path is the path of the File that we're blaming.
Path string
// Rev (Revision) is the hash of the specified Commit used to generate this result.
Rev plumbing.Hash
// Lines contains every line with its authorship.
Lines []*Line
}
// Blame returns a BlameResult with the information about the last author of
// each line from file `path` at commit `c`.
func Blame(c *object.Commit, path string) (*BlameResult, error) {
// The file to blame is identified by the input arguments:
// commit and path. commit is a Commit object obtained from a Repository. Path
// represents a path to a specific file contained in the repository.
//
// Blaming a file is done by walking the tree in reverse order trying to find where each line was last modified.
//
// When a diff is found it cannot immediately assume it came from that commit, as it may have come from 1 of its
// parents, so it will first try to resolve those diffs from its parents, if it couldn't find the change in its
// parents then it will assign the change to itself.
//
// When encountering 2 parents that have made the same change to a file it will choose the parent that was merged
// into the current branch first (this is determined by the order of the parents inside the commit).
//
// This currently works on a line by line basis, if performance becomes an issue it could be changed to work with
// hunks rather than lines. Then when encountering diff hunks it would need to split them where necessary.
b := new(blame)
b.fRev = c
b.path = path
b.q = new(priorityQueue)
file, err := b.fRev.File(path)
if err != nil {
return nil, err
}
finalLines, err := file.Lines()
if err != nil {
return nil, err
}
finalLength := len(finalLines)
needsMap := make([]lineMap, finalLength)
for i := range needsMap {
needsMap[i] = lineMap{i, i, nil, -1}
}
contents, err := file.Contents()
if err != nil {
return nil, err
}
b.q.Push(&queueItem{
nil,
nil,
c,
path,
contents,
needsMap,
0,
false,
0,
})
items := make([]*queueItem, 0)
for {
items = items[:0]
for {
if b.q.Len() == 0 {
return nil, errors.New("invalid state: no items left on the blame queue")
}
item := b.q.Pop()
items = append(items, item)
next := b.q.Peek()
if next == nil || next.Hash != item.Commit.Hash {
break
}
}
finished, err := b.addBlames(items)
if err != nil {
return nil, err
}
if finished {
break
}
}
b.lineToCommit = make([]*object.Commit, finalLength)
for i := range needsMap {
b.lineToCommit[i] = needsMap[i].Commit
}
lines, err := newLines(finalLines, b.lineToCommit)
if err != nil {
return nil, err
}
return &BlameResult{
Path: path,
Rev: c.Hash,
Lines: lines,
}, nil
}
// Line values represent the contents and author of a line in BlamedResult values.
type Line struct {
// Author is the email address of the last author that modified the line.
Author string
// AuthorName is the name of the last author that modified the line.
AuthorName string
// Text is the original text of the line.
Text string
// Date is when the original text of the line was introduced
Date time.Time
// Hash is the commit hash that introduced the original line
Hash plumbing.Hash
}
func newLine(author, authorName, text string, date time.Time, hash plumbing.Hash) *Line {
return &Line{
Author: author,
AuthorName: authorName,
Text: text,
Hash: hash,
Date: date,
}
}
func newLines(contents []string, commits []*object.Commit) ([]*Line, error) {
result := make([]*Line, 0, len(contents))
for i := range contents {
result = append(result, newLine(
commits[i].Author.Email, commits[i].Author.Name, contents[i],
commits[i].Author.When, commits[i].Hash,
))
}
return result, nil
}
// this struct is internally used by the blame function to hold its
// inputs, outputs and state.
type blame struct {
// the path of the file to blame
path string
// the commit of the final revision of the file to blame
fRev *object.Commit
// resolved lines
lineToCommit []*object.Commit
// queue of commits that need resolving
q *priorityQueue
}
type lineMap struct {
Orig, Cur int
Commit *object.Commit
FromParentNo int
}
func (b *blame) addBlames(curItems []*queueItem) (bool, error) {
curItem := curItems[0]
// Simple optimisation to merge paths, there is potential to go a bit further here and check for any duplicates
// not only if they are all the same.
if len(curItems) == 1 {
curItems = nil
} else if curItem.IdenticalToChild {
allSame := true
lenCurItems := len(curItems)
lowestParentNo := curItem.ParentNo
for i := 1; i < lenCurItems; i++ {
if !curItems[i].IdenticalToChild || curItem.Child != curItems[i].Child {
allSame = false
break
}
lowestParentNo = min(lowestParentNo, curItems[i].ParentNo)
}
if allSame {
curItem.Child.numParentsNeedResolving = curItem.Child.numParentsNeedResolving - lenCurItems + 1
curItems = nil // free the memory
curItem.ParentNo = lowestParentNo
// Now check if we can remove the parent completely
for curItem.Child.IdenticalToChild && curItem.Child.MergedChildren == nil && curItem.Child.numParentsNeedResolving == 1 {
oldChild := curItem.Child
curItem.Child = oldChild.Child
curItem.ParentNo = oldChild.ParentNo
}
}
}
// if we have more than 1 item for this commit, create a single needsMap
if len(curItems) > 1 {
curItem.MergedChildren = make([]childToNeedsMap, len(curItems))
for i, c := range curItems {
curItem.MergedChildren[i] = childToNeedsMap{c.Child, c.NeedsMap, c.IdenticalToChild, c.ParentNo}
}
newNeedsMap := make([]lineMap, 0, len(curItem.NeedsMap))
newNeedsMap = append(newNeedsMap, curItems[0].NeedsMap...)
for i := 1; i < len(curItems); i++ {
cur := curItems[i].NeedsMap
n := 0 // position in newNeedsMap
c := 0 // position in current list
for c < len(cur) {
if n == len(newNeedsMap) {
newNeedsMap = append(newNeedsMap, cur[c:]...)
break
} else if newNeedsMap[n].Cur == cur[c].Cur {
n++
c++
} else if newNeedsMap[n].Cur < cur[c].Cur {
n++
} else {
newNeedsMap = append(newNeedsMap, cur[c])
newPos := len(newNeedsMap) - 1
for newPos > n {
newNeedsMap[newPos-1], newNeedsMap[newPos] = newNeedsMap[newPos], newNeedsMap[newPos-1]
newPos--
}
}
}
}
curItem.NeedsMap = newNeedsMap
curItem.IdenticalToChild = false
curItem.Child = nil
curItems = nil // free the memory
}
parents, err := parentsContainingPath(curItem.path, curItem.Commit)
if err != nil {
return false, err
}
anyPushed := false
for parnetNo, prev := range parents {
currentHash, err := blobHash(curItem.path, curItem.Commit)
if err != nil {
return false, err
}
prevHash, err := blobHash(prev.Path, prev.Commit)
if err != nil {
return false, err
}
if currentHash == prevHash {
if len(parents) == 1 && curItem.MergedChildren == nil && curItem.IdenticalToChild {
// commit that has 1 parent and 1 child and is the same as both, bypass it completely
b.q.Push(&queueItem{
Child: curItem.Child,
Commit: prev.Commit,
path: prev.Path,
Contents: curItem.Contents,
NeedsMap: curItem.NeedsMap, // reuse the NeedsMap as we are throwing away this item
IdenticalToChild: true,
ParentNo: curItem.ParentNo,
})
} else {
b.q.Push(&queueItem{
Child: curItem,
Commit: prev.Commit,
path: prev.Path,
Contents: curItem.Contents,
NeedsMap: append([]lineMap(nil), curItem.NeedsMap...), // create new slice and copy
IdenticalToChild: true,
ParentNo: parnetNo,
})
curItem.numParentsNeedResolving++
}
anyPushed = true
continue
}
// get the contents of the file
file, err := prev.Commit.File(prev.Path)
if err != nil {
return false, err
}
prevContents, err := file.Contents()
if err != nil {
return false, err
}
hunks := diff.Do(prevContents, curItem.Contents)
prevl := -1
curl := -1
need := 0
getFromParent := make([]lineMap, 0)
out:
for h := range hunks {
hLines := countLines(hunks[h].Text)
for hl := 0; hl < hLines; hl++ {
switch hunks[h].Type {
case diffmatchpatch.DiffEqual:
prevl++
curl++
if curl == curItem.NeedsMap[need].Cur {
// add to needs
getFromParent = append(getFromParent, lineMap{curl, prevl, nil, -1})
// move to next need
need++
if need >= len(curItem.NeedsMap) {
break out
}
}
case diffmatchpatch.DiffInsert:
curl++
if curl == curItem.NeedsMap[need].Cur {
// the line we want is added, it may have been added here (or by another parent), skip it for now
need++
if need >= len(curItem.NeedsMap) {
break out
}
}
case diffmatchpatch.DiffDelete:
prevl += hLines
continue out
default:
return false, errors.New("invalid state: invalid hunk Type")
}
}
}
if len(getFromParent) > 0 {
b.q.Push(&queueItem{
curItem,
nil,
prev.Commit,
prev.Path,
prevContents,
getFromParent,
0,
false,
parnetNo,
})
curItem.numParentsNeedResolving++
anyPushed = true
}
}
curItem.Contents = "" // no longer need, free the memory
if !anyPushed {
return finishNeeds(curItem)
}
return false, nil
}
func finishNeeds(curItem *queueItem) (bool, error) {
// any needs left in the needsMap must have come from this revision
for i := range curItem.NeedsMap {
if curItem.NeedsMap[i].Commit == nil {
curItem.NeedsMap[i].Commit = curItem.Commit
curItem.NeedsMap[i].FromParentNo = -1
}
}
if curItem.Child == nil && curItem.MergedChildren == nil {
return true, nil
}
if curItem.MergedChildren == nil {
return applyNeeds(curItem.Child, curItem.NeedsMap, curItem.IdenticalToChild, curItem.ParentNo)
}
for _, ctn := range curItem.MergedChildren {
m := 0 // position in merged needs map
p := 0 // position in parent needs map
for p < len(ctn.NeedsMap) {
if ctn.NeedsMap[p].Cur == curItem.NeedsMap[m].Cur {
ctn.NeedsMap[p].Commit = curItem.NeedsMap[m].Commit
m++
p++
} else if ctn.NeedsMap[p].Cur < curItem.NeedsMap[m].Cur {
p++
} else {
m++
}
}
finished, err := applyNeeds(ctn.Child, ctn.NeedsMap, ctn.IdenticalToChild, ctn.ParentNo)
if finished || err != nil {
return finished, err
}
}
return false, nil
}
func applyNeeds(child *queueItem, needsMap []lineMap, identicalToChild bool, parentNo int) (bool, error) {
if identicalToChild {
for i := range child.NeedsMap {
l := &child.NeedsMap[i]
if l.Cur != needsMap[i].Cur || l.Orig != needsMap[i].Orig {
return false, errors.New("needsMap isn't the same? Why not??")
}
if l.Commit == nil || parentNo < l.FromParentNo {
l.Commit = needsMap[i].Commit
l.FromParentNo = parentNo
}
}
} else {
i := 0
out:
for j := range child.NeedsMap {
l := &child.NeedsMap[j]
for needsMap[i].Orig < l.Cur {
i++
if i == len(needsMap) {
break out
}
}
if l.Cur == needsMap[i].Orig {
if l.Commit == nil || parentNo < l.FromParentNo {
l.Commit = needsMap[i].Commit
l.FromParentNo = parentNo
}
}
}
}
child.numParentsNeedResolving--
if child.numParentsNeedResolving == 0 {
finished, err := finishNeeds(child)
if finished || err != nil {
return finished, err
}
}
return false, nil
}
// String prints the results of a Blame using git-blame's style.
func (b BlameResult) String() string {
var buf bytes.Buffer
// max line number length
mlnl := len(strconv.Itoa(len(b.Lines)))
// max author length
mal := b.maxAuthorLength()
format := fmt.Sprintf("%%s (%%-%ds %%s %%%dd) %%s\n", mal, mlnl)
for ln := range b.Lines {
_, _ = fmt.Fprintf(&buf, format, b.Lines[ln].Hash.String()[:8],
b.Lines[ln].AuthorName, b.Lines[ln].Date.Format("2006-01-02 15:04:05 -0700"), ln+1, b.Lines[ln].Text)
}
return buf.String()
}
// utility function to calculate the number of runes needed
// to print the longest author name in the blame of a file.
func (b BlameResult) maxAuthorLength() int {
m := 0
for ln := range b.Lines {
m = max(m, utf8.RuneCountInString(b.Lines[ln].AuthorName))
}
return m
}
func min(a, b int) int {
if a < b {
return a
}
return b
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
type childToNeedsMap struct {
Child *queueItem
NeedsMap []lineMap
IdenticalToChild bool
ParentNo int
}
type queueItem struct {
Child *queueItem
MergedChildren []childToNeedsMap
Commit *object.Commit
path string
Contents string
NeedsMap []lineMap
numParentsNeedResolving int
IdenticalToChild bool
ParentNo int
}
type priorityQueueImp []*queueItem
func (pq *priorityQueueImp) Len() int { return len(*pq) }
func (pq *priorityQueueImp) Less(i, j int) bool {
return !(*pq)[i].Commit.Less((*pq)[j].Commit)
}
func (pq *priorityQueueImp) Swap(i, j int) { (*pq)[i], (*pq)[j] = (*pq)[j], (*pq)[i] }
func (pq *priorityQueueImp) Push(x any) { *pq = append(*pq, x.(*queueItem)) }
func (pq *priorityQueueImp) Pop() any {
n := len(*pq)
ret := (*pq)[n-1]
(*pq)[n-1] = nil // ovoid memory leak
*pq = (*pq)[0 : n-1]
return ret
}
func (pq *priorityQueueImp) Peek() *object.Commit {
if len(*pq) == 0 {
return nil
}
return (*pq)[0].Commit
}
type priorityQueue priorityQueueImp
func (pq *priorityQueue) Init() { heap.Init((*priorityQueueImp)(pq)) }
func (pq *priorityQueue) Len() int { return (*priorityQueueImp)(pq).Len() }
func (pq *priorityQueue) Push(c *queueItem) {
heap.Push((*priorityQueueImp)(pq), c)
}
func (pq *priorityQueue) Pop() *queueItem {
return heap.Pop((*priorityQueueImp)(pq)).(*queueItem)
}
func (pq *priorityQueue) Peek() *object.Commit { return (*priorityQueueImp)(pq).Peek() }
type parentCommit struct {
Commit *object.Commit
Path string
}
func parentsContainingPath(path string, c *object.Commit) ([]parentCommit, error) {
// TODO: benchmark this method making git.object.Commit.parent public instead of using
// an iterator
var result []parentCommit
iter := c.Parents()
for {
parent, err := iter.Next()
if err == io.EOF {
return result, nil
}
if err != nil {
return nil, err
}
if _, err := parent.File(path); err == nil {
result = append(result, parentCommit{parent, path})
} else {
// look for renames
patch, err := parent.Patch(c)
if err != nil {
return nil, err
} else if patch != nil {
for _, fp := range patch.FilePatches() {
from, to := fp.Files()
if from != nil && to != nil && to.Path() == path {
result = append(result, parentCommit{parent, from.Path()})
break
}
}
}
}
}
}
func blobHash(path string, commit *object.Commit) (plumbing.Hash, error) {
file, err := commit.File(path)
if err != nil {
return plumbing.ZeroHash, err
}
return file.Hash, nil
}
go-git-5.13.2/blame_test.go 0000664 0000000 0000000 00000067132 14744245500 0015454 0 ustar 00root root 0000000 0000000 package git
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/object"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type BlameSuite struct {
BaseSuite
}
var _ = Suite(&BlameSuite{})
func (s *BlameSuite) TestNewLines(c *C) {
h := plumbing.NewHash("ce9f123d790717599aaeb76bc62510de437761be")
lines, err := newLines([]string{"foo"}, []*object.Commit{{
Hash: h,
Message: "foo",
}})
c.Assert(err, IsNil)
c.Assert(lines, HasLen, 1)
c.Assert(lines[0].Text, Equals, "foo")
c.Assert(lines[0].Hash, Equals, h)
}
func (s *BlameSuite) TestNewLinesWithNewLine(c *C) {
lines, err := newLines([]string{"foo", ""}, []*object.Commit{
{Message: "foo"},
{Message: "bar"},
})
c.Assert(err, IsNil)
c.Assert(lines, HasLen, 2)
c.Assert(lines[0].Text, Equals, "foo")
c.Assert(lines[1].Text, Equals, "")
}
type blameTest struct {
repo string
rev string
path string
blames []string // the commits blamed for each line
}
// run a blame on all the suite's tests
func (s *BlameSuite) TestBlame(c *C) {
for _, t := range blameTests {
r := s.NewRepositoryFromPackfile(fixtures.ByURL(t.repo).One())
exp := s.mockBlame(c, t, r)
commit, err := r.CommitObject(plumbing.NewHash(t.rev))
c.Assert(err, IsNil)
obt, err := Blame(commit, t.path)
c.Assert(err, IsNil)
c.Assert(obt, DeepEquals, exp)
for i, l := range obt.Lines {
c.Assert(l.Hash.String(), Equals, t.blames[i])
}
}
}
func (s *BlameSuite) mockBlame(c *C, t blameTest, r *Repository) (blame *BlameResult) {
commit, err := r.CommitObject(plumbing.NewHash(t.rev))
c.Assert(err, IsNil, Commentf("%v: repo=%s, rev=%s", err, t.repo, t.rev))
f, err := commit.File(t.path)
c.Assert(err, IsNil)
lines, err := f.Lines()
c.Assert(err, IsNil)
c.Assert(len(t.blames), Equals, len(lines), Commentf(
"repo=%s, path=%s, rev=%s: the number of lines in the file and the number of expected blames differ (len(blames)=%d, len(lines)=%d)\nblames=%#q\nlines=%#q", t.repo, t.path, t.rev, len(t.blames), len(lines), t.blames, lines))
blamedLines := make([]*Line, 0, len(t.blames))
for i := range t.blames {
commit, err := r.CommitObject(plumbing.NewHash(t.blames[i]))
c.Assert(err, IsNil)
l := &Line{
Author: commit.Author.Email,
AuthorName: commit.Author.Name,
Text: lines[i],
Date: commit.Author.When,
Hash: commit.Hash,
}
blamedLines = append(blamedLines, l)
}
return &BlameResult{
Path: t.path,
Rev: plumbing.NewHash(t.rev),
Lines: blamedLines,
}
}
// utility function to avoid writing so many repeated commits
func repeat(s string, n int) []string {
if n < 0 {
panic("repeat: n < 0")
}
r := make([]string, 0, n)
for i := 0; i < n; i++ {
r = append(r, s)
}
return r
}
// utility function to concat slices
func concat(vargs ...[]string) []string {
var r []string
for _, ss := range vargs {
r = append(r, ss...)
}
return r
}
var blameTests = [...]blameTest{
// use the blame2humantest.bash script to easily add more tests.
{"https://github.com/git-fixtures/basic.git", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "binary.jpg", concat(
repeat("35e85108805c84807bc66a02d91535e1e24b38b9", 285),
)},
{"https://github.com/git-fixtures/basic.git", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "CHANGELOG", concat(
repeat("b8e471f58bcbca63b07bda20e428190409c2db47", 1),
)},
{"https://github.com/git-fixtures/basic.git", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "go/example.go", concat(
repeat("918c48b83bd081e863dbe1b80f8998f058cd8294", 142),
)},
{"https://github.com/git-fixtures/basic.git", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "json/long.json", concat(
repeat("af2d6a6954d532f8ffb47615169c8fdf9d383a1a", 6492),
)},
{"https://github.com/git-fixtures/basic.git", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "json/short.json", concat(
repeat("af2d6a6954d532f8ffb47615169c8fdf9d383a1a", 22),
)},
{"https://github.com/git-fixtures/basic.git", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "LICENSE", concat(
repeat("b029517f6300c2da0f4b651b8642506cd6aaf45d", 22),
)},
{"https://github.com/git-fixtures/basic.git", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "php/crappy.php", concat(
repeat("918c48b83bd081e863dbe1b80f8998f058cd8294", 259),
)},
{"https://github.com/git-fixtures/basic.git", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "vendor/foo.go", concat(
repeat("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", 7),
)},
/*
// This fails due to the different diff tool being used to create the patches.
// For example in commit d4b48a39aba7d3bd3e8abef2274a95b112d1ae73 when "function echo_status()" is added:
// - 'git diff' adds the new "}\n\n" to the end of function and keeps the "}\n\n" beforehand blamed to the previous commit
// - our diff adds the new "}\n\n" before the function and reuses the existing "}\n\n" to close the new function
// the resultant file is the same, but it causes blame not to match.
{"https://github.com/spinnaker/spinnaker.git", "f39d86f59a0781f130e8de6b2115329c1fbe9545", "InstallSpinnaker.sh", concat(
repeat("ce9f123d790717599aaeb76bc62510de437761be", 2),
repeat("a47d0aaeda421f06df248ad65bd58230766bf118", 1),
repeat("23673af3ad70b50bba7fdafadc2323302f5ba520", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 29),
repeat("9a06d3f20eabb254d0a1e2ff7735ef007ccd595e", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 4),
repeat("a47d0aaeda421f06df248ad65bd58230766bf118", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 5),
repeat("0c5bb1e4392e751f884f3c57de5d4aee72c40031", 2),
repeat("d4b48a39aba7d3bd3e8abef2274a95b112d1ae73", 3),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 7),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 1),
repeat("b7015a5d36990d69a054482556127b9c7404a24a", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 2),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 5),
repeat("d4b48a39aba7d3bd3e8abef2274a95b112d1ae73", 7),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 3),
repeat("d4b48a39aba7d3bd3e8abef2274a95b112d1ae73", 6),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 10),
repeat("b7015a5d36990d69a054482556127b9c7404a24a", 4),
repeat("0c5bb1e4392e751f884f3c57de5d4aee72c40031", 2),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 2),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 4),
repeat("23673af3ad70b50bba7fdafadc2323302f5ba520", 4),
repeat("d4b48a39aba7d3bd3e8abef2274a95b112d1ae73", 4),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 1),
repeat("d4b48a39aba7d3bd3e8abef2274a95b112d1ae73", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 1),
repeat("b7015a5d36990d69a054482556127b9c7404a24a", 1),
repeat("0c5bb1e4392e751f884f3c57de5d4aee72c40031", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 13),
repeat("b7015a5d36990d69a054482556127b9c7404a24a", 2),
repeat("8eb116de9128c314ac8a6f5310ca500b8c74f5db", 6),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 1),
repeat("b7015a5d36990d69a054482556127b9c7404a24a", 2),
repeat("0c5bb1e4392e751f884f3c57de5d4aee72c40031", 1),
repeat("8eb116de9128c314ac8a6f5310ca500b8c74f5db", 4),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 1),
repeat("8eb116de9128c314ac8a6f5310ca500b8c74f5db", 3),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 2),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 1),
repeat("8eb116de9128c314ac8a6f5310ca500b8c74f5db", 4),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 1),
repeat("8eb116de9128c314ac8a6f5310ca500b8c74f5db", 3),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 15),
repeat("b41d7c0e5b20bbe7c8eb6606731a3ff68f4e3941", 1),
repeat("8eb116de9128c314ac8a6f5310ca500b8c74f5db", 1),
repeat("b41d7c0e5b20bbe7c8eb6606731a3ff68f4e3941", 8),
repeat("8eb116de9128c314ac8a6f5310ca500b8c74f5db", 2),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 12),
repeat("505577dc87d300cf562dc4702a05a5615d90d855", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 5),
repeat("370d61cdbc1f3c90db6759f1599ccbabd40ad6c1", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 4),
repeat("8eb116de9128c314ac8a6f5310ca500b8c74f5db", 1),
repeat("b41d7c0e5b20bbe7c8eb6606731a3ff68f4e3941", 5),
repeat("8eb116de9128c314ac8a6f5310ca500b8c74f5db", 3),
repeat("b41d7c0e5b20bbe7c8eb6606731a3ff68f4e3941", 2),
repeat("8eb116de9128c314ac8a6f5310ca500b8c74f5db", 2),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 9),
repeat("8eb116de9128c314ac8a6f5310ca500b8c74f5db", 1),
repeat("b41d7c0e5b20bbe7c8eb6606731a3ff68f4e3941", 3),
repeat("8eb116de9128c314ac8a6f5310ca500b8c74f5db", 4),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 1),
repeat("8eb116de9128c314ac8a6f5310ca500b8c74f5db", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 6),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 1),
repeat("b7015a5d36990d69a054482556127b9c7404a24a", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 6),
repeat("d2f6214b625db706384b378a29cc4c22237db97a", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 3),
repeat("d2f6214b625db706384b378a29cc4c22237db97a", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 4),
repeat("b7015a5d36990d69a054482556127b9c7404a24a", 1),
repeat("c9c2a0ec03968ab17e8b16fdec9661eb1dbea173", 1),
repeat("d2f6214b625db706384b378a29cc4c22237db97a", 2),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 1),
repeat("b7015a5d36990d69a054482556127b9c7404a24a", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 12),
repeat("6328ee836affafc1b52127147b5ca07300ac78e6", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 5),
repeat("6328ee836affafc1b52127147b5ca07300ac78e6", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 3),
repeat("6328ee836affafc1b52127147b5ca07300ac78e6", 1),
repeat("01e65d67eed8afcb67a6bdf1c962541f62b299c9", 5),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 3),
repeat("a47d0aaeda421f06df248ad65bd58230766bf118", 5),
repeat("6328ee836affafc1b52127147b5ca07300ac78e6", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 5),
repeat("6328ee836affafc1b52127147b5ca07300ac78e6", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 1),
repeat("01e65d67eed8afcb67a6bdf1c962541f62b299c9", 2),
repeat("6328ee836affafc1b52127147b5ca07300ac78e6", 1),
repeat("01e65d67eed8afcb67a6bdf1c962541f62b299c9", 1),
repeat("6328ee836affafc1b52127147b5ca07300ac78e6", 1),
repeat("b2c7142082d52b09ca20228606c31c7479c0833e", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 1),
repeat("495c7118e7cf757aa04eab410b64bfb5b5149ad2", 1),
repeat("d4b48a39aba7d3bd3e8abef2274a95b112d1ae73", 1),
repeat("495c7118e7cf757aa04eab410b64bfb5b5149ad2", 3),
repeat("d4b48a39aba7d3bd3e8abef2274a95b112d1ae73", 1),
repeat("495c7118e7cf757aa04eab410b64bfb5b5149ad2", 1),
repeat("50d0556563599366f29cb286525780004fa5a317", 1),
repeat("dd2d03c19658ff96d371aef00e75e2e54702da0e", 1),
repeat("d4b48a39aba7d3bd3e8abef2274a95b112d1ae73", 1),
repeat("dd2d03c19658ff96d371aef00e75e2e54702da0e", 2),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 2),
repeat("01e65d67eed8afcb67a6bdf1c962541f62b299c9", 1),
repeat("6328ee836affafc1b52127147b5ca07300ac78e6", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 1),
repeat("b5c6053a46993b20d1b91e7b7206bffa54669ad7", 1),
repeat("9e74d009894d73dd07773ea6b3bdd8323db980f7", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 1),
repeat("d4b48a39aba7d3bd3e8abef2274a95b112d1ae73", 4),
repeat("01e65d67eed8afcb67a6bdf1c962541f62b299c9", 1),
repeat("6328ee836affafc1b52127147b5ca07300ac78e6", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 1),
repeat("b7015a5d36990d69a054482556127b9c7404a24a", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 1),
repeat("d2f6214b625db706384b378a29cc4c22237db97a", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 3),
repeat("b41d7c0e5b20bbe7c8eb6606731a3ff68f4e3941", 2),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 2),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 4),
repeat("d2f6214b625db706384b378a29cc4c22237db97a", 1),
repeat("b7015a5d36990d69a054482556127b9c7404a24a", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 5),
repeat("b41d7c0e5b20bbe7c8eb6606731a3ff68f4e3941", 2),
repeat("d2f6214b625db706384b378a29cc4c22237db97a", 1),
repeat("ce9f123d790717599aaeb76bc62510de437761be", 5),
repeat("ba486de7c025457963701114c683dcd4708e1dee", 4),
repeat("6328ee836affafc1b52127147b5ca07300ac78e6", 1),
repeat("01e65d67eed8afcb67a6bdf1c962541f62b299c9", 1),
repeat("6328ee836affafc1b52127147b5ca07300ac78e6", 1),
repeat("01e65d67eed8afcb67a6bdf1c962541f62b299c9", 3),
repeat("6328ee836affafc1b52127147b5ca07300ac78e6", 1),
repeat("01e65d67eed8afcb67a6bdf1c962541f62b299c9", 3),
repeat("6328ee836affafc1b52127147b5ca07300ac78e6", 2),
repeat("01e65d67eed8afcb67a6bdf1c962541f62b299c9", 3),
repeat("3de4f77c105f700f50d9549d32b9a05a01b46c4b", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 2),
repeat("370d61cdbc1f3c90db6759f1599ccbabd40ad6c1", 6),
repeat("dd7e66c862209e8b912694a582a09c0db3227f0d", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 2),
repeat("dd7e66c862209e8b912694a582a09c0db3227f0d", 3),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 1),
repeat("dd7e66c862209e8b912694a582a09c0db3227f0d", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 3),
)},
*/
{"https://github.com/spinnaker/spinnaker.git", "f39d86f59a0781f130e8de6b2115329c1fbe9545", "pylib/spinnaker/reconfigure_spinnaker.py", concat(
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 22),
repeat("c89dab0d42f1856d157357e9010f8cc6a12f5b1f", 7),
)},
{"https://github.com/spinnaker/spinnaker.git", "f39d86f59a0781f130e8de6b2115329c1fbe9545", "pylib/spinnaker/validate_configuration.py", concat(
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 29),
repeat("1e3d328a2cabda5d0aaddc5dec65271343e0dc37", 19),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 15),
repeat("b5d999e2986e190d81767cd3cfeda0260f9f6fb8", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 12),
repeat("1e14f94bcf82694fdc7e2dcbbfdbbed58db0f4d9", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 4),
repeat("b5d999e2986e190d81767cd3cfeda0260f9f6fb8", 8),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 1),
repeat("b5d999e2986e190d81767cd3cfeda0260f9f6fb8", 4),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 46),
repeat("1e14f94bcf82694fdc7e2dcbbfdbbed58db0f4d9", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 4),
repeat("1e3d328a2cabda5d0aaddc5dec65271343e0dc37", 42),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 1),
repeat("1e3d328a2cabda5d0aaddc5dec65271343e0dc37", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 3),
repeat("1e3d328a2cabda5d0aaddc5dec65271343e0dc37", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 1),
repeat("1e14f94bcf82694fdc7e2dcbbfdbbed58db0f4d9", 8),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 1),
repeat("1e14f94bcf82694fdc7e2dcbbfdbbed58db0f4d9", 2),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 3),
repeat("1e3d328a2cabda5d0aaddc5dec65271343e0dc37", 3),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 12),
repeat("1e14f94bcf82694fdc7e2dcbbfdbbed58db0f4d9", 10),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 69),
repeat("b5d999e2986e190d81767cd3cfeda0260f9f6fb8", 7),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 4),
)},
{"https://github.com/spinnaker/spinnaker.git", "f39d86f59a0781f130e8de6b2115329c1fbe9545", "pylib/spinnaker/run.py", concat(
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 185),
)},
/*
// This fails due to the different diff tool being used to create the patches.
// For commit c89dab0d42f1856d157357e9010f8cc6a12f5b1f our diff tool keeps an existing newline as moved in the file, whereas
// 'git diff' says the existing newline was deleted and a new one created.
{"https://github.com/spinnaker/spinnaker.git", "f39d86f59a0781f130e8de6b2115329c1fbe9545", "pylib/spinnaker/configurator.py", concat(
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 53),
repeat("c89dab0d42f1856d157357e9010f8cc6a12f5b1f", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 4),
repeat("e805183c72f0426fb073728c01901c2fd2db1da6", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 6),
repeat("023d4fb17b76e0fe0764971df8b8538b735a1d67", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 36),
repeat("1e14f94bcf82694fdc7e2dcbbfdbbed58db0f4d9", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 3),
repeat("1e14f94bcf82694fdc7e2dcbbfdbbed58db0f4d9", 3),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 4),
repeat("c89dab0d42f1856d157357e9010f8cc6a12f5b1f", 13),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 2),
repeat("c89dab0d42f1856d157357e9010f8cc6a12f5b1f", 18),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 2),
repeat("1e14f94bcf82694fdc7e2dcbbfdbbed58db0f4d9", 1),
repeat("023d4fb17b76e0fe0764971df8b8538b735a1d67", 17),
repeat("c89dab0d42f1856d157357e9010f8cc6a12f5b1f", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 43),
)},
*/
{"https://github.com/spinnaker/spinnaker.git", "f39d86f59a0781f130e8de6b2115329c1fbe9545", "pylib/spinnaker/__init__.py", []string{}},
{"https://github.com/spinnaker/spinnaker.git", "f39d86f59a0781f130e8de6b2115329c1fbe9545", "gradle/wrapper/gradle-wrapper.jar", concat(
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 1),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 7),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 2),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 2),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 3),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 1),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 10),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 11),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 29),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 7),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 58),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 1),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 1),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 2),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 2),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 13),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 4),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 3),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 13),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 2),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 9),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 3),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 1),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 17),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 3),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 6),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 6),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 3),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 5),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 4),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 3),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 2),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 1),
repeat("11d6c1020b1765e236ca65b2709d37b5bfdba0f4", 6),
repeat("bc02440df2ff95a014a7b3cb11b98c3a2bded777", 55),
)},
{"https://github.com/spinnaker/spinnaker.git", "f39d86f59a0781f130e8de6b2115329c1fbe9545", "config/settings.js", concat(
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 17),
repeat("99534ecc895fe17a1d562bb3049d4168a04d0865", 1),
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 43),
repeat("d2838db9f6ef9628645e7d04cd9658a83e8708ea", 1),
repeat("637ba49300f701cfbd859c1ccf13c4f39a9ba1c8", 1),
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 13),
)},
{"https://github.com/spinnaker/spinnaker.git", "f39d86f59a0781f130e8de6b2115329c1fbe9545", "config/default-spinnaker-local.yml", concat(
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 9),
repeat("5e09821cbd7d710405b61cab0a795c2982a71b9c", 2),
repeat("99534ecc895fe17a1d562bb3049d4168a04d0865", 1),
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 2),
repeat("a596972a661d9a7deca8abd18b52ce1a39516e89", 1),
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 5),
repeat("5e09821cbd7d710405b61cab0a795c2982a71b9c", 2),
repeat("a596972a661d9a7deca8abd18b52ce1a39516e89", 1),
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 5),
repeat("5e09821cbd7d710405b61cab0a795c2982a71b9c", 1),
repeat("8980daf661408a3faa1f22c225702a5c1d11d5c9", 1),
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 25),
repeat("caf6d62e8285d4681514dd8027356fb019bc97ff", 1),
repeat("eaf7614cad81e8ab5c813dd4821129d0c04ea449", 1),
repeat("caf6d62e8285d4681514dd8027356fb019bc97ff", 1),
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 24),
repeat("974b775a8978b120ff710cac93a21c7387b914c9", 2),
repeat("3ce7b902a51bac2f10994f7d1f251b616c975e54", 1),
repeat("5a2a845bc08974a36d599a4a4b7e25be833823b0", 6),
repeat("41e96c54a478e5d09dd07ed7feb2d8d08d8c7e3c", 14),
repeat("7c8d9a6081d9cb7a56c479bfe64d70540ea32795", 5),
repeat("5a2a845bc08974a36d599a4a4b7e25be833823b0", 2),
)},
{"https://github.com/spinnaker/spinnaker.git", "f39d86f59a0781f130e8de6b2115329c1fbe9545", "config/spinnaker.yml", concat(
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 32),
repeat("41e96c54a478e5d09dd07ed7feb2d8d08d8c7e3c", 2),
repeat("5a2a845bc08974a36d599a4a4b7e25be833823b0", 1),
repeat("41e96c54a478e5d09dd07ed7feb2d8d08d8c7e3c", 6),
repeat("5a2a845bc08974a36d599a4a4b7e25be833823b0", 2),
repeat("41e96c54a478e5d09dd07ed7feb2d8d08d8c7e3c", 2),
repeat("5a2a845bc08974a36d599a4a4b7e25be833823b0", 2),
repeat("41e96c54a478e5d09dd07ed7feb2d8d08d8c7e3c", 3),
repeat("7c8d9a6081d9cb7a56c479bfe64d70540ea32795", 3),
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 50),
repeat("974b775a8978b120ff710cac93a21c7387b914c9", 2),
repeat("d4553dac205023fa77652308af1a2d1cf52138fb", 1),
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 9),
repeat("caf6d62e8285d4681514dd8027356fb019bc97ff", 1),
repeat("eaf7614cad81e8ab5c813dd4821129d0c04ea449", 1),
repeat("caf6d62e8285d4681514dd8027356fb019bc97ff", 1),
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 39),
repeat("079e42e7c979541b6fab7343838f7b9fd4a360cd", 6),
repeat("ae904e8d60228c21c47368f6a10f1cc9ca3aeebf", 15),
)},
/*
// This fails due to the different diff tool being used to create the patches
// For commit d1ff4e13e9e0b500821aa558373878f93487e34b our diff tool keeps an existing newline as moved in the file, whereas
// 'git diff' says the existing newline was deleted and a new one created
{"https://github.com/spinnaker/spinnaker.git", "f39d86f59a0781f130e8de6b2115329c1fbe9545", "dev/install_development.sh", concat(
repeat("99534ecc895fe17a1d562bb3049d4168a04d0865", 1),
repeat("d1ff4e13e9e0b500821aa558373878f93487e34b", 71),
)},
*/
/*
// This fails due to the different diff tool being used to create the patches
// For commit 838aed816872c52ed435e4876a7b64dba0bed500 the diff tools assign the "fi\n" to different line numbers
{"https://github.com/spinnaker/spinnaker.git", "f39d86f59a0781f130e8de6b2115329c1fbe9545", "dev/bootstrap_dev.sh", concat(
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 95),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 10),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 7),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 2),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 1),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 3),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 4),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 12),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 2),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 2),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 2),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 3),
repeat("d1ff4e13e9e0b500821aa558373878f93487e34b", 6),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 1),
repeat("d1ff4e13e9e0b500821aa558373878f93487e34b", 4),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 1),
repeat("376599177551c3f04ccc94d71bbb4d037dec0c3f", 2),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 17),
repeat("d1ff4e13e9e0b500821aa558373878f93487e34b", 2),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 2),
repeat("d1ff4e13e9e0b500821aa558373878f93487e34b", 2),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 3),
repeat("d1ff4e13e9e0b500821aa558373878f93487e34b", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 3),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 5),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 5),
repeat("d1ff4e13e9e0b500821aa558373878f93487e34b", 8),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 4),
repeat("d1ff4e13e9e0b500821aa558373878f93487e34b", 1),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 6),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 1),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 4),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 10),
repeat("d1ff4e13e9e0b500821aa558373878f93487e34b", 2),
repeat("fc28a378558cdb5bbc08b6dcb96ee77c5b716760", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 1),
repeat("d1ff4e13e9e0b500821aa558373878f93487e34b", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 8),
repeat("d1ff4e13e9e0b500821aa558373878f93487e34b", 1),
repeat("fc28a378558cdb5bbc08b6dcb96ee77c5b716760", 1),
repeat("d1ff4e13e9e0b500821aa558373878f93487e34b", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 4),
repeat("24551a5d486969a2972ee05e87f16444890f9555", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 2),
repeat("24551a5d486969a2972ee05e87f16444890f9555", 1),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 8),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 13),
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 5),
repeat("24551a5d486969a2972ee05e87f16444890f9555", 1),
repeat("838aed816872c52ed435e4876a7b64dba0bed500", 8),
)},
*/
{"https://github.com/spinnaker/spinnaker.git", "f39d86f59a0781f130e8de6b2115329c1fbe9545", "dev/create_google_dev_vm.sh", concat(
repeat("a24001f6938d425d0e7504bdf5d27fc866a85c3d", 20),
)},
}
go-git-5.13.2/cli/ 0000775 0000000 0000000 00000000000 14744245500 0013544 5 ustar 00root root 0000000 0000000 go-git-5.13.2/cli/go-git/ 0000775 0000000 0000000 00000000000 14744245500 0014732 5 ustar 00root root 0000000 0000000 go-git-5.13.2/cli/go-git/go.mod 0000664 0000000 0000000 00000002310 14744245500 0016034 0 ustar 00root root 0000000 0000000 module github.com/go-git/go-git/cli/go-git
go 1.20
require (
github.com/go-git/go-git/v5 v5.12.0
github.com/jessevdk/go-flags v1.6.1
)
require (
dario.cat/mergo v1.0.0 // indirect
github.com/Microsoft/go-winio v0.6.1 // indirect
github.com/ProtonMail/go-crypto v1.0.0 // indirect
github.com/cloudflare/circl v1.3.7 // indirect
github.com/cyphar/filepath-securejoin v0.2.4 // indirect
github.com/emirpasic/gods v1.18.1 // indirect
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
github.com/go-git/go-billy/v5 v5.5.0 // indirect
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
github.com/kevinburke/ssh_config v1.2.0 // indirect
github.com/pjbgf/sha1cd v0.3.0 // indirect
github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
github.com/skeema/knownhosts v1.2.2 // indirect
github.com/xanzy/ssh-agent v0.3.3 // indirect
golang.org/x/crypto v0.31.0 // indirect
golang.org/x/mod v0.12.0 // indirect
golang.org/x/net v0.23.0 // indirect
golang.org/x/sys v0.28.0 // indirect
golang.org/x/tools v0.13.0 // indirect
gopkg.in/warnings.v0 v0.1.2 // indirect
)
go-git-5.13.2/cli/go-git/go.sum 0000664 0000000 0000000 00000027340 14744245500 0016073 0 ustar 00root root 0000000 0000000 dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
github.com/ProtonMail/go-crypto v1.0.0 h1:LRuvITjQWX+WIfr930YHG2HNfjR1uOfyf5vE0kC2U78=
github.com/ProtonMail/go-crypto v1.0.0/go.mod h1:EjAoLdwvbIOoOQr3ihjnSoLZRtE8azugULFRteWMNc0=
github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0=
github.com/cloudflare/circl v1.3.3/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA=
github.com/cloudflare/circl v1.3.7 h1:qlCDlTPz2n9fu58M0Nh1J/JzcFpfgkFHHX3O35r5vcU=
github.com/cloudflare/circl v1.3.7/go.mod h1:sRTcRWXGLrKw6yIGJ+l7amYJFfAXbZG0kBSc8r4zxgA=
github.com/cyphar/filepath-securejoin v0.2.4 h1:Ugdm7cg7i6ZK6x3xDF1oEu1nfkyfH53EtKeQYTC3kyg=
github.com/cyphar/filepath-securejoin v0.2.4/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/elazarl/goproxy v0.0.0-20230808193330-2592e75ae04a h1:mATvB/9r/3gvcejNsXKSkQ6lcIaNec2nyfOdlTBR2lU=
github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
github.com/gliderlabs/ssh v0.3.7 h1:iV3Bqi942d9huXnzEF2Mt+CY9gLu8DNM4Obd+8bODRE=
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
github.com/go-git/go-billy/v5 v5.5.0 h1:yEY4yhzCDuMGSv83oGxiBotRzhwhNr8VZyphhiu+mTU=
github.com/go-git/go-billy/v5 v5.5.0/go.mod h1:hmexnoNsr2SJU1Ju67OaNz5ASJY3+sHgFRpCtpDCKow=
github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=
github.com/go-git/go-git/v5 v5.12.0 h1:7Md+ndsjrzZxbddRDZjF14qK+NN56sy6wkqaVrjZtys=
github.com/go-git/go-git/v5 v5.12.0/go.mod h1:FTM9VKtnI2m65hNI/TenDDDnUf2Q9FHnXYjuz9i5OEY=
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
github.com/jessevdk/go-flags v1.6.1 h1:Cvu5U8UGrLay1rZfv/zP7iLpSHGUZ/Ou68T0iX1bBK4=
github.com/jessevdk/go-flags v1.6.1/go.mod h1:Mk8T1hIAWpOiJiHa9rJASDK2UGWji0EuPGBnNLMooyc=
github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=
github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/onsi/gomega v1.27.10 h1:naR28SdDFlqrG6kScpT8VWpu1xWY5nJRCF3XaYyBjhI=
github.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4=
github.com/pjbgf/sha1cd v0.3.0/go.mod h1:nZ1rrWOcGJ5uZgEEVL1VUM9iRQiZvWdbZjkKyFzPPsI=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
github.com/skeema/knownhosts v1.2.2 h1:Iug2P4fLmDw9f41PB6thxUkNUkJzB5i+1/exaj40L3A=
github.com/skeema/knownhosts v1.2.2/go.mod h1:xYbVRSPxqBZFrdmDyMmsOs+uX1UZC3nTN3ThzgDxUwo=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
golang.org/x/crypto v0.3.1-0.20221117191849-2c476679df9a/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc=
golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs=
golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
golang.org/x/term v0.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
golang.org/x/tools v0.13.0 h1:Iey4qkscZuv0VvIt8E0neZjtPVQFSc870HQ448QgEmQ=
golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
go-git-5.13.2/cli/go-git/main.go 0000664 0000000 0000000 00000001771 14744245500 0016213 0 ustar 00root root 0000000 0000000 package main
import (
"os"
"path/filepath"
"github.com/jessevdk/go-flags"
)
const (
bin = "go-git"
receivePackBin = "git-receive-pack"
uploadPackBin = "git-upload-pack"
)
func main() {
switch filepath.Base(os.Args[0]) {
case receivePackBin:
os.Args = append([]string{"git", "receive-pack"}, os.Args[1:]...)
case uploadPackBin:
os.Args = append([]string{"git", "upload-pack"}, os.Args[1:]...)
}
parser := flags.NewNamedParser(bin, flags.Default)
parser.AddCommand("update-server-info", "", "", &CmdUpdateServerInfo{})
parser.AddCommand("receive-pack", "", "", &CmdReceivePack{})
parser.AddCommand("upload-pack", "", "", &CmdUploadPack{})
parser.AddCommand("version", "Show the version information.", "", &CmdVersion{})
_, err := parser.Parse()
if err != nil {
if e, ok := err.(*flags.Error); ok && e.Type == flags.ErrCommandRequired {
parser.WriteHelp(os.Stdout)
}
os.Exit(1)
}
}
type cmd struct {
Verbose bool `short:"v" description:"Activates the verbose mode"`
}
go-git-5.13.2/cli/go-git/receive_pack.go 0000664 0000000 0000000 00000001261 14744245500 0017701 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"path/filepath"
"github.com/go-git/go-git/v5/plumbing/transport/file"
)
type CmdReceivePack struct {
cmd
Args struct {
GitDir string `positional-arg-name:"git-dir" required:"true"`
} `positional-args:"yes"`
}
func (CmdReceivePack) Usage() string {
//TODO: git-receive-pack returns error code 129 if arguments are invalid.
return fmt.Sprintf("usage: %s ", os.Args[0])
}
func (c *CmdReceivePack) Execute(args []string) error {
gitDir, err := filepath.Abs(c.Args.GitDir)
if err != nil {
return err
}
if err := file.ServeReceivePack(gitDir); err != nil {
fmt.Fprintln(os.Stderr, "ERR:", err)
os.Exit(128)
}
return nil
}
go-git-5.13.2/cli/go-git/update_server_info.go 0000664 0000000 0000000 00000001545 14744245500 0021151 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing/serverinfo"
"github.com/go-git/go-git/v5/storage/filesystem"
)
// CmdUpdateServerInfo command updates the server info files in the repository.
// This is used by git http transport (dumb) to generate a list of available
// refs for the repository. See:
// https://git-scm.com/docs/git-update-server-info
type CmdUpdateServerInfo struct {
cmd
}
// Usage returns the usage of the command.
func (CmdUpdateServerInfo) Usage() string {
return fmt.Sprintf("within a git repository run: %s", os.Args[0])
}
// Execute runs the command.
func (c *CmdUpdateServerInfo) Execute(args []string) error {
r, err := git.PlainOpen(".")
if err != nil {
return err
}
fs := r.Storer.(*filesystem.Storage).Filesystem()
return serverinfo.UpdateServerInfo(r.Storer, fs)
}
go-git-5.13.2/cli/go-git/upload_pack.go 0000664 0000000 0000000 00000001355 14744245500 0017547 0 ustar 00root root 0000000 0000000 package main
import (
"fmt"
"os"
"path/filepath"
"github.com/go-git/go-git/v5/plumbing/transport/file"
)
type CmdUploadPack struct {
cmd
Args struct {
GitDir string `positional-arg-name:"git-dir" required:"true"`
} `positional-args:"yes"`
}
func (CmdUploadPack) Usage() string {
//TODO: usage: git upload-pack [--strict] [--timeout=]
//TODO: git-upload-pack returns error code 129 if arguments are invalid.
return fmt.Sprintf("usage: %s ", os.Args[0])
}
func (c *CmdUploadPack) Execute(args []string) error {
gitDir, err := filepath.Abs(c.Args.GitDir)
if err != nil {
return err
}
if err := file.ServeUploadPack(gitDir); err != nil {
fmt.Fprintln(os.Stderr, "ERR:", err)
os.Exit(128)
}
return nil
}
go-git-5.13.2/cli/go-git/version.go 0000664 0000000 0000000 00000000327 14744245500 0016750 0 ustar 00root root 0000000 0000000 package main
import "fmt"
var version string
var build string
type CmdVersion struct{}
func (c *CmdVersion) Execute(args []string) error {
fmt.Printf("%s (%s) - build %s\n", bin, version, build)
return nil
}
go-git-5.13.2/common.go 0000664 0000000 0000000 00000000705 14744245500 0014616 0 ustar 00root root 0000000 0000000 package git
import "strings"
// countLines returns the number of lines in a string à la git, this is
// The newline character is assumed to be '\n'. The empty string
// contains 0 lines. If the last line of the string doesn't end with a
// newline, it will still be considered a line.
func countLines(s string) int {
if s == "" {
return 0
}
nEOL := strings.Count(s, "\n")
if strings.HasSuffix(s, "\n") {
return nEOL
}
return nEOL + 1
}
go-git-5.13.2/common_test.go 0000664 0000000 0000000 00000012330 14744245500 0015652 0 ustar 00root root 0000000 0000000 package git
import (
"os"
"testing"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-git/v5/storage/memory"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-billy/v5/util"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type BaseSuite struct {
fixtures.Suite
Repository *Repository
cache map[string]*Repository
}
func (s *BaseSuite) SetUpSuite(c *C) {
s.buildBasicRepository(c)
s.cache = make(map[string]*Repository)
}
func (s *BaseSuite) TearDownSuite(c *C) {
s.Suite.TearDownSuite(c)
}
func (s *BaseSuite) buildBasicRepository(_ *C) {
f := fixtures.Basic().One()
s.Repository = s.NewRepository(f)
}
// NewRepository returns a new repository using the .git folder, if the fixture
// is tagged as worktree the filesystem from fixture is used, otherwise a new
// memfs filesystem is used as worktree.
func (s *BaseSuite) NewRepository(f *fixtures.Fixture) *Repository {
var worktree, dotgit billy.Filesystem
if f.Is("worktree") {
r, err := PlainOpen(f.Worktree().Root())
if err != nil {
panic(err)
}
return r
}
dotgit = f.DotGit()
worktree = memfs.New()
st := filesystem.NewStorage(dotgit, cache.NewObjectLRUDefault())
r, err := Open(st, worktree)
if err != nil {
panic(err)
}
return r
}
// NewRepositoryWithEmptyWorktree returns a new repository using the .git folder
// from the fixture but without a empty memfs worktree, the index and the
// modules are deleted from the .git folder.
func (s *BaseSuite) NewRepositoryWithEmptyWorktree(f *fixtures.Fixture) *Repository {
dotgit := f.DotGit()
err := dotgit.Remove("index")
if err != nil {
panic(err)
}
err = util.RemoveAll(dotgit, "modules")
if err != nil {
panic(err)
}
worktree := memfs.New()
st := filesystem.NewStorage(dotgit, cache.NewObjectLRUDefault())
r, err := Open(st, worktree)
if err != nil {
panic(err)
}
return r
}
func (s *BaseSuite) NewRepositoryFromPackfile(f *fixtures.Fixture) *Repository {
h := f.PackfileHash
if r, ok := s.cache[h]; ok {
return r
}
storer := memory.NewStorage()
p := f.Packfile()
defer func() { _ = p.Close() }()
if err := packfile.UpdateObjectStorage(storer, p); err != nil {
panic(err)
}
err := storer.SetReference(plumbing.NewHashReference(plumbing.HEAD, plumbing.NewHash(f.Head)))
if err != nil {
panic(err)
}
r, err := Open(storer, memfs.New())
if err != nil {
panic(err)
}
s.cache[h] = r
return r
}
func (s *BaseSuite) GetBasicLocalRepositoryURL() string {
fixture := fixtures.Basic().One()
return s.GetLocalRepositoryURL(fixture)
}
func (s *BaseSuite) GetLocalRepositoryURL(f *fixtures.Fixture) string {
return f.DotGit().Root()
}
func (s *BaseSuite) TemporalHomeDir() (path string, clean func()) {
home, err := os.UserHomeDir()
if err != nil {
panic(err)
}
fs := osfs.New(home)
relPath, err := util.TempDir(fs, "", "")
if err != nil {
panic(err)
}
path = fs.Join(fs.Root(), relPath)
clean = func() {
_ = util.RemoveAll(fs, relPath)
}
return
}
func (s *BaseSuite) TemporalFilesystem(c *C) (fs billy.Filesystem) {
fs = osfs.New(c.MkDir())
path, err := util.TempDir(fs, "", "")
if err != nil {
panic(err)
}
fs, err = fs.Chroot(path)
if err != nil {
panic(err)
}
return
}
type SuiteCommon struct{}
var _ = Suite(&SuiteCommon{})
var countLinesTests = [...]struct {
i string // the string we want to count lines from
e int // the expected number of lines in i
}{
{"", 0},
{"a", 1},
{"a\n", 1},
{"a\nb", 2},
{"a\nb\n", 2},
{"a\nb\nc", 3},
{"a\nb\nc\n", 3},
{"a\n\n\nb\n", 4},
{"first line\n\tsecond line\nthird line\n", 3},
}
func (s *SuiteCommon) TestCountLines(c *C) {
for i, t := range countLinesTests {
o := countLines(t.i)
c.Assert(o, Equals, t.e, Commentf("subtest %d, input=%q", i, t.i))
}
}
func AssertReferences(c *C, r *Repository, expected map[string]string) {
for name, target := range expected {
expected := plumbing.NewReferenceFromStrings(name, target)
obtained, err := r.Reference(expected.Name(), true)
c.Assert(err, IsNil)
c.Assert(obtained, DeepEquals, expected)
}
}
func AssertReferencesMissing(c *C, r *Repository, expected []string) {
for _, name := range expected {
_, err := r.Reference(plumbing.ReferenceName(name), false)
c.Assert(err, NotNil)
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
}
}
func CommitNewFile(c *C, repo *Repository, fileName string) plumbing.Hash {
wt, err := repo.Worktree()
c.Assert(err, IsNil)
fd, err := wt.Filesystem.Create(fileName)
c.Assert(err, IsNil)
_, err = fd.Write([]byte("# test file"))
c.Assert(err, IsNil)
err = fd.Close()
c.Assert(err, IsNil)
_, err = wt.Add(fileName)
c.Assert(err, IsNil)
sha, err := wt.Commit("test commit", &CommitOptions{
Author: &object.Signature{
Name: "test",
Email: "test@example.com",
When: time.Now(),
},
Committer: &object.Signature{
Name: "test",
Email: "test@example.com",
When: time.Now(),
},
})
c.Assert(err, IsNil)
return sha
}
go-git-5.13.2/config/ 0000775 0000000 0000000 00000000000 14744245500 0014242 5 ustar 00root root 0000000 0000000 go-git-5.13.2/config/branch.go 0000664 0000000 0000000 00000006162 14744245500 0016033 0 ustar 00root root 0000000 0000000 package config
import (
"errors"
"strings"
"github.com/go-git/go-git/v5/plumbing"
format "github.com/go-git/go-git/v5/plumbing/format/config"
)
var (
errBranchEmptyName = errors.New("branch config: empty name")
errBranchInvalidMerge = errors.New("branch config: invalid merge")
errBranchInvalidRebase = errors.New("branch config: rebase must be one of 'true' or 'interactive'")
)
// Branch contains information on the
// local branches and which remote to track
type Branch struct {
// Name of branch
Name string
// Remote name of remote to track
Remote string
// Merge is the local refspec for the branch
Merge plumbing.ReferenceName
// Rebase instead of merge when pulling. Valid values are
// "true" and "interactive". "false" is undocumented and
// typically represented by the non-existence of this field
Rebase string
// Description explains what the branch is for.
// Multi-line explanations may be used.
//
// Original git command to edit:
// git branch --edit-description
Description string
raw *format.Subsection
}
// Validate validates fields of branch
func (b *Branch) Validate() error {
if b.Name == "" {
return errBranchEmptyName
}
if b.Merge != "" && !b.Merge.IsBranch() {
return errBranchInvalidMerge
}
if b.Rebase != "" &&
b.Rebase != "true" &&
b.Rebase != "interactive" &&
b.Rebase != "false" {
return errBranchInvalidRebase
}
return plumbing.NewBranchReferenceName(b.Name).Validate()
}
func (b *Branch) marshal() *format.Subsection {
if b.raw == nil {
b.raw = &format.Subsection{}
}
b.raw.Name = b.Name
if b.Remote == "" {
b.raw.RemoveOption(remoteSection)
} else {
b.raw.SetOption(remoteSection, b.Remote)
}
if b.Merge == "" {
b.raw.RemoveOption(mergeKey)
} else {
b.raw.SetOption(mergeKey, string(b.Merge))
}
if b.Rebase == "" {
b.raw.RemoveOption(rebaseKey)
} else {
b.raw.SetOption(rebaseKey, b.Rebase)
}
if b.Description == "" {
b.raw.RemoveOption(descriptionKey)
} else {
desc := quoteDescription(b.Description)
b.raw.SetOption(descriptionKey, desc)
}
return b.raw
}
// hack to trigger conditional quoting in the
// plumbing/format/config/Encoder.encodeOptions
//
// Current Encoder implementation uses Go %q format if value contains a backslash character,
// which is not consistent with reference git implementation.
// git just replaces newline characters with \n, while Encoder prints them directly.
// Until value quoting fix, we should escape description value by replacing newline characters with \n.
func quoteDescription(desc string) string {
return strings.ReplaceAll(desc, "\n", `\n`)
}
func (b *Branch) unmarshal(s *format.Subsection) error {
b.raw = s
b.Name = b.raw.Name
b.Remote = b.raw.Options.Get(remoteSection)
b.Merge = plumbing.ReferenceName(b.raw.Options.Get(mergeKey))
b.Rebase = b.raw.Options.Get(rebaseKey)
b.Description = unquoteDescription(b.raw.Options.Get(descriptionKey))
return b.Validate()
}
// hack to enable conditional quoting in the
// plumbing/format/config/Encoder.encodeOptions
// goto quoteDescription for details.
func unquoteDescription(desc string) string {
return strings.ReplaceAll(desc, `\n`, "\n")
}
go-git-5.13.2/config/branch_test.go 0000664 0000000 0000000 00000003555 14744245500 0017075 0 ustar 00root root 0000000 0000000 package config
import (
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
type BranchSuite struct{}
var _ = Suite(&BranchSuite{})
func (b *BranchSuite) TestValidateName(c *C) {
goodBranch := Branch{
Name: "master",
Remote: "some_remote",
Merge: "refs/heads/master",
}
badBranch := Branch{
Remote: "some_remote",
Merge: "refs/heads/master",
}
c.Assert(goodBranch.Validate(), IsNil)
c.Assert(badBranch.Validate(), NotNil)
}
func (b *BranchSuite) TestValidateMerge(c *C) {
goodBranch := Branch{
Name: "master",
Remote: "some_remote",
Merge: "refs/heads/master",
}
badBranch := Branch{
Name: "master",
Remote: "some_remote",
Merge: "blah",
}
c.Assert(goodBranch.Validate(), IsNil)
c.Assert(badBranch.Validate(), NotNil)
}
func (b *BranchSuite) TestMarshal(c *C) {
expected := []byte(`[core]
bare = false
[branch "branch-tracking-on-clone"]
remote = fork
merge = refs/heads/branch-tracking-on-clone
rebase = interactive
`)
cfg := NewConfig()
cfg.Branches["branch-tracking-on-clone"] = &Branch{
Name: "branch-tracking-on-clone",
Remote: "fork",
Merge: plumbing.ReferenceName("refs/heads/branch-tracking-on-clone"),
Rebase: "interactive",
}
actual, err := cfg.Marshal()
c.Assert(err, IsNil)
c.Assert(string(actual), Equals, string(expected))
}
func (b *BranchSuite) TestUnmarshal(c *C) {
input := []byte(`[core]
bare = false
[branch "branch-tracking-on-clone"]
remote = fork
merge = refs/heads/branch-tracking-on-clone
rebase = interactive
`)
cfg := NewConfig()
err := cfg.Unmarshal(input)
c.Assert(err, IsNil)
branch := cfg.Branches["branch-tracking-on-clone"]
c.Assert(branch.Name, Equals, "branch-tracking-on-clone")
c.Assert(branch.Remote, Equals, "fork")
c.Assert(branch.Merge, Equals, plumbing.ReferenceName("refs/heads/branch-tracking-on-clone"))
c.Assert(branch.Rebase, Equals, "interactive")
}
go-git-5.13.2/config/config.go 0000664 0000000 0000000 00000041220 14744245500 0016035 0 ustar 00root root 0000000 0000000 // Package config contains the abstraction of multiple config files
package config
import (
"bytes"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"sort"
"strconv"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-git/v5/internal/url"
"github.com/go-git/go-git/v5/plumbing"
format "github.com/go-git/go-git/v5/plumbing/format/config"
)
const (
// DefaultFetchRefSpec is the default refspec used for fetch.
DefaultFetchRefSpec = "+refs/heads/*:refs/remotes/%s/*"
// DefaultPushRefSpec is the default refspec used for push.
DefaultPushRefSpec = "refs/heads/*:refs/heads/*"
)
// ConfigStorer generic storage of Config object
type ConfigStorer interface {
Config() (*Config, error)
SetConfig(*Config) error
}
var (
ErrInvalid = errors.New("config invalid key in remote or branch")
ErrRemoteConfigNotFound = errors.New("remote config not found")
ErrRemoteConfigEmptyURL = errors.New("remote config: empty URL")
ErrRemoteConfigEmptyName = errors.New("remote config: empty name")
)
// Scope defines the scope of a config file, such as local, global or system.
type Scope int
// Available ConfigScope's
const (
LocalScope Scope = iota
GlobalScope
SystemScope
)
// Config contains the repository configuration
// https://www.kernel.org/pub/software/scm/git/docs/git-config.html#FILES
type Config struct {
Core struct {
// IsBare if true this repository is assumed to be bare and has no
// working directory associated with it.
IsBare bool
// Worktree is the path to the root of the working tree.
Worktree string
// CommentChar is the character indicating the start of a
// comment for commands like commit and tag
CommentChar string
// RepositoryFormatVersion identifies the repository format and layout version.
RepositoryFormatVersion format.RepositoryFormatVersion
}
User struct {
// Name is the personal name of the author and the committer of a commit.
Name string
// Email is the email of the author and the committer of a commit.
Email string
}
Author struct {
// Name is the personal name of the author of a commit.
Name string
// Email is the email of the author of a commit.
Email string
}
Committer struct {
// Name is the personal name of the committer of a commit.
Name string
// Email is the email of the committer of a commit.
Email string
}
Pack struct {
// Window controls the size of the sliding window for delta
// compression. The default is 10. A value of 0 turns off
// delta compression entirely.
Window uint
}
Init struct {
// DefaultBranch Allows overriding the default branch name
// e.g. when initializing a new repository or when cloning
// an empty repository.
DefaultBranch string
}
Extensions struct {
// ObjectFormat specifies the hash algorithm to use. The
// acceptable values are sha1 and sha256. If not specified,
// sha1 is assumed. It is an error to specify this key unless
// core.repositoryFormatVersion is 1.
//
// This setting must not be changed after repository initialization
// (e.g. clone or init).
ObjectFormat format.ObjectFormat
}
// Remotes list of repository remotes, the key of the map is the name
// of the remote, should equal to RemoteConfig.Name.
Remotes map[string]*RemoteConfig
// Submodules list of repository submodules, the key of the map is the name
// of the submodule, should equal to Submodule.Name.
Submodules map[string]*Submodule
// Branches list of branches, the key is the branch name and should
// equal Branch.Name
Branches map[string]*Branch
// URLs list of url rewrite rules, if repo url starts with URL.InsteadOf value, it will be replaced with the
// key instead.
URLs map[string]*URL
// Raw contains the raw information of a config file. The main goal is
// preserve the parsed information from the original format, to avoid
// dropping unsupported fields.
Raw *format.Config
}
// NewConfig returns a new empty Config.
func NewConfig() *Config {
config := &Config{
Remotes: make(map[string]*RemoteConfig),
Submodules: make(map[string]*Submodule),
Branches: make(map[string]*Branch),
URLs: make(map[string]*URL),
Raw: format.New(),
}
config.Pack.Window = DefaultPackWindow
return config
}
// ReadConfig reads a config file from a io.Reader.
func ReadConfig(r io.Reader) (*Config, error) {
b, err := io.ReadAll(r)
if err != nil {
return nil, err
}
cfg := NewConfig()
if err = cfg.Unmarshal(b); err != nil {
return nil, err
}
return cfg, nil
}
// LoadConfig loads a config file from a given scope. The returned Config,
// contains exclusively information from the given scope. If it couldn't find a
// config file to the given scope, an empty one is returned.
func LoadConfig(scope Scope) (*Config, error) {
if scope == LocalScope {
return nil, fmt.Errorf("LocalScope should be read from the a ConfigStorer")
}
files, err := Paths(scope)
if err != nil {
return nil, err
}
for _, file := range files {
f, err := osfs.Default.Open(file)
if err != nil {
if os.IsNotExist(err) {
continue
}
return nil, err
}
defer f.Close()
return ReadConfig(f)
}
return NewConfig(), nil
}
// Paths returns the config file location for a given scope.
func Paths(scope Scope) ([]string, error) {
var files []string
switch scope {
case GlobalScope:
xdg := os.Getenv("XDG_CONFIG_HOME")
if xdg != "" {
files = append(files, filepath.Join(xdg, "git/config"))
}
home, err := os.UserHomeDir()
if err != nil {
return nil, err
}
files = append(files,
filepath.Join(home, ".gitconfig"),
filepath.Join(home, ".config/git/config"),
)
case SystemScope:
files = append(files, "/etc/gitconfig")
}
return files, nil
}
// Validate validates the fields and sets the default values.
func (c *Config) Validate() error {
for name, r := range c.Remotes {
if r.Name != name {
return ErrInvalid
}
if err := r.Validate(); err != nil {
return err
}
}
for name, b := range c.Branches {
if b.Name != name {
return ErrInvalid
}
if err := b.Validate(); err != nil {
return err
}
}
return nil
}
const (
remoteSection = "remote"
submoduleSection = "submodule"
branchSection = "branch"
coreSection = "core"
packSection = "pack"
userSection = "user"
authorSection = "author"
committerSection = "committer"
initSection = "init"
urlSection = "url"
extensionsSection = "extensions"
fetchKey = "fetch"
urlKey = "url"
pushurlKey = "pushurl"
bareKey = "bare"
worktreeKey = "worktree"
commentCharKey = "commentChar"
windowKey = "window"
mergeKey = "merge"
rebaseKey = "rebase"
nameKey = "name"
emailKey = "email"
descriptionKey = "description"
defaultBranchKey = "defaultBranch"
repositoryFormatVersionKey = "repositoryformatversion"
objectFormat = "objectformat"
mirrorKey = "mirror"
// DefaultPackWindow holds the number of previous objects used to
// generate deltas. The value 10 is the same used by git command.
DefaultPackWindow = uint(10)
)
// Unmarshal parses a git-config file and stores it.
func (c *Config) Unmarshal(b []byte) error {
r := bytes.NewBuffer(b)
d := format.NewDecoder(r)
c.Raw = format.New()
if err := d.Decode(c.Raw); err != nil {
return err
}
c.unmarshalCore()
c.unmarshalUser()
c.unmarshalInit()
if err := c.unmarshalPack(); err != nil {
return err
}
unmarshalSubmodules(c.Raw, c.Submodules)
if err := c.unmarshalBranches(); err != nil {
return err
}
if err := c.unmarshalURLs(); err != nil {
return err
}
return c.unmarshalRemotes()
}
func (c *Config) unmarshalCore() {
s := c.Raw.Section(coreSection)
if s.Options.Get(bareKey) == "true" {
c.Core.IsBare = true
}
c.Core.Worktree = s.Options.Get(worktreeKey)
c.Core.CommentChar = s.Options.Get(commentCharKey)
}
func (c *Config) unmarshalUser() {
s := c.Raw.Section(userSection)
c.User.Name = s.Options.Get(nameKey)
c.User.Email = s.Options.Get(emailKey)
s = c.Raw.Section(authorSection)
c.Author.Name = s.Options.Get(nameKey)
c.Author.Email = s.Options.Get(emailKey)
s = c.Raw.Section(committerSection)
c.Committer.Name = s.Options.Get(nameKey)
c.Committer.Email = s.Options.Get(emailKey)
}
func (c *Config) unmarshalPack() error {
s := c.Raw.Section(packSection)
window := s.Options.Get(windowKey)
if window == "" {
c.Pack.Window = DefaultPackWindow
} else {
winUint, err := strconv.ParseUint(window, 10, 32)
if err != nil {
return err
}
c.Pack.Window = uint(winUint)
}
return nil
}
func (c *Config) unmarshalRemotes() error {
s := c.Raw.Section(remoteSection)
for _, sub := range s.Subsections {
r := &RemoteConfig{}
if err := r.unmarshal(sub); err != nil {
return err
}
c.Remotes[r.Name] = r
}
// Apply insteadOf url rules
for _, r := range c.Remotes {
r.applyURLRules(c.URLs)
}
return nil
}
func (c *Config) unmarshalURLs() error {
s := c.Raw.Section(urlSection)
for _, sub := range s.Subsections {
r := &URL{}
if err := r.unmarshal(sub); err != nil {
return err
}
c.URLs[r.Name] = r
}
return nil
}
func unmarshalSubmodules(fc *format.Config, submodules map[string]*Submodule) {
s := fc.Section(submoduleSection)
for _, sub := range s.Subsections {
m := &Submodule{}
m.unmarshal(sub)
if m.Validate() == ErrModuleBadPath {
continue
}
submodules[m.Name] = m
}
}
func (c *Config) unmarshalBranches() error {
bs := c.Raw.Section(branchSection)
for _, sub := range bs.Subsections {
b := &Branch{}
if err := b.unmarshal(sub); err != nil {
return err
}
c.Branches[b.Name] = b
}
return nil
}
func (c *Config) unmarshalInit() {
s := c.Raw.Section(initSection)
c.Init.DefaultBranch = s.Options.Get(defaultBranchKey)
}
// Marshal returns Config encoded as a git-config file.
func (c *Config) Marshal() ([]byte, error) {
c.marshalCore()
c.marshalExtensions()
c.marshalUser()
c.marshalPack()
c.marshalRemotes()
c.marshalSubmodules()
c.marshalBranches()
c.marshalURLs()
c.marshalInit()
buf := bytes.NewBuffer(nil)
if err := format.NewEncoder(buf).Encode(c.Raw); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
func (c *Config) marshalCore() {
s := c.Raw.Section(coreSection)
s.SetOption(bareKey, fmt.Sprintf("%t", c.Core.IsBare))
if string(c.Core.RepositoryFormatVersion) != "" {
s.SetOption(repositoryFormatVersionKey, string(c.Core.RepositoryFormatVersion))
}
if c.Core.Worktree != "" {
s.SetOption(worktreeKey, c.Core.Worktree)
}
}
func (c *Config) marshalExtensions() {
// Extensions are only supported on Version 1, therefore
// ignore them otherwise.
if c.Core.RepositoryFormatVersion == format.Version_1 {
s := c.Raw.Section(extensionsSection)
s.SetOption(objectFormat, string(c.Extensions.ObjectFormat))
}
}
func (c *Config) marshalUser() {
s := c.Raw.Section(userSection)
if c.User.Name != "" {
s.SetOption(nameKey, c.User.Name)
}
if c.User.Email != "" {
s.SetOption(emailKey, c.User.Email)
}
s = c.Raw.Section(authorSection)
if c.Author.Name != "" {
s.SetOption(nameKey, c.Author.Name)
}
if c.Author.Email != "" {
s.SetOption(emailKey, c.Author.Email)
}
s = c.Raw.Section(committerSection)
if c.Committer.Name != "" {
s.SetOption(nameKey, c.Committer.Name)
}
if c.Committer.Email != "" {
s.SetOption(emailKey, c.Committer.Email)
}
}
func (c *Config) marshalPack() {
s := c.Raw.Section(packSection)
if c.Pack.Window != DefaultPackWindow {
s.SetOption(windowKey, fmt.Sprintf("%d", c.Pack.Window))
}
}
func (c *Config) marshalRemotes() {
s := c.Raw.Section(remoteSection)
newSubsections := make(format.Subsections, 0, len(c.Remotes))
added := make(map[string]bool)
for _, subsection := range s.Subsections {
if remote, ok := c.Remotes[subsection.Name]; ok {
newSubsections = append(newSubsections, remote.marshal())
added[subsection.Name] = true
}
}
remoteNames := make([]string, 0, len(c.Remotes))
for name := range c.Remotes {
remoteNames = append(remoteNames, name)
}
sort.Strings(remoteNames)
for _, name := range remoteNames {
if !added[name] {
newSubsections = append(newSubsections, c.Remotes[name].marshal())
}
}
s.Subsections = newSubsections
}
func (c *Config) marshalSubmodules() {
s := c.Raw.Section(submoduleSection)
s.Subsections = make(format.Subsections, len(c.Submodules))
var i int
for _, r := range c.Submodules {
section := r.marshal()
// the submodule section at config is a subset of the .gitmodule file
// we should remove the non-valid options for the config file.
section.RemoveOption(pathKey)
s.Subsections[i] = section
i++
}
}
func (c *Config) marshalBranches() {
s := c.Raw.Section(branchSection)
newSubsections := make(format.Subsections, 0, len(c.Branches))
added := make(map[string]bool)
for _, subsection := range s.Subsections {
if branch, ok := c.Branches[subsection.Name]; ok {
newSubsections = append(newSubsections, branch.marshal())
added[subsection.Name] = true
}
}
branchNames := make([]string, 0, len(c.Branches))
for name := range c.Branches {
branchNames = append(branchNames, name)
}
sort.Strings(branchNames)
for _, name := range branchNames {
if !added[name] {
newSubsections = append(newSubsections, c.Branches[name].marshal())
}
}
s.Subsections = newSubsections
}
func (c *Config) marshalURLs() {
s := c.Raw.Section(urlSection)
s.Subsections = make(format.Subsections, len(c.URLs))
var i int
for _, r := range c.URLs {
section := r.marshal()
// the submodule section at config is a subset of the .gitmodule file
// we should remove the non-valid options for the config file.
s.Subsections[i] = section
i++
}
}
func (c *Config) marshalInit() {
s := c.Raw.Section(initSection)
if c.Init.DefaultBranch != "" {
s.SetOption(defaultBranchKey, c.Init.DefaultBranch)
}
}
// RemoteConfig contains the configuration for a given remote repository.
type RemoteConfig struct {
// Name of the remote
Name string
// URLs the URLs of a remote repository. It must be non-empty. Fetch will
// always use the first URL, while push will use all of them.
URLs []string
// Mirror indicates that the repository is a mirror of remote.
Mirror bool
// insteadOfRulesApplied have urls been modified
insteadOfRulesApplied bool
// originalURLs are the urls before applying insteadOf rules
originalURLs []string
// Fetch the default set of "refspec" for fetch operation
Fetch []RefSpec
// raw representation of the subsection, filled by marshal or unmarshal are
// called
raw *format.Subsection
}
// Validate validates the fields and sets the default values.
func (c *RemoteConfig) Validate() error {
if c.Name == "" {
return ErrRemoteConfigEmptyName
}
if len(c.URLs) == 0 {
return ErrRemoteConfigEmptyURL
}
for _, r := range c.Fetch {
if err := r.Validate(); err != nil {
return err
}
}
if len(c.Fetch) == 0 {
c.Fetch = []RefSpec{RefSpec(fmt.Sprintf(DefaultFetchRefSpec, c.Name))}
}
return plumbing.NewRemoteHEADReferenceName(c.Name).Validate()
}
func (c *RemoteConfig) unmarshal(s *format.Subsection) error {
c.raw = s
fetch := []RefSpec{}
for _, f := range c.raw.Options.GetAll(fetchKey) {
rs := RefSpec(f)
if err := rs.Validate(); err != nil {
return err
}
fetch = append(fetch, rs)
}
c.Name = c.raw.Name
c.URLs = append([]string(nil), c.raw.Options.GetAll(urlKey)...)
c.URLs = append(c.URLs, c.raw.Options.GetAll(pushurlKey)...)
c.Fetch = fetch
c.Mirror = c.raw.Options.Get(mirrorKey) == "true"
return nil
}
func (c *RemoteConfig) marshal() *format.Subsection {
if c.raw == nil {
c.raw = &format.Subsection{}
}
c.raw.Name = c.Name
if len(c.URLs) == 0 {
c.raw.RemoveOption(urlKey)
} else {
urls := c.URLs
if c.insteadOfRulesApplied {
urls = c.originalURLs
}
c.raw.SetOption(urlKey, urls...)
}
if len(c.Fetch) == 0 {
c.raw.RemoveOption(fetchKey)
} else {
var values []string
for _, rs := range c.Fetch {
values = append(values, rs.String())
}
c.raw.SetOption(fetchKey, values...)
}
if c.Mirror {
c.raw.SetOption(mirrorKey, strconv.FormatBool(c.Mirror))
}
return c.raw
}
func (c *RemoteConfig) IsFirstURLLocal() bool {
return url.IsLocalEndpoint(c.URLs[0])
}
func (c *RemoteConfig) applyURLRules(urlRules map[string]*URL) {
// save original urls
originalURLs := make([]string, len(c.URLs))
copy(originalURLs, c.URLs)
for i, url := range c.URLs {
if matchingURLRule := findLongestInsteadOfMatch(url, urlRules); matchingURLRule != nil {
c.URLs[i] = matchingURLRule.ApplyInsteadOf(c.URLs[i])
c.insteadOfRulesApplied = true
}
}
if c.insteadOfRulesApplied {
c.originalURLs = originalURLs
}
}
go-git-5.13.2/config/config_test.go 0000664 0000000 0000000 00000024723 14744245500 0017105 0 ustar 00root root 0000000 0000000 package config
import (
"os"
"path/filepath"
"strings"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-billy/v5/util"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
type ConfigSuite struct{}
var _ = Suite(&ConfigSuite{})
func (s *ConfigSuite) TestUnmarshal(c *C) {
input := []byte(`[core]
bare = true
worktree = foo
commentchar = bar
[user]
name = John Doe
email = john@example.com
[author]
name = Jane Roe
email = jane@example.com
[committer]
name = Richard Roe
email = richard@example.com
[pack]
window = 20
[remote "origin"]
url = git@github.com:mcuadros/go-git.git
fetch = +refs/heads/*:refs/remotes/origin/*
[remote "alt"]
url = git@github.com:mcuadros/go-git.git
url = git@github.com:src-d/go-git.git
fetch = +refs/heads/*:refs/remotes/origin/*
fetch = +refs/pull/*:refs/remotes/origin/pull/*
[remote "insteadOf"]
url = https://github.com/kostyay/go-git.git
[remote "win-local"]
url = X:\\Git\\
[submodule "qux"]
path = qux
url = https://github.com/foo/qux.git
branch = bar
[branch "master"]
remote = origin
merge = refs/heads/master
description = "Add support for branch description.\\n\\nEdit branch description: git branch --edit-description\\n"
[init]
defaultBranch = main
[url "ssh://git@github.com/"]
insteadOf = https://github.com/
`)
cfg := NewConfig()
err := cfg.Unmarshal(input)
c.Assert(err, IsNil)
c.Assert(cfg.Core.IsBare, Equals, true)
c.Assert(cfg.Core.Worktree, Equals, "foo")
c.Assert(cfg.Core.CommentChar, Equals, "bar")
c.Assert(cfg.User.Name, Equals, "John Doe")
c.Assert(cfg.User.Email, Equals, "john@example.com")
c.Assert(cfg.Author.Name, Equals, "Jane Roe")
c.Assert(cfg.Author.Email, Equals, "jane@example.com")
c.Assert(cfg.Committer.Name, Equals, "Richard Roe")
c.Assert(cfg.Committer.Email, Equals, "richard@example.com")
c.Assert(cfg.Pack.Window, Equals, uint(20))
c.Assert(cfg.Remotes, HasLen, 4)
c.Assert(cfg.Remotes["origin"].Name, Equals, "origin")
c.Assert(cfg.Remotes["origin"].URLs, DeepEquals, []string{"git@github.com:mcuadros/go-git.git"})
c.Assert(cfg.Remotes["origin"].Fetch, DeepEquals, []RefSpec{"+refs/heads/*:refs/remotes/origin/*"})
c.Assert(cfg.Remotes["alt"].Name, Equals, "alt")
c.Assert(cfg.Remotes["alt"].URLs, DeepEquals, []string{"git@github.com:mcuadros/go-git.git", "git@github.com:src-d/go-git.git"})
c.Assert(cfg.Remotes["alt"].Fetch, DeepEquals, []RefSpec{"+refs/heads/*:refs/remotes/origin/*", "+refs/pull/*:refs/remotes/origin/pull/*"})
c.Assert(cfg.Remotes["win-local"].Name, Equals, "win-local")
c.Assert(cfg.Remotes["win-local"].URLs, DeepEquals, []string{"X:\\Git\\"})
c.Assert(cfg.Remotes["insteadOf"].URLs, DeepEquals, []string{"ssh://git@github.com/kostyay/go-git.git"})
c.Assert(cfg.Submodules, HasLen, 1)
c.Assert(cfg.Submodules["qux"].Name, Equals, "qux")
c.Assert(cfg.Submodules["qux"].URL, Equals, "https://github.com/foo/qux.git")
c.Assert(cfg.Submodules["qux"].Branch, Equals, "bar")
c.Assert(cfg.Branches["master"].Remote, Equals, "origin")
c.Assert(cfg.Branches["master"].Merge, Equals, plumbing.ReferenceName("refs/heads/master"))
c.Assert(cfg.Branches["master"].Description, Equals, "Add support for branch description.\n\nEdit branch description: git branch --edit-description\n")
c.Assert(cfg.Init.DefaultBranch, Equals, "main")
}
func (s *ConfigSuite) TestMarshal(c *C) {
output := []byte(`[core]
bare = true
worktree = bar
[pack]
window = 20
[remote "alt"]
url = git@github.com:mcuadros/go-git.git
url = git@github.com:src-d/go-git.git
fetch = +refs/heads/*:refs/remotes/origin/*
fetch = +refs/pull/*:refs/remotes/origin/pull/*
[remote "insteadOf"]
url = https://github.com/kostyay/go-git.git
[remote "origin"]
url = git@github.com:mcuadros/go-git.git
[remote "win-local"]
url = "X:\\Git\\"
[submodule "qux"]
url = https://github.com/foo/qux.git
[branch "master"]
remote = origin
merge = refs/heads/master
description = "Add support for branch description.\\n\\nEdit branch description: git branch --edit-description\\n"
[url "ssh://git@github.com/"]
insteadOf = https://github.com/
[init]
defaultBranch = main
`)
cfg := NewConfig()
cfg.Core.IsBare = true
cfg.Core.Worktree = "bar"
cfg.Pack.Window = 20
cfg.Init.DefaultBranch = "main"
cfg.Remotes["origin"] = &RemoteConfig{
Name: "origin",
URLs: []string{"git@github.com:mcuadros/go-git.git"},
}
cfg.Remotes["alt"] = &RemoteConfig{
Name: "alt",
URLs: []string{"git@github.com:mcuadros/go-git.git", "git@github.com:src-d/go-git.git"},
Fetch: []RefSpec{"+refs/heads/*:refs/remotes/origin/*", "+refs/pull/*:refs/remotes/origin/pull/*"},
}
cfg.Remotes["win-local"] = &RemoteConfig{
Name: "win-local",
URLs: []string{"X:\\Git\\"},
}
cfg.Remotes["insteadOf"] = &RemoteConfig{
Name: "insteadOf",
URLs: []string{"https://github.com/kostyay/go-git.git"},
}
cfg.Submodules["qux"] = &Submodule{
Name: "qux",
URL: "https://github.com/foo/qux.git",
}
cfg.Branches["master"] = &Branch{
Name: "master",
Remote: "origin",
Merge: "refs/heads/master",
Description: "Add support for branch description.\n\nEdit branch description: git branch --edit-description\n",
}
cfg.URLs["ssh://git@github.com/"] = &URL{
Name: "ssh://git@github.com/",
InsteadOf: "https://github.com/",
}
b, err := cfg.Marshal()
c.Assert(err, IsNil)
c.Assert(string(b), Equals, string(output))
}
func (s *ConfigSuite) TestUnmarshalMarshal(c *C) {
input := []byte(`[core]
bare = true
worktree = foo
custom = ignored
[user]
name = John Doe
email = john@example.com
[author]
name = Jane Roe
email = jane@example.com
[committer]
name = Richard Roe
email = richard@example.co
[pack]
window = 20
[remote "insteadOf"]
url = https://github.com/kostyay/go-git.git
[remote "origin"]
url = git@github.com:mcuadros/go-git.git
fetch = +refs/heads/*:refs/remotes/origin/*
mirror = true
[remote "win-local"]
url = "X:\\Git\\"
[branch "master"]
remote = origin
merge = refs/heads/master
[url "ssh://git@github.com/"]
insteadOf = https://github.com/
`)
cfg := NewConfig()
err := cfg.Unmarshal(input)
c.Assert(err, IsNil)
output, err := cfg.Marshal()
c.Assert(err, IsNil)
c.Assert(string(output), DeepEquals, string(input))
}
func (s *ConfigSuite) TestLoadConfigXDG(c *C) {
cfg := NewConfig()
cfg.User.Name = "foo"
cfg.User.Email = "foo@foo.com"
tmp, err := util.TempDir(osfs.Default, "", "test-commit-options")
c.Assert(err, IsNil)
defer util.RemoveAll(osfs.Default, tmp)
err = osfs.Default.MkdirAll(filepath.Join(tmp, "git"), 0777)
c.Assert(err, IsNil)
os.Setenv("XDG_CONFIG_HOME", tmp)
defer func() {
os.Setenv("XDG_CONFIG_HOME", "")
}()
content, err := cfg.Marshal()
c.Assert(err, IsNil)
cfgFile := filepath.Join(tmp, "git/config")
err = util.WriteFile(osfs.Default, cfgFile, content, 0777)
c.Assert(err, IsNil)
cfg, err = LoadConfig(GlobalScope)
c.Assert(err, IsNil)
c.Assert(cfg.User.Email, Equals, "foo@foo.com")
}
func (s *ConfigSuite) TestValidateConfig(c *C) {
config := &Config{
Remotes: map[string]*RemoteConfig{
"bar": {
Name: "bar",
URLs: []string{"http://foo/bar"},
},
},
Branches: map[string]*Branch{
"bar": {
Name: "bar",
},
"foo": {
Name: "foo",
Remote: "origin",
Merge: plumbing.ReferenceName("refs/heads/foo"),
},
},
}
c.Assert(config.Validate(), IsNil)
}
func (s *ConfigSuite) TestValidateInvalidRemote(c *C) {
config := &Config{
Remotes: map[string]*RemoteConfig{
"foo": {Name: "foo"},
},
}
c.Assert(config.Validate(), Equals, ErrRemoteConfigEmptyURL)
}
func (s *ConfigSuite) TestValidateInvalidRemoteKey(c *C) {
config := &Config{
Remotes: map[string]*RemoteConfig{
"bar": {Name: "foo"},
},
}
c.Assert(config.Validate(), Equals, ErrInvalid)
}
func (s *ConfigSuite) TestRemoteConfigValidateMissingURL(c *C) {
config := &RemoteConfig{Name: "foo"}
c.Assert(config.Validate(), Equals, ErrRemoteConfigEmptyURL)
}
func (s *ConfigSuite) TestRemoteConfigValidateMissingName(c *C) {
config := &RemoteConfig{}
c.Assert(config.Validate(), Equals, ErrRemoteConfigEmptyName)
}
func (s *ConfigSuite) TestRemoteConfigValidateDefault(c *C) {
config := &RemoteConfig{Name: "foo", URLs: []string{"http://foo/bar"}}
c.Assert(config.Validate(), IsNil)
fetch := config.Fetch
c.Assert(fetch, HasLen, 1)
c.Assert(fetch[0].String(), Equals, "+refs/heads/*:refs/remotes/foo/*")
}
func (s *ConfigSuite) TestValidateInvalidBranchKey(c *C) {
config := &Config{
Branches: map[string]*Branch{
"foo": {
Name: "bar",
Remote: "origin",
Merge: plumbing.ReferenceName("refs/heads/bar"),
},
},
}
c.Assert(config.Validate(), Equals, ErrInvalid)
}
func (s *ConfigSuite) TestValidateInvalidBranch(c *C) {
config := &Config{
Branches: map[string]*Branch{
"bar": {
Name: "bar",
Remote: "origin",
Merge: plumbing.ReferenceName("refs/heads/bar"),
},
"foo": {
Name: "foo",
Remote: "origin",
Merge: plumbing.ReferenceName("baz"),
},
},
}
c.Assert(config.Validate(), Equals, errBranchInvalidMerge)
}
func (s *ConfigSuite) TestRemoteConfigDefaultValues(c *C) {
config := NewConfig()
c.Assert(config.Remotes, HasLen, 0)
c.Assert(config.Branches, HasLen, 0)
c.Assert(config.Submodules, HasLen, 0)
c.Assert(config.Raw, NotNil)
c.Assert(config.Pack.Window, Equals, DefaultPackWindow)
}
func (s *ConfigSuite) TestLoadConfigLocalScope(c *C) {
cfg, err := LoadConfig(LocalScope)
c.Assert(err, NotNil)
c.Assert(cfg, IsNil)
}
func (s *ConfigSuite) TestRemoveUrlOptions(c *C) {
buf := []byte(`
[remote "alt"]
url = git@github.com:mcuadros/go-git.git
url = git@github.com:src-d/go-git.git
fetch = +refs/heads/*:refs/remotes/origin/*
fetch = +refs/pull/*:refs/remotes/origin/pull/*`)
cfg := NewConfig()
err := cfg.Unmarshal(buf)
c.Assert(err, IsNil)
c.Assert(len(cfg.Remotes), Equals, 1)
cfg.Remotes["alt"].URLs = []string{}
buf, err = cfg.Marshal()
c.Assert(err, IsNil)
if strings.Contains(string(buf), "url") {
c.Fatal("config should not contain any url sections")
}
c.Assert(err, IsNil)
}
func (s *ConfigSuite) TestUnmarshalRemotes(c *C) {
input := []byte(`[core]
bare = true
worktree = foo
custom = ignored
[user]
name = John Doe
email = john@example.com
[remote "origin"]
url = https://git.sr.ht/~mcepl/go-git
pushurl = git@git.sr.ht:~mcepl/go-git.git
fetch = +refs/heads/*:refs/remotes/origin/*
mirror = true
`)
cfg := NewConfig()
err := cfg.Unmarshal(input)
c.Assert(err, IsNil)
c.Assert(cfg.Remotes["origin"].URLs[0], Equals, "https://git.sr.ht/~mcepl/go-git")
c.Assert(cfg.Remotes["origin"].URLs[1], Equals, "git@git.sr.ht:~mcepl/go-git.git")
}
go-git-5.13.2/config/modules.go 0000664 0000000 0000000 00000005660 14744245500 0016250 0 ustar 00root root 0000000 0000000 package config
import (
"bytes"
"errors"
"regexp"
format "github.com/go-git/go-git/v5/plumbing/format/config"
)
var (
ErrModuleEmptyURL = errors.New("module config: empty URL")
ErrModuleEmptyPath = errors.New("module config: empty path")
ErrModuleBadPath = errors.New("submodule has an invalid path")
)
var (
// Matches module paths with dotdot ".." components.
dotdotPath = regexp.MustCompile(`(^|[/\\])\.\.([/\\]|$)`)
)
// Modules defines the submodules properties, represents a .gitmodules file
// https://www.kernel.org/pub/software/scm/git/docs/gitmodules.html
type Modules struct {
// Submodules is a map of submodules being the key the name of the submodule.
Submodules map[string]*Submodule
raw *format.Config
}
// NewModules returns a new empty Modules
func NewModules() *Modules {
return &Modules{
Submodules: make(map[string]*Submodule),
raw: format.New(),
}
}
const (
pathKey = "path"
branchKey = "branch"
)
// Unmarshal parses a git-config file and stores it.
func (m *Modules) Unmarshal(b []byte) error {
r := bytes.NewBuffer(b)
d := format.NewDecoder(r)
m.raw = format.New()
if err := d.Decode(m.raw); err != nil {
return err
}
unmarshalSubmodules(m.raw, m.Submodules)
return nil
}
// Marshal returns Modules encoded as a git-config file.
func (m *Modules) Marshal() ([]byte, error) {
s := m.raw.Section(submoduleSection)
s.Subsections = make(format.Subsections, len(m.Submodules))
var i int
for _, r := range m.Submodules {
s.Subsections[i] = r.marshal()
i++
}
buf := bytes.NewBuffer(nil)
if err := format.NewEncoder(buf).Encode(m.raw); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
// Submodule defines a submodule.
type Submodule struct {
// Name module name
Name string
// Path defines the path, relative to the top-level directory of the Git
// working tree.
Path string
// URL defines a URL from which the submodule repository can be cloned.
URL string
// Branch is a remote branch name for tracking updates in the upstream
// submodule. Optional value.
Branch string
// raw representation of the subsection, filled by marshal or unmarshal are
// called.
raw *format.Subsection
}
// Validate validates the fields and sets the default values.
func (m *Submodule) Validate() error {
if m.Path == "" {
return ErrModuleEmptyPath
}
if m.URL == "" {
return ErrModuleEmptyURL
}
if dotdotPath.MatchString(m.Path) {
return ErrModuleBadPath
}
return nil
}
func (m *Submodule) unmarshal(s *format.Subsection) {
m.raw = s
m.Name = m.raw.Name
m.Path = m.raw.Option(pathKey)
m.URL = m.raw.Option(urlKey)
m.Branch = m.raw.Option(branchKey)
}
func (m *Submodule) marshal() *format.Subsection {
if m.raw == nil {
m.raw = &format.Subsection{}
}
m.raw.Name = m.Name
if m.raw.Name == "" {
m.raw.Name = m.Path
}
m.raw.SetOption(pathKey, m.Path)
m.raw.SetOption(urlKey, m.URL)
if m.Branch != "" {
m.raw.SetOption(branchKey, m.Branch)
}
return m.raw
}
go-git-5.13.2/config/modules_test.go 0000664 0000000 0000000 00000004157 14744245500 0017307 0 ustar 00root root 0000000 0000000 package config
import . "gopkg.in/check.v1"
type ModulesSuite struct{}
var _ = Suite(&ModulesSuite{})
func (s *ModulesSuite) TestValidateMissingURL(c *C) {
m := &Submodule{Path: "foo"}
c.Assert(m.Validate(), Equals, ErrModuleEmptyURL)
}
func (s *ModulesSuite) TestValidateBadPath(c *C) {
input := []string{
`..`,
`../`,
`../bar`,
`/..`,
`/../bar`,
`foo/..`,
`foo/../`,
`foo/../bar`,
}
for _, p := range input {
m := &Submodule{
Path: p,
URL: "https://example.com/",
}
c.Assert(m.Validate(), Equals, ErrModuleBadPath)
}
}
func (s *ModulesSuite) TestValidateMissingName(c *C) {
m := &Submodule{URL: "bar"}
c.Assert(m.Validate(), Equals, ErrModuleEmptyPath)
}
func (s *ModulesSuite) TestMarshal(c *C) {
input := []byte(`[submodule "qux"]
path = qux
url = baz
branch = bar
`)
cfg := NewModules()
cfg.Submodules["qux"] = &Submodule{Path: "qux", URL: "baz", Branch: "bar"}
output, err := cfg.Marshal()
c.Assert(err, IsNil)
c.Assert(output, DeepEquals, input)
}
func (s *ModulesSuite) TestUnmarshal(c *C) {
input := []byte(`[submodule "qux"]
path = qux
url = https://github.com/foo/qux.git
[submodule "foo/bar"]
path = foo/bar
url = https://github.com/foo/bar.git
branch = dev
[submodule "suspicious"]
path = ../../foo/bar
url = https://github.com/foo/bar.git
`)
cfg := NewModules()
err := cfg.Unmarshal(input)
c.Assert(err, IsNil)
c.Assert(cfg.Submodules, HasLen, 2)
c.Assert(cfg.Submodules["qux"].Name, Equals, "qux")
c.Assert(cfg.Submodules["qux"].URL, Equals, "https://github.com/foo/qux.git")
c.Assert(cfg.Submodules["foo/bar"].Name, Equals, "foo/bar")
c.Assert(cfg.Submodules["foo/bar"].URL, Equals, "https://github.com/foo/bar.git")
c.Assert(cfg.Submodules["foo/bar"].Branch, Equals, "dev")
}
func (s *ModulesSuite) TestUnmarshalMarshal(c *C) {
input := []byte(`[submodule "foo/bar"]
path = foo/bar
url = https://github.com/foo/bar.git
ignore = all
`)
cfg := NewModules()
err := cfg.Unmarshal(input)
c.Assert(err, IsNil)
output, err := cfg.Marshal()
c.Assert(err, IsNil)
c.Assert(string(output), DeepEquals, string(input))
}
go-git-5.13.2/config/refspec.go 0000664 0000000 0000000 00000007341 14744245500 0016225 0 ustar 00root root 0000000 0000000 package config
import (
"errors"
"strings"
"github.com/go-git/go-git/v5/plumbing"
)
const (
refSpecWildcard = "*"
refSpecForce = "+"
refSpecSeparator = ":"
)
var (
ErrRefSpecMalformedSeparator = errors.New("malformed refspec, separators are wrong")
ErrRefSpecMalformedWildcard = errors.New("malformed refspec, mismatched number of wildcards")
)
// RefSpec is a mapping from local branches to remote references.
// The format of the refspec is an optional +, followed by :, where
// is the pattern for references on the remote side and is where
// those references will be written locally. The + tells Git to update the
// reference even if it isn’t a fast-forward.
// eg.: "+refs/heads/*:refs/remotes/origin/*"
//
// https://git-scm.com/book/en/v2/Git-Internals-The-Refspec
type RefSpec string
// Validate validates the RefSpec
func (s RefSpec) Validate() error {
spec := string(s)
if strings.Count(spec, refSpecSeparator) != 1 {
return ErrRefSpecMalformedSeparator
}
sep := strings.Index(spec, refSpecSeparator)
if sep == len(spec)-1 {
return ErrRefSpecMalformedSeparator
}
ws := strings.Count(spec[0:sep], refSpecWildcard)
wd := strings.Count(spec[sep+1:], refSpecWildcard)
if ws == wd && ws < 2 && wd < 2 {
return nil
}
return ErrRefSpecMalformedWildcard
}
// IsForceUpdate returns if update is allowed in non fast-forward merges.
func (s RefSpec) IsForceUpdate() bool {
return s[0] == refSpecForce[0]
}
// IsDelete returns true if the refspec indicates a delete (empty src).
func (s RefSpec) IsDelete() bool {
return s[0] == refSpecSeparator[0]
}
// IsExactSHA1 returns true if the source is a SHA1 hash.
func (s RefSpec) IsExactSHA1() bool {
return plumbing.IsHash(s.Src())
}
// Src returns the src side.
func (s RefSpec) Src() string {
spec := string(s)
var start int
if s.IsForceUpdate() {
start = 1
} else {
start = 0
}
end := strings.Index(spec, refSpecSeparator)
return spec[start:end]
}
// Match match the given plumbing.ReferenceName against the source.
func (s RefSpec) Match(n plumbing.ReferenceName) bool {
if !s.IsWildcard() {
return s.matchExact(n)
}
return s.matchGlob(n)
}
// IsWildcard returns true if the RefSpec contains a wildcard.
func (s RefSpec) IsWildcard() bool {
return strings.Contains(string(s), refSpecWildcard)
}
func (s RefSpec) matchExact(n plumbing.ReferenceName) bool {
return s.Src() == n.String()
}
func (s RefSpec) matchGlob(n plumbing.ReferenceName) bool {
src := s.Src()
name := n.String()
wildcard := strings.Index(src, refSpecWildcard)
var prefix, suffix string
prefix = src[0:wildcard]
if len(src) > wildcard+1 {
suffix = src[wildcard+1:]
}
return len(name) >= len(prefix)+len(suffix) &&
strings.HasPrefix(name, prefix) &&
strings.HasSuffix(name, suffix)
}
// Dst returns the destination for the given remote reference.
func (s RefSpec) Dst(n plumbing.ReferenceName) plumbing.ReferenceName {
spec := string(s)
start := strings.Index(spec, refSpecSeparator) + 1
dst := spec[start:]
src := s.Src()
if !s.IsWildcard() {
return plumbing.ReferenceName(dst)
}
name := n.String()
ws := strings.Index(src, refSpecWildcard)
wd := strings.Index(dst, refSpecWildcard)
match := name[ws : len(name)-(len(src)-(ws+1))]
return plumbing.ReferenceName(dst[0:wd] + match + dst[wd+1:])
}
func (s RefSpec) Reverse() RefSpec {
spec := string(s)
separator := strings.Index(spec, refSpecSeparator)
return RefSpec(spec[separator+1:] + refSpecSeparator + spec[:separator])
}
func (s RefSpec) String() string {
return string(s)
}
// MatchAny returns true if any of the RefSpec match with the given ReferenceName.
func MatchAny(l []RefSpec, n plumbing.ReferenceName) bool {
for _, r := range l {
if r.Match(n) {
return true
}
}
return false
}
go-git-5.13.2/config/refspec_test.go 0000664 0000000 0000000 00000015010 14744245500 0017254 0 ustar 00root root 0000000 0000000 package config
import (
"testing"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
type RefSpecSuite struct{}
var _ = Suite(&RefSpecSuite{})
func Test(t *testing.T) { TestingT(t) }
func (s *RefSpecSuite) TestRefSpecIsValid(c *C) {
spec := RefSpec("+refs/heads/*:refs/remotes/origin/*")
c.Assert(spec.Validate(), Equals, nil)
spec = RefSpec("refs/heads/*:refs/remotes/origin/")
c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedWildcard)
spec = RefSpec("refs/heads/master:refs/remotes/origin/master")
c.Assert(spec.Validate(), Equals, nil)
spec = RefSpec(":refs/heads/master")
c.Assert(spec.Validate(), Equals, nil)
spec = RefSpec(":refs/heads/*")
c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedWildcard)
spec = RefSpec(":*")
c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedWildcard)
spec = RefSpec("refs/heads/*")
c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedSeparator)
spec = RefSpec("refs/heads:")
c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedSeparator)
spec = RefSpec("12039e008f9a4e3394f3f94f8ea897785cb09448:refs/heads/foo")
c.Assert(spec.Validate(), Equals, nil)
spec = RefSpec("12039e008f9a4e3394f3f94f8ea897785cb09448:refs/heads/*")
c.Assert(spec.Validate(), Equals, ErrRefSpecMalformedWildcard)
}
func (s *RefSpecSuite) TestRefSpecIsForceUpdate(c *C) {
spec := RefSpec("+refs/heads/*:refs/remotes/origin/*")
c.Assert(spec.IsForceUpdate(), Equals, true)
spec = RefSpec("refs/heads/*:refs/remotes/origin/*")
c.Assert(spec.IsForceUpdate(), Equals, false)
}
func (s *RefSpecSuite) TestRefSpecIsDelete(c *C) {
spec := RefSpec(":refs/heads/master")
c.Assert(spec.IsDelete(), Equals, true)
spec = RefSpec("+refs/heads/*:refs/remotes/origin/*")
c.Assert(spec.IsDelete(), Equals, false)
spec = RefSpec("refs/heads/*:refs/remotes/origin/*")
c.Assert(spec.IsDelete(), Equals, false)
}
func (s *RefSpecSuite) TestRefSpecIsExactSHA1(c *C) {
spec := RefSpec("foo:refs/heads/master")
c.Assert(spec.IsExactSHA1(), Equals, false)
spec = RefSpec("12039e008f9a4e3394f3f94f8ea897785cb09448:refs/heads/foo")
c.Assert(spec.IsExactSHA1(), Equals, true)
}
func (s *RefSpecSuite) TestRefSpecSrc(c *C) {
spec := RefSpec("refs/heads/*:refs/remotes/origin/*")
c.Assert(spec.Src(), Equals, "refs/heads/*")
spec = RefSpec("+refs/heads/*:refs/remotes/origin/*")
c.Assert(spec.Src(), Equals, "refs/heads/*")
spec = RefSpec(":refs/heads/master")
c.Assert(spec.Src(), Equals, "")
spec = RefSpec("refs/heads/love+hate:refs/heads/love+hate")
c.Assert(spec.Src(), Equals, "refs/heads/love+hate")
spec = RefSpec("+refs/heads/love+hate:refs/heads/love+hate")
c.Assert(spec.Src(), Equals, "refs/heads/love+hate")
}
func (s *RefSpecSuite) TestRefSpecMatch(c *C) {
spec := RefSpec("refs/heads/master:refs/remotes/origin/master")
c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/foo")), Equals, false)
c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/master")), Equals, true)
spec = RefSpec("+refs/heads/master:refs/remotes/origin/master")
c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/foo")), Equals, false)
c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/master")), Equals, true)
spec = RefSpec(":refs/heads/master")
c.Assert(spec.Match(plumbing.ReferenceName("")), Equals, true)
c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/master")), Equals, false)
spec = RefSpec("refs/heads/love+hate:heads/love+hate")
c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/love+hate")), Equals, true)
spec = RefSpec("+refs/heads/love+hate:heads/love+hate")
c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/love+hate")), Equals, true)
}
func (s *RefSpecSuite) TestRefSpecMatchGlob(c *C) {
tests := map[string]map[string]bool{
"refs/heads/*:refs/remotes/origin/*": {
"refs/tag/foo": false,
"refs/heads/foo": true,
},
"refs/heads/*bc:refs/remotes/origin/*bc": {
"refs/heads/abc": true,
"refs/heads/bc": true,
"refs/heads/abx": false,
},
"refs/heads/a*c:refs/remotes/origin/a*c": {
"refs/heads/abc": true,
"refs/heads/ac": true,
"refs/heads/abx": false,
},
"refs/heads/ab*:refs/remotes/origin/ab*": {
"refs/heads/abc": true,
"refs/heads/ab": true,
"refs/heads/xbc": false,
},
}
for specStr, data := range tests {
spec := RefSpec(specStr)
for ref, matches := range data {
c.Assert(spec.Match(plumbing.ReferenceName(ref)),
Equals,
matches,
Commentf("while matching spec %q against ref %q", specStr, ref),
)
}
}
}
func (s *RefSpecSuite) TestRefSpecDst(c *C) {
spec := RefSpec("refs/heads/master:refs/remotes/origin/master")
c.Assert(
spec.Dst(plumbing.ReferenceName("refs/heads/master")).String(), Equals,
"refs/remotes/origin/master",
)
}
func (s *RefSpecSuite) TestRefSpecDstBlob(c *C) {
ref := "refs/heads/abc"
tests := map[string]string{
"refs/heads/*:refs/remotes/origin/*": "refs/remotes/origin/abc",
"refs/heads/*bc:refs/remotes/origin/*": "refs/remotes/origin/a",
"refs/heads/*bc:refs/remotes/origin/*bc": "refs/remotes/origin/abc",
"refs/heads/a*c:refs/remotes/origin/*": "refs/remotes/origin/b",
"refs/heads/a*c:refs/remotes/origin/a*c": "refs/remotes/origin/abc",
"refs/heads/ab*:refs/remotes/origin/*": "refs/remotes/origin/c",
"refs/heads/ab*:refs/remotes/origin/ab*": "refs/remotes/origin/abc",
"refs/heads/*abc:refs/remotes/origin/*abc": "refs/remotes/origin/abc",
"refs/heads/abc*:refs/remotes/origin/abc*": "refs/remotes/origin/abc",
// for these two cases, git specifically logs:
// error: * Ignoring funny ref 'refs/remotes/origin/' locally
// and ignores the ref; go-git does not currently do this validation,
// but probably should.
// "refs/heads/*abc:refs/remotes/origin/*": "",
// "refs/heads/abc*:refs/remotes/origin/*": "",
}
for specStr, dst := range tests {
spec := RefSpec(specStr)
c.Assert(spec.Dst(plumbing.ReferenceName(ref)).String(),
Equals,
dst,
Commentf("while getting dst from spec %q with ref %q", specStr, ref),
)
}
}
func (s *RefSpecSuite) TestRefSpecReverse(c *C) {
spec := RefSpec("refs/heads/*:refs/remotes/origin/*")
c.Assert(
spec.Reverse(), Equals,
RefSpec("refs/remotes/origin/*:refs/heads/*"),
)
}
func (s *RefSpecSuite) TestMatchAny(c *C) {
specs := []RefSpec{
"refs/heads/bar:refs/remotes/origin/foo",
"refs/heads/foo:refs/remotes/origin/bar",
}
c.Assert(MatchAny(specs, plumbing.ReferenceName("refs/heads/foo")), Equals, true)
c.Assert(MatchAny(specs, plumbing.ReferenceName("refs/heads/bar")), Equals, true)
c.Assert(MatchAny(specs, plumbing.ReferenceName("refs/heads/master")), Equals, false)
}
go-git-5.13.2/config/url.go 0000664 0000000 0000000 00000003145 14744245500 0015376 0 ustar 00root root 0000000 0000000 package config
import (
"errors"
"strings"
format "github.com/go-git/go-git/v5/plumbing/format/config"
)
var (
errURLEmptyInsteadOf = errors.New("url config: empty insteadOf")
)
// Url defines Url rewrite rules
type URL struct {
// Name new base url
Name string
// Any URL that starts with this value will be rewritten to start, instead, with .
// When more than one insteadOf strings match a given URL, the longest match is used.
InsteadOf string
// raw representation of the subsection, filled by marshal or unmarshal are
// called.
raw *format.Subsection
}
// Validate validates fields of branch
func (b *URL) Validate() error {
if b.InsteadOf == "" {
return errURLEmptyInsteadOf
}
return nil
}
const (
insteadOfKey = "insteadOf"
)
func (u *URL) unmarshal(s *format.Subsection) error {
u.raw = s
u.Name = s.Name
u.InsteadOf = u.raw.Option(insteadOfKey)
return nil
}
func (u *URL) marshal() *format.Subsection {
if u.raw == nil {
u.raw = &format.Subsection{}
}
u.raw.Name = u.Name
u.raw.SetOption(insteadOfKey, u.InsteadOf)
return u.raw
}
func findLongestInsteadOfMatch(remoteURL string, urls map[string]*URL) *URL {
var longestMatch *URL
for _, u := range urls {
if !strings.HasPrefix(remoteURL, u.InsteadOf) {
continue
}
// according to spec if there is more than one match, take the logest
if longestMatch == nil || len(longestMatch.InsteadOf) < len(u.InsteadOf) {
longestMatch = u
}
}
return longestMatch
}
func (u *URL) ApplyInsteadOf(url string) string {
if !strings.HasPrefix(url, u.InsteadOf) {
return url
}
return u.Name + url[len(u.InsteadOf):]
}
go-git-5.13.2/config/url_test.go 0000664 0000000 0000000 00000002612 14744245500 0016433 0 ustar 00root root 0000000 0000000 package config
import (
. "gopkg.in/check.v1"
)
type URLSuite struct{}
var _ = Suite(&URLSuite{})
func (b *URLSuite) TestValidateInsteadOf(c *C) {
goodURL := URL{
Name: "ssh://github.com",
InsteadOf: "http://github.com",
}
badURL := URL{}
c.Assert(goodURL.Validate(), IsNil)
c.Assert(badURL.Validate(), NotNil)
}
func (b *URLSuite) TestMarshal(c *C) {
expected := []byte(`[core]
bare = false
[url "ssh://git@github.com/"]
insteadOf = https://github.com/
`)
cfg := NewConfig()
cfg.URLs["ssh://git@github.com/"] = &URL{
Name: "ssh://git@github.com/",
InsteadOf: "https://github.com/",
}
actual, err := cfg.Marshal()
c.Assert(err, IsNil)
c.Assert(string(actual), Equals, string(expected))
}
func (b *URLSuite) TestUnmarshal(c *C) {
input := []byte(`[core]
bare = false
[url "ssh://git@github.com/"]
insteadOf = https://github.com/
`)
cfg := NewConfig()
err := cfg.Unmarshal(input)
c.Assert(err, IsNil)
url := cfg.URLs["ssh://git@github.com/"]
c.Assert(url.Name, Equals, "ssh://git@github.com/")
c.Assert(url.InsteadOf, Equals, "https://github.com/")
}
func (b *URLSuite) TestApplyInsteadOf(c *C) {
urlRule := URL{
Name: "ssh://github.com",
InsteadOf: "http://github.com",
}
c.Assert(urlRule.ApplyInsteadOf("http://google.com"), Equals, "http://google.com")
c.Assert(urlRule.ApplyInsteadOf("http://github.com/myrepo"), Equals, "ssh://github.com/myrepo")
}
go-git-5.13.2/doc.go 0000664 0000000 0000000 00000000740 14744245500 0014072 0 ustar 00root root 0000000 0000000 // A highly extensible git implementation in pure Go.
//
// go-git aims to reach the completeness of libgit2 or jgit, nowadays covers the
// majority of the plumbing read operations and some of the main write
// operations, but lacks the main porcelain operations such as merges.
//
// It is highly extensible, we have been following the open/close principle in
// its design to facilitate extensions, mainly focusing the efforts on the
// persistence of the objects.
package git
go-git-5.13.2/example_test.go 0000664 0000000 0000000 00000010163 14744245500 0016017 0 ustar 00root root 0000000 0000000 package git_test
import (
"fmt"
"io"
"log"
"os"
"path/filepath"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/transport/http"
"github.com/go-git/go-git/v5/storage/memory"
"github.com/go-git/go-billy/v5/memfs"
)
func ExampleClone() {
// Filesystem abstraction based on memory
fs := memfs.New()
// Git objects storer based on memory
storer := memory.NewStorage()
// Clones the repository into the worktree (fs) and stores all the .git
// content into the storer
_, err := git.Clone(storer, fs, &git.CloneOptions{
URL: "https://github.com/git-fixtures/basic.git",
})
if err != nil {
log.Fatal(err)
}
// Prints the content of the CHANGELOG file from the cloned repository
changelog, err := fs.Open("CHANGELOG")
if err != nil {
log.Fatal(err)
}
io.Copy(os.Stdout, changelog)
// Output: Initial changelog
}
func ExamplePlainClone() {
// Tempdir to clone the repository
dir, err := os.MkdirTemp("", "clone-example")
if err != nil {
log.Fatal(err)
}
defer os.RemoveAll(dir) // clean up
// Clones the repository into the given dir, just as a normal git clone does
_, err = git.PlainClone(dir, false, &git.CloneOptions{
URL: "https://github.com/git-fixtures/basic.git",
})
if err != nil {
log.Fatal(err)
}
// Prints the content of the CHANGELOG file from the cloned repository
changelog, err := os.Open(filepath.Join(dir, "CHANGELOG"))
if err != nil {
log.Fatal(err)
}
io.Copy(os.Stdout, changelog)
// Output: Initial changelog
}
func ExamplePlainClone_usernamePassword() {
// Tempdir to clone the repository
dir, err := os.MkdirTemp("", "clone-example")
if err != nil {
log.Fatal(err)
}
defer os.RemoveAll(dir) // clean up
// Clones the repository into the given dir, just as a normal git clone does
_, err = git.PlainClone(dir, false, &git.CloneOptions{
URL: "https://github.com/git-fixtures/basic.git",
Auth: &http.BasicAuth{
Username: "username",
Password: "password",
},
})
if err != nil {
log.Fatal(err)
}
}
func ExamplePlainClone_accessToken() {
// Tempdir to clone the repository
dir, err := os.MkdirTemp("", "clone-example")
if err != nil {
log.Fatal(err)
}
defer os.RemoveAll(dir) // clean up
// Clones the repository into the given dir, just as a normal git clone does
_, err = git.PlainClone(dir, false, &git.CloneOptions{
URL: "https://github.com/git-fixtures/basic.git",
Auth: &http.BasicAuth{
Username: "abc123", // anything except an empty string
Password: "github_access_token",
},
})
if err != nil {
log.Fatal(err)
}
}
func ExampleRepository_References() {
r, _ := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
URL: "https://github.com/git-fixtures/basic.git",
})
// simulating a git show-ref
refs, _ := r.References()
refs.ForEach(func(ref *plumbing.Reference) error {
if ref.Type() == plumbing.HashReference {
fmt.Println(ref)
}
return nil
})
// Example Output:
// 6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/remotes/origin/master
// e8d3ffab552895c19b9fcf7aa264d277cde33881 refs/remotes/origin/branch
// 6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/heads/master
}
func ExampleRepository_Branches() {
r, _ := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
URL: "https://github.com/git-fixtures/basic.git",
})
branches, _ := r.Branches()
branches.ForEach(func(branch *plumbing.Reference) error {
fmt.Println(branch.Hash().String(), branch.Name())
return nil
})
// Example Output:
// 6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/heads/master
}
func ExampleRepository_CreateRemote() {
r, _ := git.Init(memory.NewStorage(), nil)
// Add a new remote, with the default fetch refspec
_, err := r.CreateRemote(&config.RemoteConfig{
Name: "example",
URLs: []string{"https://github.com/git-fixtures/basic.git"},
})
if err != nil {
log.Fatal(err)
}
list, err := r.Remotes()
if err != nil {
log.Fatal(err)
}
for _, r := range list {
fmt.Println(r)
}
// Example Output:
// example https://github.com/git-fixtures/basic.git (fetch)
// example https://github.com/git-fixtures/basic.git (push)
}
go-git-5.13.2/go.mod 0000664 0000000 0000000 00000003366 14744245500 0014113 0 ustar 00root root 0000000 0000000 module github.com/go-git/go-git/v5
// go-git supports the last 3 stable Go versions.
go 1.21
require (
dario.cat/mergo v1.0.0
github.com/ProtonMail/go-crypto v1.1.5
github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5
github.com/elazarl/goproxy v1.4.0
github.com/emirpasic/gods v1.18.1
github.com/gliderlabs/ssh v0.3.8
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376
github.com/go-git/go-billy/v5 v5.6.2
github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da
github.com/google/go-cmp v0.6.0
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99
github.com/kevinburke/ssh_config v1.2.0
github.com/pjbgf/sha1cd v0.3.2
github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3
github.com/skeema/knownhosts v1.3.0
github.com/stretchr/testify v1.10.0
github.com/xanzy/ssh-agent v0.3.3
golang.org/x/crypto v0.32.0
golang.org/x/net v0.34.0
golang.org/x/sys v0.29.0
golang.org/x/text v0.21.0
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c
)
require (
github.com/Microsoft/go-winio v0.6.1 // indirect
github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be // indirect
github.com/cloudflare/circl v1.3.7 // indirect
github.com/cyphar/filepath-securejoin v0.3.6 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/kr/pretty v0.3.1 // indirect
github.com/kr/text v0.2.0 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/rogpeppe/go-internal v1.12.0 // indirect
golang.org/x/mod v0.17.0 // indirect
golang.org/x/sync v0.10.0 // indirect
golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d // indirect
gopkg.in/warnings.v0 v0.1.2 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)
go-git-5.13.2/go.sum 0000664 0000000 0000000 00000023557 14744245500 0014144 0 ustar 00root root 0000000 0000000 dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
github.com/ProtonMail/go-crypto v1.1.5 h1:eoAQfK2dwL+tFSFpr7TbOaPNUbPiJj4fLYwwGE1FQO4=
github.com/ProtonMail/go-crypto v1.1.5/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
github.com/cloudflare/circl v1.3.7 h1:qlCDlTPz2n9fu58M0Nh1J/JzcFpfgkFHHX3O35r5vcU=
github.com/cloudflare/circl v1.3.7/go.mod h1:sRTcRWXGLrKw6yIGJ+l7amYJFfAXbZG0kBSc8r4zxgA=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/cyphar/filepath-securejoin v0.3.6 h1:4d9N5ykBnSp5Xn2JkhocYDkOpURL/18CYMpo6xB9uWM=
github.com/cyphar/filepath-securejoin v0.3.6/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/elazarl/goproxy v1.4.0 h1:4GyuSbFa+s26+3rmYNSuUVsx+HgPrV1bk1jXI0l9wjM=
github.com/elazarl/goproxy v1.4.0/go.mod h1:X/5W/t+gzDyLfHW4DrMdpjqYjpXsURlBt9lpBDxZZZQ=
github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
github.com/go-git/go-billy/v5 v5.6.2 h1:6Q86EsPXMa7c3YZ3aLAQsMA0VlWmy43r6FHqa/UNbRM=
github.com/go-git/go-billy/v5 v5.6.2/go.mod h1:rcFC2rAsp/erv7CMz9GczHcuD0D32fWzH+MJAU+jaUU=
github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=
github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=
github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4=
github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=
github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
github.com/skeema/knownhosts v1.3.0 h1:AM+y0rI04VksttfwjkSTNQorvGqmwATnvnAHpSgc0LY=
github.com/skeema/knownhosts v1.3.0/go.mod h1:sPINvnADmT/qYH1kfv+ePMmOBTH6Tbl7b5LvTDjFK7M=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg=
golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
go-git-5.13.2/internal/ 0000775 0000000 0000000 00000000000 14744245500 0014611 5 ustar 00root root 0000000 0000000 go-git-5.13.2/internal/path_util/ 0000775 0000000 0000000 00000000000 14744245500 0016602 5 ustar 00root root 0000000 0000000 go-git-5.13.2/internal/path_util/path_util.go 0000664 0000000 0000000 00000001135 14744245500 0021122 0 ustar 00root root 0000000 0000000 package path_util
import (
"os"
"os/user"
"strings"
)
func ReplaceTildeWithHome(path string) (string, error) {
if strings.HasPrefix(path, "~") {
firstSlash := strings.Index(path, "/")
if firstSlash == 1 {
home, err := os.UserHomeDir()
if err != nil {
return path, err
}
return strings.Replace(path, "~", home, 1), nil
} else if firstSlash > 1 {
username := path[1:firstSlash]
userAccount, err := user.Lookup(username)
if err != nil {
return path, err
}
return strings.Replace(path, path[:firstSlash], userAccount.HomeDir, 1), nil
}
}
return path, nil
}
go-git-5.13.2/internal/reference/ 0000775 0000000 0000000 00000000000 14744245500 0016547 5 ustar 00root root 0000000 0000000 go-git-5.13.2/internal/reference/sort.go 0000664 0000000 0000000 00000000422 14744245500 0020063 0 ustar 00root root 0000000 0000000 package reference
import (
"sort"
"github.com/go-git/go-git/v5/plumbing"
)
// Sort sorts the references by name to ensure a consistent order.
func Sort(refs []*plumbing.Reference) {
sort.Slice(refs, func(i, j int) bool {
return refs[i].Name() < refs[j].Name()
})
}
go-git-5.13.2/internal/revision/ 0000775 0000000 0000000 00000000000 14744245500 0016447 5 ustar 00root root 0000000 0000000 go-git-5.13.2/internal/revision/parser.go 0000664 0000000 0000000 00000031562 14744245500 0020301 0 ustar 00root root 0000000 0000000 // Package revision extracts git revision from string
// More information about revision : https://www.kernel.org/pub/software/scm/git/docs/gitrevisions.html
package revision
import (
"bytes"
"fmt"
"io"
"regexp"
"strconv"
"time"
)
// ErrInvalidRevision is emitted if string doesn't match valid revision
type ErrInvalidRevision struct {
s string
}
func (e *ErrInvalidRevision) Error() string {
return "Revision invalid : " + e.s
}
// Revisioner represents a revision component.
// A revision is made of multiple revision components
// obtained after parsing a revision string,
// for instance revision "master~" will be converted in
// two revision components Ref and TildePath
type Revisioner interface {
}
// Ref represents a reference name : HEAD, master,
type Ref string
// TildePath represents ~, ~{n}
type TildePath struct {
Depth int
}
// CaretPath represents ^, ^{n}
type CaretPath struct {
Depth int
}
// CaretReg represents ^{/foo bar}
type CaretReg struct {
Regexp *regexp.Regexp
Negate bool
}
// CaretType represents ^{commit}
type CaretType struct {
ObjectType string
}
// AtReflog represents @{n}
type AtReflog struct {
Depth int
}
// AtCheckout represents @{-n}
type AtCheckout struct {
Depth int
}
// AtUpstream represents @{upstream}, @{u}
type AtUpstream struct {
BranchName string
}
// AtPush represents @{push}
type AtPush struct {
BranchName string
}
// AtDate represents @{"2006-01-02T15:04:05Z"}
type AtDate struct {
Date time.Time
}
// ColonReg represents :/foo bar
type ColonReg struct {
Regexp *regexp.Regexp
Negate bool
}
// ColonPath represents :./ :
type ColonPath struct {
Path string
}
// ColonStagePath represents ::/
type ColonStagePath struct {
Path string
Stage int
}
// Parser represents a parser
// use to tokenize and transform to revisioner chunks
// a given string
type Parser struct {
s *scanner
currentParsedChar struct {
tok token
lit string
}
unreadLastChar bool
}
// NewParserFromString returns a new instance of parser from a string.
func NewParserFromString(s string) *Parser {
return NewParser(bytes.NewBufferString(s))
}
// NewParser returns a new instance of parser.
func NewParser(r io.Reader) *Parser {
return &Parser{s: newScanner(r)}
}
// scan returns the next token from the underlying scanner
// or the last scanned token if an unscan was requested
func (p *Parser) scan() (token, string, error) {
if p.unreadLastChar {
p.unreadLastChar = false
return p.currentParsedChar.tok, p.currentParsedChar.lit, nil
}
tok, lit, err := p.s.scan()
p.currentParsedChar.tok, p.currentParsedChar.lit = tok, lit
return tok, lit, err
}
// unscan pushes the previously read token back onto the buffer.
func (p *Parser) unscan() { p.unreadLastChar = true }
// Parse explode a revision string into revisioner chunks
func (p *Parser) Parse() ([]Revisioner, error) {
var rev Revisioner
var revs []Revisioner
var tok token
var err error
for {
tok, _, err = p.scan()
if err != nil {
return nil, err
}
switch tok {
case at:
rev, err = p.parseAt()
case tilde:
rev, err = p.parseTilde()
case caret:
rev, err = p.parseCaret()
case colon:
rev, err = p.parseColon()
case eof:
err = p.validateFullRevision(&revs)
if err != nil {
return []Revisioner{}, err
}
return revs, nil
default:
p.unscan()
rev, err = p.parseRef()
}
if err != nil {
return []Revisioner{}, err
}
revs = append(revs, rev)
}
}
// validateFullRevision ensures all revisioner chunks make a valid revision
func (p *Parser) validateFullRevision(chunks *[]Revisioner) error {
var hasReference bool
for i, chunk := range *chunks {
switch chunk.(type) {
case Ref:
if i == 0 {
hasReference = true
} else {
return &ErrInvalidRevision{`reference must be defined once at the beginning`}
}
case AtDate:
if len(*chunks) == 1 || hasReference && len(*chunks) == 2 {
return nil
}
return &ErrInvalidRevision{`"@" statement is not valid, could be : @{}, @{}`}
case AtReflog:
if len(*chunks) == 1 || hasReference && len(*chunks) == 2 {
return nil
}
return &ErrInvalidRevision{`"@" statement is not valid, could be : @{}, @{}`}
case AtCheckout:
if len(*chunks) == 1 {
return nil
}
return &ErrInvalidRevision{`"@" statement is not valid, could be : @{-}`}
case AtUpstream:
if len(*chunks) == 1 || hasReference && len(*chunks) == 2 {
return nil
}
return &ErrInvalidRevision{`"@" statement is not valid, could be : @{upstream}, @{upstream}, @{u}, @{u}`}
case AtPush:
if len(*chunks) == 1 || hasReference && len(*chunks) == 2 {
return nil
}
return &ErrInvalidRevision{`"@" statement is not valid, could be : @{push}, @{push}`}
case TildePath, CaretPath, CaretReg:
if !hasReference {
return &ErrInvalidRevision{`"~" or "^" statement must have a reference defined at the beginning`}
}
case ColonReg:
if len(*chunks) == 1 {
return nil
}
return &ErrInvalidRevision{`":" statement is not valid, could be : :/`}
case ColonPath:
if i == len(*chunks)-1 && hasReference || len(*chunks) == 1 {
return nil
}
return &ErrInvalidRevision{`":" statement is not valid, could be : :`}
case ColonStagePath:
if len(*chunks) == 1 {
return nil
}
return &ErrInvalidRevision{`":" statement is not valid, could be : ::`}
}
}
return nil
}
// parseAt extract @ statements
func (p *Parser) parseAt() (Revisioner, error) {
var tok, nextTok token
var lit, nextLit string
var err error
tok, _, err = p.scan()
if err != nil {
return nil, err
}
if tok != obrace {
p.unscan()
return Ref("HEAD"), nil
}
tok, lit, err = p.scan()
if err != nil {
return nil, err
}
nextTok, nextLit, err = p.scan()
if err != nil {
return nil, err
}
switch {
case tok == word && (lit == "u" || lit == "upstream") && nextTok == cbrace:
return AtUpstream{}, nil
case tok == word && lit == "push" && nextTok == cbrace:
return AtPush{}, nil
case tok == number && nextTok == cbrace:
n, _ := strconv.Atoi(lit)
return AtReflog{n}, nil
case tok == minus && nextTok == number:
n, _ := strconv.Atoi(nextLit)
t, _, err := p.scan()
if err != nil {
return nil, err
}
if t != cbrace {
return nil, &ErrInvalidRevision{s: `missing "}" in @{-n} structure`}
}
return AtCheckout{n}, nil
default:
p.unscan()
date := lit
for {
tok, lit, err = p.scan()
if err != nil {
return nil, err
}
switch {
case tok == cbrace:
t, err := time.Parse("2006-01-02T15:04:05Z", date)
if err != nil {
return nil, &ErrInvalidRevision{fmt.Sprintf(`wrong date "%s" must fit ISO-8601 format : 2006-01-02T15:04:05Z`, date)}
}
return AtDate{t}, nil
case tok == eof:
return nil, &ErrInvalidRevision{s: `missing "}" in @{} structure`}
default:
date += lit
}
}
}
}
// parseTilde extract ~ statements
func (p *Parser) parseTilde() (Revisioner, error) {
var tok token
var lit string
var err error
tok, lit, err = p.scan()
if err != nil {
return nil, err
}
switch {
case tok == number:
n, _ := strconv.Atoi(lit)
return TildePath{n}, nil
default:
p.unscan()
return TildePath{1}, nil
}
}
// parseCaret extract ^ statements
func (p *Parser) parseCaret() (Revisioner, error) {
var tok token
var lit string
var err error
tok, lit, err = p.scan()
if err != nil {
return nil, err
}
switch {
case tok == obrace:
r, err := p.parseCaretBraces()
if err != nil {
return nil, err
}
return r, nil
case tok == number:
n, _ := strconv.Atoi(lit)
if n > 2 {
return nil, &ErrInvalidRevision{fmt.Sprintf(`"%s" found must be 0, 1 or 2 after "^"`, lit)}
}
return CaretPath{n}, nil
default:
p.unscan()
return CaretPath{1}, nil
}
}
// parseCaretBraces extract ^{} statements
func (p *Parser) parseCaretBraces() (Revisioner, error) {
var tok, nextTok token
var lit, _ string
start := true
var re string
var negate bool
var err error
for {
tok, lit, err = p.scan()
if err != nil {
return nil, err
}
nextTok, _, err = p.scan()
if err != nil {
return nil, err
}
switch {
case tok == word && nextTok == cbrace && (lit == "commit" || lit == "tree" || lit == "blob" || lit == "tag" || lit == "object"):
return CaretType{lit}, nil
case re == "" && tok == cbrace:
return CaretType{"tag"}, nil
case re == "" && tok == emark && nextTok == emark:
re += lit
case re == "" && tok == emark && nextTok == minus:
negate = true
case re == "" && tok == emark:
return nil, &ErrInvalidRevision{s: `revision suffix brace component sequences starting with "/!" others than those defined are reserved`}
case re == "" && tok == slash:
p.unscan()
case tok != slash && start:
return nil, &ErrInvalidRevision{fmt.Sprintf(`"%s" is not a valid revision suffix brace component`, lit)}
case tok == eof:
return nil, &ErrInvalidRevision{s: `missing "}" in ^{} structure`}
case tok != cbrace:
p.unscan()
re += lit
case tok == cbrace:
p.unscan()
reg, err := regexp.Compile(re)
if err != nil {
return CaretReg{}, &ErrInvalidRevision{fmt.Sprintf(`revision suffix brace component, %s`, err.Error())}
}
return CaretReg{reg, negate}, nil
}
start = false
}
}
// parseColon extract : statements
func (p *Parser) parseColon() (Revisioner, error) {
var tok token
var err error
tok, _, err = p.scan()
if err != nil {
return nil, err
}
switch tok {
case slash:
return p.parseColonSlash()
default:
p.unscan()
return p.parseColonDefault()
}
}
// parseColonSlash extract :/ statements
func (p *Parser) parseColonSlash() (Revisioner, error) {
var tok, nextTok token
var lit string
var re string
var negate bool
var err error
for {
tok, lit, err = p.scan()
if err != nil {
return nil, err
}
nextTok, _, err = p.scan()
if err != nil {
return nil, err
}
switch {
case tok == emark && nextTok == emark:
re += lit
case re == "" && tok == emark && nextTok == minus:
negate = true
case re == "" && tok == emark:
return nil, &ErrInvalidRevision{s: `revision suffix brace component sequences starting with "/!" others than those defined are reserved`}
case tok == eof:
p.unscan()
reg, err := regexp.Compile(re)
if err != nil {
return ColonReg{}, &ErrInvalidRevision{fmt.Sprintf(`revision suffix brace component, %s`, err.Error())}
}
return ColonReg{reg, negate}, nil
default:
p.unscan()
re += lit
}
}
}
// parseColonDefault extract : statements
func (p *Parser) parseColonDefault() (Revisioner, error) {
var tok token
var lit string
var path string
var stage int
var err error
var n = -1
tok, lit, err = p.scan()
if err != nil {
return nil, err
}
nextTok, _, err := p.scan()
if err != nil {
return nil, err
}
if tok == number && nextTok == colon {
n, _ = strconv.Atoi(lit)
}
switch n {
case 0, 1, 2, 3:
stage = n
default:
path += lit
p.unscan()
}
for {
tok, lit, err = p.scan()
if err != nil {
return nil, err
}
switch {
case tok == eof && n == -1:
return ColonPath{path}, nil
case tok == eof:
return ColonStagePath{path, stage}, nil
default:
path += lit
}
}
}
// parseRef extract reference name
func (p *Parser) parseRef() (Revisioner, error) {
var tok, prevTok token
var lit, buf string
var endOfRef bool
var err error
for {
tok, lit, err = p.scan()
if err != nil {
return nil, err
}
switch tok {
case eof, at, colon, tilde, caret:
endOfRef = true
}
err := p.checkRefFormat(tok, lit, prevTok, buf, endOfRef)
if err != nil {
return "", err
}
if endOfRef {
p.unscan()
return Ref(buf), nil
}
buf += lit
prevTok = tok
}
}
// checkRefFormat ensure reference name follow rules defined here :
// https://git-scm.com/docs/git-check-ref-format
func (p *Parser) checkRefFormat(token token, literal string, previousToken token, buffer string, endOfRef bool) error {
switch token {
case aslash, space, control, qmark, asterisk, obracket:
return &ErrInvalidRevision{fmt.Sprintf(`must not contains "%s"`, literal)}
}
switch {
case (token == dot || token == slash) && buffer == "":
return &ErrInvalidRevision{fmt.Sprintf(`must not start with "%s"`, literal)}
case previousToken == slash && endOfRef:
return &ErrInvalidRevision{`must not end with "/"`}
case previousToken == dot && endOfRef:
return &ErrInvalidRevision{`must not end with "."`}
case token == dot && previousToken == slash:
return &ErrInvalidRevision{`must not contains "/."`}
case previousToken == dot && token == dot:
return &ErrInvalidRevision{`must not contains ".."`}
case previousToken == slash && token == slash:
return &ErrInvalidRevision{`must not contains consecutively "/"`}
case (token == slash || endOfRef) && len(buffer) > 4 && buffer[len(buffer)-5:] == ".lock":
return &ErrInvalidRevision{"cannot end with .lock"}
}
return nil
}
go-git-5.13.2/internal/revision/parser_test.go 0000664 0000000 0000000 00000027667 14744245500 0021353 0 ustar 00root root 0000000 0000000 package revision
import (
"bytes"
"regexp"
"testing"
"time"
. "gopkg.in/check.v1"
)
type ParserSuite struct{}
var _ = Suite(&ParserSuite{})
func (s *ParserSuite) TestErrInvalidRevision(c *C) {
e := ErrInvalidRevision{"test"}
c.Assert(e.Error(), Equals, "Revision invalid : test")
}
func (s *ParserSuite) TestNewParserFromString(c *C) {
p := NewParserFromString("test")
c.Assert(p, FitsTypeOf, &Parser{})
}
func (s *ParserSuite) TestScan(c *C) {
parser := NewParser(bytes.NewBufferString("Hello world !"))
expected := []struct {
t token
s string
}{
{
word,
"Hello",
},
{
space,
" ",
},
{
word,
"world",
},
{
space,
" ",
},
{
emark,
"!",
},
}
for i := 0; ; {
tok, str, err := parser.scan()
if tok == eof {
return
}
c.Assert(err, Equals, nil)
c.Assert(str, Equals, expected[i].s)
c.Assert(tok, Equals, expected[i].t)
i++
}
}
func (s *ParserSuite) TestUnscan(c *C) {
parser := NewParser(bytes.NewBufferString("Hello world !"))
tok, str, err := parser.scan()
c.Assert(err, Equals, nil)
c.Assert(str, Equals, "Hello")
c.Assert(tok, Equals, word)
parser.unscan()
tok, str, err = parser.scan()
c.Assert(err, Equals, nil)
c.Assert(str, Equals, "Hello")
c.Assert(tok, Equals, word)
}
func (s *ParserSuite) TestParseWithValidExpression(c *C) {
tim, _ := time.Parse("2006-01-02T15:04:05Z", "2016-12-16T21:42:47Z")
datas := map[string]Revisioner{
"@": []Revisioner{Ref("HEAD")},
"@~3": []Revisioner{
Ref("HEAD"),
TildePath{3},
},
"@{2016-12-16T21:42:47Z}": []Revisioner{AtDate{tim}},
"@{1}": []Revisioner{AtReflog{1}},
"@{-1}": []Revisioner{AtCheckout{1}},
"master@{upstream}": []Revisioner{
Ref("master"),
AtUpstream{},
},
"@{upstream}": []Revisioner{
AtUpstream{},
},
"@{u}": []Revisioner{
AtUpstream{},
},
"master@{push}": []Revisioner{
Ref("master"),
AtPush{},
},
"master@{2016-12-16T21:42:47Z}": []Revisioner{
Ref("master"),
AtDate{tim},
},
"HEAD^": []Revisioner{
Ref("HEAD"),
CaretPath{1},
},
"master~3": []Revisioner{
Ref("master"),
TildePath{3},
},
"v0.99.8^{commit}": []Revisioner{
Ref("v0.99.8"),
CaretType{"commit"},
},
"v0.99.8^{}": []Revisioner{
Ref("v0.99.8"),
CaretType{"tag"},
},
"HEAD^{/fix nasty bug}": []Revisioner{
Ref("HEAD"),
CaretReg{regexp.MustCompile("fix nasty bug"), false},
},
":/fix nasty bug": []Revisioner{
ColonReg{regexp.MustCompile("fix nasty bug"), false},
},
"HEAD:README": []Revisioner{
Ref("HEAD"),
ColonPath{"README"},
},
":README": []Revisioner{
ColonPath{"README"},
},
"master:./README": []Revisioner{
Ref("master"),
ColonPath{"./README"},
},
"master^1~:./README": []Revisioner{
Ref("master"),
CaretPath{1},
TildePath{1},
ColonPath{"./README"},
},
":0:README": []Revisioner{
ColonStagePath{"README", 0},
},
":3:README": []Revisioner{
ColonStagePath{"README", 3},
},
"master~1^{/update}~5~^^1": []Revisioner{
Ref("master"),
TildePath{1},
CaretReg{regexp.MustCompile("update"), false},
TildePath{5},
TildePath{1},
CaretPath{1},
CaretPath{1},
},
}
for d, expected := range datas {
parser := NewParser(bytes.NewBufferString(d))
result, err := parser.Parse()
c.Assert(err, Equals, nil)
c.Assert(result, DeepEquals, expected)
}
}
func (s *ParserSuite) TestParseWithInvalidExpression(c *C) {
datas := map[string]error{
"..": &ErrInvalidRevision{`must not start with "."`},
"master^1master": &ErrInvalidRevision{`reference must be defined once at the beginning`},
"master^1@{2016-12-16T21:42:47Z}": &ErrInvalidRevision{`"@" statement is not valid, could be : @{}, @{}`},
"master^1@{1}": &ErrInvalidRevision{`"@" statement is not valid, could be : @{}, @{}`},
"master@{-1}": &ErrInvalidRevision{`"@" statement is not valid, could be : @{-}`},
"master^1@{upstream}": &ErrInvalidRevision{`"@" statement is not valid, could be : @{upstream}, @{upstream}, @{u}, @{u}`},
"master^1@{u}": &ErrInvalidRevision{`"@" statement is not valid, could be : @{upstream}, @{upstream}, @{u}, @{u}`},
"master^1@{push}": &ErrInvalidRevision{`"@" statement is not valid, could be : @{push}, @{push}`},
"^1": &ErrInvalidRevision{`"~" or "^" statement must have a reference defined at the beginning`},
"^{/test}": &ErrInvalidRevision{`"~" or "^" statement must have a reference defined at the beginning`},
"~1": &ErrInvalidRevision{`"~" or "^" statement must have a reference defined at the beginning`},
"master:/test": &ErrInvalidRevision{`":" statement is not valid, could be : :/`},
"master:0:README": &ErrInvalidRevision{`":" statement is not valid, could be : ::`},
"^{/": &ErrInvalidRevision{`missing "}" in ^{} structure`},
"~@{": &ErrInvalidRevision{`missing "}" in @{} structure`},
"@@{{0": &ErrInvalidRevision{`missing "}" in @{} structure`},
}
for s, e := range datas {
parser := NewParser(bytes.NewBufferString(s))
_, err := parser.Parse()
c.Assert(err, DeepEquals, e)
}
}
func (s *ParserSuite) TestParseAtWithValidExpression(c *C) {
tim, _ := time.Parse("2006-01-02T15:04:05Z", "2016-12-16T21:42:47Z")
datas := map[string]Revisioner{
"": Ref("HEAD"),
"{1}": AtReflog{1},
"{-1}": AtCheckout{1},
"{push}": AtPush{},
"{upstream}": AtUpstream{},
"{u}": AtUpstream{},
"{2016-12-16T21:42:47Z}": AtDate{tim},
}
for d, expected := range datas {
parser := NewParser(bytes.NewBufferString(d))
result, err := parser.parseAt()
c.Assert(err, Equals, nil)
c.Assert(result, DeepEquals, expected)
}
}
func (s *ParserSuite) TestParseAtWithInvalidExpression(c *C) {
datas := map[string]error{
"{test}": &ErrInvalidRevision{`wrong date "test" must fit ISO-8601 format : 2006-01-02T15:04:05Z`},
"{-1": &ErrInvalidRevision{`missing "}" in @{-n} structure`},
}
for s, e := range datas {
parser := NewParser(bytes.NewBufferString(s))
_, err := parser.parseAt()
c.Assert(err, DeepEquals, e)
}
}
func (s *ParserSuite) TestParseCaretWithValidExpression(c *C) {
datas := map[string]Revisioner{
"": CaretPath{1},
"2": CaretPath{2},
"{}": CaretType{"tag"},
"{commit}": CaretType{"commit"},
"{tree}": CaretType{"tree"},
"{blob}": CaretType{"blob"},
"{tag}": CaretType{"tag"},
"{object}": CaretType{"object"},
"{/hello world !}": CaretReg{regexp.MustCompile("hello world !"), false},
"{/!-hello world !}": CaretReg{regexp.MustCompile("hello world !"), true},
"{/!! hello world !}": CaretReg{regexp.MustCompile("! hello world !"), false},
}
for d, expected := range datas {
parser := NewParser(bytes.NewBufferString(d))
result, err := parser.parseCaret()
c.Assert(err, Equals, nil)
c.Assert(result, DeepEquals, expected)
}
}
func (s *ParserSuite) TestParseCaretWithUnValidExpression(c *C) {
datas := map[string]error{
"3": &ErrInvalidRevision{`"3" found must be 0, 1 or 2 after "^"`},
"{test}": &ErrInvalidRevision{`"test" is not a valid revision suffix brace component`},
"{/!test}": &ErrInvalidRevision{`revision suffix brace component sequences starting with "/!" others than those defined are reserved`},
"{/test**}": &ErrInvalidRevision{"revision suffix brace component, error parsing regexp: invalid nested repetition operator: `**`"},
}
for s, e := range datas {
parser := NewParser(bytes.NewBufferString(s))
_, err := parser.parseCaret()
c.Assert(err, DeepEquals, e)
}
}
func (s *ParserSuite) TestParseTildeWithValidExpression(c *C) {
datas := map[string]Revisioner{
"3": TildePath{3},
"1": TildePath{1},
"": TildePath{1},
}
for d, expected := range datas {
parser := NewParser(bytes.NewBufferString(d))
result, err := parser.parseTilde()
c.Assert(err, Equals, nil)
c.Assert(result, DeepEquals, expected)
}
}
func (s *ParserSuite) TestParseColonWithValidExpression(c *C) {
datas := map[string]Revisioner{
"/hello world !": ColonReg{regexp.MustCompile("hello world !"), false},
"/!-hello world !": ColonReg{regexp.MustCompile("hello world !"), true},
"/!! hello world !": ColonReg{regexp.MustCompile("! hello world !"), false},
"../parser.go": ColonPath{"../parser.go"},
"./parser.go": ColonPath{"./parser.go"},
"parser.go": ColonPath{"parser.go"},
"0:parser.go": ColonStagePath{"parser.go", 0},
"1:parser.go": ColonStagePath{"parser.go", 1},
"2:parser.go": ColonStagePath{"parser.go", 2},
"3:parser.go": ColonStagePath{"parser.go", 3},
}
for d, expected := range datas {
parser := NewParser(bytes.NewBufferString(d))
result, err := parser.parseColon()
c.Assert(err, Equals, nil)
c.Assert(result, DeepEquals, expected)
}
}
func (s *ParserSuite) TestParseColonWithUnValidExpression(c *C) {
datas := map[string]error{
"/!test": &ErrInvalidRevision{`revision suffix brace component sequences starting with "/!" others than those defined are reserved`},
"/*": &ErrInvalidRevision{"revision suffix brace component, error parsing regexp: missing argument to repetition operator: `*`"},
}
for s, e := range datas {
parser := NewParser(bytes.NewBufferString(s))
_, err := parser.parseColon()
c.Assert(err, DeepEquals, e)
}
}
func (s *ParserSuite) TestParseRefWithValidName(c *C) {
datas := []string{
"lock",
"master",
"v1.0.0",
"refs/stash",
"refs/tags/v1.0.0",
"refs/heads/master",
"refs/remotes/test",
"refs/remotes/origin/HEAD",
"refs/remotes/origin/master",
"0123abcd", // short hash
}
for _, d := range datas {
parser := NewParser(bytes.NewBufferString(d))
result, err := parser.parseRef()
c.Assert(err, Equals, nil)
c.Assert(result, Equals, Ref(d))
}
}
func (s *ParserSuite) TestParseRefWithInvalidName(c *C) {
datas := map[string]error{
".master": &ErrInvalidRevision{`must not start with "."`},
"/master": &ErrInvalidRevision{`must not start with "/"`},
"master/": &ErrInvalidRevision{`must not end with "/"`},
"master.": &ErrInvalidRevision{`must not end with "."`},
"refs/remotes/.origin/HEAD": &ErrInvalidRevision{`must not contains "/."`},
"test..test": &ErrInvalidRevision{`must not contains ".."`},
"test..": &ErrInvalidRevision{`must not contains ".."`},
"test test": &ErrInvalidRevision{`must not contains " "`},
"test*test": &ErrInvalidRevision{`must not contains "*"`},
"test?test": &ErrInvalidRevision{`must not contains "?"`},
"test\\test": &ErrInvalidRevision{`must not contains "\"`},
"test[test": &ErrInvalidRevision{`must not contains "["`},
"te//st": &ErrInvalidRevision{`must not contains consecutively "/"`},
"refs/remotes/test.lock/HEAD": &ErrInvalidRevision{`cannot end with .lock`},
"test.lock": &ErrInvalidRevision{`cannot end with .lock`},
}
for s, e := range datas {
parser := NewParser(bytes.NewBufferString(s))
_, err := parser.parseRef()
c.Assert(err, DeepEquals, e)
}
}
func FuzzParser(f *testing.F) {
f.Add("@{2016-12-16T21:42:47Z}")
f.Add("@~3")
f.Add("v0.99.8^{}")
f.Add("master:./README")
f.Add("HEAD^{/fix nasty bug}")
f.Add("HEAD^{/[A-")
f.Add(":/fix nasty bug")
f.Add(":/[A-")
f.Fuzz(func(t *testing.T, input string) {
parser := NewParser(bytes.NewBufferString(input))
parser.Parse()
})
}
go-git-5.13.2/internal/revision/scanner.go 0000664 0000000 0000000 00000005040 14744245500 0020426 0 ustar 00root root 0000000 0000000 package revision
import (
"bufio"
"io"
"unicode"
)
// runeCategoryValidator takes a rune as input and
// validates it belongs to a rune category
type runeCategoryValidator func(r rune) bool
// tokenizeExpression aggregates a series of runes matching check predicate into a single
// string and provides given tokenType as token type
func tokenizeExpression(ch rune, tokenType token, check runeCategoryValidator, r *bufio.Reader) (token, string, error) {
var data []rune
data = append(data, ch)
for {
c, _, err := r.ReadRune()
if c == zeroRune {
break
}
if err != nil {
return tokenError, "", err
}
if check(c) {
data = append(data, c)
} else {
err := r.UnreadRune()
if err != nil {
return tokenError, "", err
}
return tokenType, string(data), nil
}
}
return tokenType, string(data), nil
}
// maxRevisionLength holds the maximum length that will be parsed for a
// revision. Git itself doesn't enforce a max length, but rather leans on
// the OS to enforce it via its ARG_MAX.
const maxRevisionLength = 128 * 1024 // 128kb
var zeroRune = rune(0)
// scanner represents a lexical scanner.
type scanner struct {
r *bufio.Reader
}
// newScanner returns a new instance of scanner.
func newScanner(r io.Reader) *scanner {
return &scanner{r: bufio.NewReader(io.LimitReader(r, maxRevisionLength))}
}
// Scan extracts tokens and their strings counterpart
// from the reader
func (s *scanner) scan() (token, string, error) {
ch, _, err := s.r.ReadRune()
if err != nil && err != io.EOF {
return tokenError, "", err
}
switch ch {
case zeroRune:
return eof, "", nil
case ':':
return colon, string(ch), nil
case '~':
return tilde, string(ch), nil
case '^':
return caret, string(ch), nil
case '.':
return dot, string(ch), nil
case '/':
return slash, string(ch), nil
case '{':
return obrace, string(ch), nil
case '}':
return cbrace, string(ch), nil
case '-':
return minus, string(ch), nil
case '@':
return at, string(ch), nil
case '\\':
return aslash, string(ch), nil
case '?':
return qmark, string(ch), nil
case '*':
return asterisk, string(ch), nil
case '[':
return obracket, string(ch), nil
case '!':
return emark, string(ch), nil
}
if unicode.IsSpace(ch) {
return space, string(ch), nil
}
if unicode.IsControl(ch) {
return control, string(ch), nil
}
if unicode.IsLetter(ch) {
return tokenizeExpression(ch, word, unicode.IsLetter, s.r)
}
if unicode.IsNumber(ch) {
return tokenizeExpression(ch, number, unicode.IsNumber, s.r)
}
return tokenError, string(ch), nil
}
go-git-5.13.2/internal/revision/scanner_test.go 0000664 0000000 0000000 00000011100 14744245500 0021457 0 ustar 00root root 0000000 0000000 package revision
import (
"bytes"
"testing"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type ScannerSuite struct{}
var _ = Suite(&ScannerSuite{})
func (s *ScannerSuite) TestReadColon(c *C) {
scanner := newScanner(bytes.NewBufferString(":"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, ":")
c.Assert(tok, Equals, colon)
}
func (s *ScannerSuite) TestReadTilde(c *C) {
scanner := newScanner(bytes.NewBufferString("~"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "~")
c.Assert(tok, Equals, tilde)
}
func (s *ScannerSuite) TestReadCaret(c *C) {
scanner := newScanner(bytes.NewBufferString("^"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "^")
c.Assert(tok, Equals, caret)
}
func (s *ScannerSuite) TestReadDot(c *C) {
scanner := newScanner(bytes.NewBufferString("."))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, ".")
c.Assert(tok, Equals, dot)
}
func (s *ScannerSuite) TestReadSlash(c *C) {
scanner := newScanner(bytes.NewBufferString("/"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "/")
c.Assert(tok, Equals, slash)
}
func (s *ScannerSuite) TestReadEOF(c *C) {
scanner := newScanner(bytes.NewBufferString(string(rune(0))))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "")
c.Assert(tok, Equals, eof)
}
func (s *ScannerSuite) TestReadNumber(c *C) {
scanner := newScanner(bytes.NewBufferString("1234"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "1234")
c.Assert(tok, Equals, number)
}
func (s *ScannerSuite) TestReadSpace(c *C) {
scanner := newScanner(bytes.NewBufferString(" "))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, " ")
c.Assert(tok, Equals, space)
}
func (s *ScannerSuite) TestReadControl(c *C) {
scanner := newScanner(bytes.NewBufferString(""))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "\x01")
c.Assert(tok, Equals, control)
}
func (s *ScannerSuite) TestReadOpenBrace(c *C) {
scanner := newScanner(bytes.NewBufferString("{"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "{")
c.Assert(tok, Equals, obrace)
}
func (s *ScannerSuite) TestReadCloseBrace(c *C) {
scanner := newScanner(bytes.NewBufferString("}"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "}")
c.Assert(tok, Equals, cbrace)
}
func (s *ScannerSuite) TestReadMinus(c *C) {
scanner := newScanner(bytes.NewBufferString("-"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "-")
c.Assert(tok, Equals, minus)
}
func (s *ScannerSuite) TestReadAt(c *C) {
scanner := newScanner(bytes.NewBufferString("@"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "@")
c.Assert(tok, Equals, at)
}
func (s *ScannerSuite) TestReadAntislash(c *C) {
scanner := newScanner(bytes.NewBufferString("\\"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "\\")
c.Assert(tok, Equals, aslash)
}
func (s *ScannerSuite) TestReadQuestionMark(c *C) {
scanner := newScanner(bytes.NewBufferString("?"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "?")
c.Assert(tok, Equals, qmark)
}
func (s *ScannerSuite) TestReadAsterisk(c *C) {
scanner := newScanner(bytes.NewBufferString("*"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "*")
c.Assert(tok, Equals, asterisk)
}
func (s *ScannerSuite) TestReadOpenBracket(c *C) {
scanner := newScanner(bytes.NewBufferString("["))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "[")
c.Assert(tok, Equals, obracket)
}
func (s *ScannerSuite) TestReadExclamationMark(c *C) {
scanner := newScanner(bytes.NewBufferString("!"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "!")
c.Assert(tok, Equals, emark)
}
func (s *ScannerSuite) TestReadWord(c *C) {
scanner := newScanner(bytes.NewBufferString("abcde"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "abcde")
c.Assert(tok, Equals, word)
}
func (s *ScannerSuite) TestReadTokenError(c *C) {
scanner := newScanner(bytes.NewBufferString("`"))
tok, data, err := scanner.scan()
c.Assert(err, Equals, nil)
c.Assert(data, Equals, "`")
c.Assert(tok, Equals, tokenError)
}
go-git-5.13.2/internal/revision/token.go 0000664 0000000 0000000 00000000412 14744245500 0020113 0 ustar 00root root 0000000 0000000 package revision
// token represents a entity extracted from string parsing
type token int
const (
eof token = iota
aslash
asterisk
at
caret
cbrace
colon
control
dot
emark
minus
number
obrace
obracket
qmark
slash
space
tilde
tokenError
word
)
go-git-5.13.2/internal/test/ 0000775 0000000 0000000 00000000000 14744245500 0015570 5 ustar 00root root 0000000 0000000 go-git-5.13.2/internal/test/checkers.go 0000664 0000000 0000000 00000002151 14744245500 0017705 0 ustar 00root root 0000000 0000000 package test
import (
"errors"
"fmt"
check "gopkg.in/check.v1"
)
// This check.Checker implementation exists because there's no implementation
// in the library that compares errors using `errors.Is`. If / when the check
// library fixes https://github.com/go-check/check/issues/139, this code can
// likely be removed and replaced with the library implementation.
//
// Added in Go 1.13 [https://go.dev/blog/go1.13-errors] `errors.Is` is the
// best mechanism to use to compare errors that might be wrapped in other
// errors.
type errorIsChecker struct {
*check.CheckerInfo
}
var ErrorIs check.Checker = errorIsChecker{
&check.CheckerInfo{
Name: "ErrorIs",
Params: []string{"obtained", "expected"},
},
}
func (e errorIsChecker) Check(params []interface{}, names []string) (bool, string) {
obtained, ok := params[0].(error)
if !ok {
return false, "obtained is not an error"
}
expected, ok := params[1].(error)
if !ok {
return false, "expected is not an error"
}
if !errors.Is(obtained, expected) {
return false, fmt.Sprintf("obtained: %+v expected: %+v", obtained, expected)
}
return true, ""
}
go-git-5.13.2/internal/url/ 0000775 0000000 0000000 00000000000 14744245500 0015413 5 ustar 00root root 0000000 0000000 go-git-5.13.2/internal/url/url.go 0000664 0000000 0000000 00000002301 14744245500 0016540 0 ustar 00root root 0000000 0000000 package url
import (
"regexp"
)
var (
isSchemeRegExp = regexp.MustCompile(`^[^:]+://`)
// Ref: https://github.com/git/git/blob/master/Documentation/urls.txt#L37
scpLikeUrlRegExp = regexp.MustCompile(`^(?:(?P[^@]+)@)?(?P[^:\s]+):(?:(?P[0-9]{1,5}):)?(?P[^\\].*)$`)
)
// MatchesScheme returns true if the given string matches a URL-like
// format scheme.
func MatchesScheme(url string) bool {
return isSchemeRegExp.MatchString(url)
}
// MatchesScpLike returns true if the given string matches an SCP-like
// format scheme.
func MatchesScpLike(url string) bool {
return scpLikeUrlRegExp.MatchString(url)
}
// FindScpLikeComponents returns the user, host, port and path of the
// given SCP-like URL.
func FindScpLikeComponents(url string) (user, host, port, path string) {
m := scpLikeUrlRegExp.FindStringSubmatch(url)
return m[1], m[2], m[3], m[4]
}
// IsLocalEndpoint returns true if the given URL string specifies a
// local file endpoint. For example, on a Linux machine,
// `/home/user/src/go-git` would match as a local endpoint, but
// `https://github.com/src-d/go-git` would not.
func IsLocalEndpoint(url string) bool {
return !MatchesScheme(url) && !MatchesScpLike(url)
}
go-git-5.13.2/internal/url/url_test.go 0000775 0000000 0000000 00000006120 14744245500 0017605 0 ustar 00root root 0000000 0000000 package url
import (
"testing"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type URLSuite struct{}
var _ = Suite(&URLSuite{})
func (s *URLSuite) TestMatchesScpLike(c *C) {
// See https://github.com/git/git/blob/master/Documentation/urls.txt#L37
examples := []string{
// Most-extended case
"git@github.com:james/bond",
// Most-extended case with port
"git@github.com:22:james/bond",
// Most-extended case with numeric path
"git@github.com:007/bond",
// Most-extended case with port and numeric "username"
"git@github.com:22:007/bond",
// Single repo path
"git@github.com:bond",
// Single repo path with port
"git@github.com:22:bond",
// Single repo path with port and numeric repo
"git@github.com:22:007",
// Repo path ending with .git and starting with _
"git@github.com:22:_007.git",
"git@github.com:_007.git",
"git@github.com:_james.git",
"git@github.com:_james/bond.git",
}
for _, url := range examples {
c.Check(MatchesScpLike(url), Equals, true)
}
}
func (s *URLSuite) TestFindScpLikeComponents(c *C) {
testCases := []struct {
url, user, host, port, path string
}{
{
// Most-extended case
url: "git@github.com:james/bond", user: "git", host: "github.com", port: "", path: "james/bond",
},
{
// Most-extended case with port
url: "git@github.com:22:james/bond", user: "git", host: "github.com", port: "22", path: "james/bond",
},
{
// Most-extended case with numeric path
url: "git@github.com:007/bond", user: "git", host: "github.com", port: "", path: "007/bond",
},
{
// Most-extended case with port and numeric path
url: "git@github.com:22:007/bond", user: "git", host: "github.com", port: "22", path: "007/bond",
},
{
// Single repo path
url: "git@github.com:bond", user: "git", host: "github.com", port: "", path: "bond",
},
{
// Single repo path with port
url: "git@github.com:22:bond", user: "git", host: "github.com", port: "22", path: "bond",
},
{
// Single repo path with port and numeric path
url: "git@github.com:22:007", user: "git", host: "github.com", port: "22", path: "007",
},
{
// Repo path ending with .git and starting with _
url: "git@github.com:22:_007.git", user: "git", host: "github.com", port: "22", path: "_007.git",
},
{
// Repo path ending with .git and starting with _
url: "git@github.com:_007.git", user: "git", host: "github.com", port: "", path: "_007.git",
},
{
// Repo path ending with .git and starting with _
url: "git@github.com:_james.git", user: "git", host: "github.com", port: "", path: "_james.git",
},
{
// Repo path ending with .git and starting with _
url: "git@github.com:_james/bond.git", user: "git", host: "github.com", port: "", path: "_james/bond.git",
},
}
for _, tc := range testCases {
user, host, port, path := FindScpLikeComponents(tc.url)
logf := func(ok bool) {
if ok {
return
}
c.Logf("%q check failed", tc.url)
}
logf(c.Check(user, Equals, tc.user))
logf(c.Check(host, Equals, tc.host))
logf(c.Check(port, Equals, tc.port))
logf(c.Check(path, Equals, tc.path))
}
}
go-git-5.13.2/object_walker.go 0000664 0000000 0000000 00000005427 14744245500 0016147 0 ustar 00root root 0000000 0000000 package git
import (
"fmt"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/storage"
)
type objectWalker struct {
Storer storage.Storer
// seen is the set of objects seen in the repo.
// seen map can become huge if walking over large
// repos. Thus using struct{} as the value type.
seen map[plumbing.Hash]struct{}
}
func newObjectWalker(s storage.Storer) *objectWalker {
return &objectWalker{s, map[plumbing.Hash]struct{}{}}
}
// walkAllRefs walks all (hash) references from the repo.
func (p *objectWalker) walkAllRefs() error {
// Walk over all the references in the repo.
it, err := p.Storer.IterReferences()
if err != nil {
return err
}
defer it.Close()
err = it.ForEach(func(ref *plumbing.Reference) error {
// Exit this iteration early for non-hash references.
if ref.Type() != plumbing.HashReference {
return nil
}
return p.walkObjectTree(ref.Hash())
})
return err
}
func (p *objectWalker) isSeen(hash plumbing.Hash) bool {
_, seen := p.seen[hash]
return seen
}
func (p *objectWalker) add(hash plumbing.Hash) {
p.seen[hash] = struct{}{}
}
// walkObjectTree walks over all objects and remembers references
// to them in the objectWalker. This is used instead of the revlist
// walks because memory usage is tight with huge repos.
func (p *objectWalker) walkObjectTree(hash plumbing.Hash) error {
// Check if we have already seen, and mark this object
if p.isSeen(hash) {
return nil
}
p.add(hash)
// Fetch the object.
obj, err := object.GetObject(p.Storer, hash)
if err != nil {
return fmt.Errorf("getting object %s failed: %v", hash, err)
}
// Walk all children depending on object type.
switch obj := obj.(type) {
case *object.Commit:
err = p.walkObjectTree(obj.TreeHash)
if err != nil {
return err
}
for _, h := range obj.ParentHashes {
err = p.walkObjectTree(h)
if err != nil {
return err
}
}
case *object.Tree:
for i := range obj.Entries {
// Shortcut for blob objects:
// 'or' the lower bits of a mode and check that it
// it matches a filemode.Executable. The type information
// is in the higher bits, but this is the cleanest way
// to handle plain files with different modes.
// Other non-tree objects are somewhat rare, so they
// are not special-cased.
if obj.Entries[i].Mode|0755 == filemode.Executable {
p.add(obj.Entries[i].Hash)
continue
}
// Normal walk for sub-trees (and symlinks etc).
err = p.walkObjectTree(obj.Entries[i].Hash)
if err != nil {
return err
}
}
case *object.Tag:
return p.walkObjectTree(obj.Target)
default:
// Error out on unhandled object types.
return fmt.Errorf("unknown object %X %s %T", obj.ID(), obj.Type(), obj)
}
return nil
}
go-git-5.13.2/options.go 0000664 0000000 0000000 00000065407 14744245500 0015033 0 ustar 00root root 0000000 0000000 package git
import (
"errors"
"fmt"
"regexp"
"strings"
"time"
"github.com/ProtonMail/go-crypto/openpgp"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
formatcfg "github.com/go-git/go-git/v5/plumbing/format/config"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband"
"github.com/go-git/go-git/v5/plumbing/transport"
)
// SubmoduleRescursivity defines how depth will affect any submodule recursive
// operation.
type SubmoduleRescursivity uint
const (
// DefaultRemoteName name of the default Remote, just like git command.
DefaultRemoteName = "origin"
// NoRecurseSubmodules disables the recursion for a submodule operation.
NoRecurseSubmodules SubmoduleRescursivity = 0
// DefaultSubmoduleRecursionDepth allow recursion in a submodule operation.
DefaultSubmoduleRecursionDepth SubmoduleRescursivity = 10
)
var (
ErrMissingURL = errors.New("URL field is required")
)
// CloneOptions describes how a clone should be performed.
type CloneOptions struct {
// The (possibly remote) repository URL to clone from.
URL string
// Auth credentials, if required, to use with the remote repository.
Auth transport.AuthMethod
// Name of the remote to be added, by default `origin`.
RemoteName string
// Remote branch to clone.
ReferenceName plumbing.ReferenceName
// Fetch only ReferenceName if true.
SingleBranch bool
// Mirror clones the repository as a mirror.
//
// Compared to a bare clone, mirror not only maps local branches of the
// source to local branches of the target, it maps all refs (including
// remote-tracking branches, notes etc.) and sets up a refspec configuration
// such that all these refs are overwritten by a git remote update in the
// target repository.
Mirror bool
// No checkout of HEAD after clone if true.
NoCheckout bool
// Limit fetching to the specified number of commits.
Depth int
// RecurseSubmodules after the clone is created, initialize all submodules
// within, using their default settings. This option is ignored if the
// cloned repository does not have a worktree.
RecurseSubmodules SubmoduleRescursivity
// ShallowSubmodules limit cloning submodules to the 1 level of depth.
// It matches the git command --shallow-submodules.
ShallowSubmodules bool
// Progress is where the human readable information sent by the server is
// stored, if nil nothing is stored and the capability (if supported)
// no-progress, is sent to the server to avoid send this information.
Progress sideband.Progress
// Tags describe how the tags will be fetched from the remote repository,
// by default is AllTags.
Tags TagMode
// InsecureSkipTLS skips ssl verify if protocol is https
InsecureSkipTLS bool
// CABundle specify additional ca bundle with system cert pool
CABundle []byte
// ProxyOptions provides info required for connecting to a proxy.
ProxyOptions transport.ProxyOptions
// When the repository to clone is on the local machine, instead of
// using hard links, automatically setup .git/objects/info/alternates
// to share the objects with the source repository.
// The resulting repository starts out without any object of its own.
// NOTE: this is a possibly dangerous operation; do not use it unless
// you understand what it does.
//
// [Reference]: https://git-scm.com/docs/git-clone#Documentation/git-clone.txt---shared
Shared bool
}
// MergeOptions describes how a merge should be performed.
type MergeOptions struct {
// Strategy defines the merge strategy to be used.
Strategy MergeStrategy
}
// MergeStrategy represents the different types of merge strategies.
type MergeStrategy int8
const (
// FastForwardMerge represents a Git merge strategy where the current
// branch can be simply updated to point to the HEAD of the branch being
// merged. This is only possible if the history of the branch being merged
// is a linear descendant of the current branch, with no conflicting commits.
//
// This is the default option.
FastForwardMerge MergeStrategy = iota
)
// Validate validates the fields and sets the default values.
func (o *CloneOptions) Validate() error {
if o.URL == "" {
return ErrMissingURL
}
if o.RemoteName == "" {
o.RemoteName = DefaultRemoteName
}
if o.ReferenceName == "" {
o.ReferenceName = plumbing.HEAD
}
if o.Tags == InvalidTagMode {
o.Tags = AllTags
}
return nil
}
// PullOptions describes how a pull should be performed.
type PullOptions struct {
// Name of the remote to be pulled. If empty, uses the default.
RemoteName string
// RemoteURL overrides the remote repo address with a custom URL
RemoteURL string
// Remote branch to clone. If empty, uses HEAD.
ReferenceName plumbing.ReferenceName
// Fetch only ReferenceName if true.
SingleBranch bool
// Limit fetching to the specified number of commits.
Depth int
// Auth credentials, if required, to use with the remote repository.
Auth transport.AuthMethod
// RecurseSubmodules controls if new commits of all populated submodules
// should be fetched too.
RecurseSubmodules SubmoduleRescursivity
// Progress is where the human readable information sent by the server is
// stored, if nil nothing is stored and the capability (if supported)
// no-progress, is sent to the server to avoid send this information.
Progress sideband.Progress
// Force allows the pull to update a local branch even when the remote
// branch does not descend from it.
Force bool
// InsecureSkipTLS skips ssl verify if protocol is https
InsecureSkipTLS bool
// CABundle specify additional ca bundle with system cert pool
CABundle []byte
// ProxyOptions provides info required for connecting to a proxy.
ProxyOptions transport.ProxyOptions
}
// Validate validates the fields and sets the default values.
func (o *PullOptions) Validate() error {
if o.RemoteName == "" {
o.RemoteName = DefaultRemoteName
}
if o.ReferenceName == "" {
o.ReferenceName = plumbing.HEAD
}
return nil
}
type TagMode int
const (
InvalidTagMode TagMode = iota
// TagFollowing any tag that points into the histories being fetched is also
// fetched. TagFollowing requires a server with `include-tag` capability
// in order to fetch the annotated tags objects.
TagFollowing
// AllTags fetch all tags from the remote (i.e., fetch remote tags
// refs/tags/* into local tags with the same name)
AllTags
// NoTags fetch no tags from the remote at all
NoTags
)
// FetchOptions describes how a fetch should be performed
type FetchOptions struct {
// Name of the remote to fetch from. Defaults to origin.
RemoteName string
// RemoteURL overrides the remote repo address with a custom URL
RemoteURL string
RefSpecs []config.RefSpec
// Depth limit fetching to the specified number of commits from the tip of
// each remote branch history.
Depth int
// Auth credentials, if required, to use with the remote repository.
Auth transport.AuthMethod
// Progress is where the human readable information sent by the server is
// stored, if nil nothing is stored and the capability (if supported)
// no-progress, is sent to the server to avoid send this information.
Progress sideband.Progress
// Tags describe how the tags will be fetched from the remote repository,
// by default is TagFollowing.
Tags TagMode
// Force allows the fetch to update a local branch even when the remote
// branch does not descend from it.
Force bool
// InsecureSkipTLS skips ssl verify if protocol is https
InsecureSkipTLS bool
// CABundle specify additional ca bundle with system cert pool
CABundle []byte
// ProxyOptions provides info required for connecting to a proxy.
ProxyOptions transport.ProxyOptions
// Prune specify that local refs that match given RefSpecs and that do
// not exist remotely will be removed.
Prune bool
}
// Validate validates the fields and sets the default values.
func (o *FetchOptions) Validate() error {
if o.RemoteName == "" {
o.RemoteName = DefaultRemoteName
}
if o.Tags == InvalidTagMode {
o.Tags = TagFollowing
}
for _, r := range o.RefSpecs {
if err := r.Validate(); err != nil {
return err
}
}
return nil
}
// PushOptions describes how a push should be performed.
type PushOptions struct {
// RemoteName is the name of the remote to be pushed to.
RemoteName string
// RemoteURL overrides the remote repo address with a custom URL
RemoteURL string
// RefSpecs specify what destination ref to update with what source object.
//
// The format of a parameter is an optional plus +, followed by
// the source object , followed by a colon :, followed by the destination ref .
// The is often the name of the branch you would want to push, but it can be a SHA-1.
// The tells which ref on the remote side is updated with this push.
//
// A refspec with empty src can be used to delete a reference.
RefSpecs []config.RefSpec
// Auth credentials, if required, to use with the remote repository.
Auth transport.AuthMethod
// Progress is where the human readable information sent by the server is
// stored, if nil nothing is stored.
Progress sideband.Progress
// Prune specify that remote refs that match given RefSpecs and that do
// not exist locally will be removed.
Prune bool
// Force allows the push to update a remote branch even when the local
// branch does not descend from it.
Force bool
// InsecureSkipTLS skips ssl verify if protocol is https
InsecureSkipTLS bool
// CABundle specify additional ca bundle with system cert pool
CABundle []byte
// RequireRemoteRefs only allows a remote ref to be updated if its current
// value is the one specified here.
RequireRemoteRefs []config.RefSpec
// FollowTags will send any annotated tags with a commit target reachable from
// the refs already being pushed
FollowTags bool
// ForceWithLease allows a force push as long as the remote ref adheres to a "lease"
ForceWithLease *ForceWithLease
// PushOptions sets options to be transferred to the server during push.
Options map[string]string
// Atomic sets option to be an atomic push
Atomic bool
// ProxyOptions provides info required for connecting to a proxy.
ProxyOptions transport.ProxyOptions
}
// ForceWithLease sets fields on the lease
// If neither RefName nor Hash are set, ForceWithLease protects
// all refs in the refspec by ensuring the ref of the remote in the local repsitory
// matches the one in the ref advertisement.
type ForceWithLease struct {
// RefName, when set will protect the ref by ensuring it matches the
// hash in the ref advertisement.
RefName plumbing.ReferenceName
// Hash is the expected object id of RefName. The push will be rejected unless this
// matches the corresponding object id of RefName in the refs advertisement.
Hash plumbing.Hash
}
// Validate validates the fields and sets the default values.
func (o *PushOptions) Validate() error {
if o.RemoteName == "" {
o.RemoteName = DefaultRemoteName
}
if len(o.RefSpecs) == 0 {
o.RefSpecs = []config.RefSpec{
config.RefSpec(config.DefaultPushRefSpec),
}
}
for _, r := range o.RefSpecs {
if err := r.Validate(); err != nil {
return err
}
}
return nil
}
// SubmoduleUpdateOptions describes how a submodule update should be performed.
type SubmoduleUpdateOptions struct {
// Init, if true initializes the submodules recorded in the index.
Init bool
// NoFetch tell to the update command to not fetch new objects from the
// remote site.
NoFetch bool
// RecurseSubmodules the update is performed not only in the submodules of
// the current repository but also in any nested submodules inside those
// submodules (and so on). Until the SubmoduleRescursivity is reached.
RecurseSubmodules SubmoduleRescursivity
// Auth credentials, if required, to use with the remote repository.
Auth transport.AuthMethod
// Depth limit fetching to the specified number of commits from the tip of
// each remote branch history.
Depth int
}
var (
ErrBranchHashExclusive = errors.New("Branch and Hash are mutually exclusive")
ErrCreateRequiresBranch = errors.New("Branch is mandatory when Create is used")
)
// CheckoutOptions describes how a checkout operation should be performed.
type CheckoutOptions struct {
// Hash is the hash of a commit or tag to be checked out. If used, HEAD
// will be in detached mode. If Create is not used, Branch and Hash are
// mutually exclusive.
Hash plumbing.Hash
// Branch to be checked out, if Branch and Hash are empty is set to `master`.
Branch plumbing.ReferenceName
// Create a new branch named Branch and start it at Hash.
Create bool
// Force, if true when switching branches, proceed even if the index or the
// working tree differs from HEAD. This is used to throw away local changes
Force bool
// Keep, if true when switching branches, local changes (the index or the
// working tree changes) will be kept so that they can be committed to the
// target branch. Force and Keep are mutually exclusive, should not be both
// set to true.
Keep bool
// SparseCheckoutDirectories
SparseCheckoutDirectories []string
}
// Validate validates the fields and sets the default values.
func (o *CheckoutOptions) Validate() error {
if !o.Create && !o.Hash.IsZero() && o.Branch != "" {
return ErrBranchHashExclusive
}
if o.Create && o.Branch == "" {
return ErrCreateRequiresBranch
}
if o.Branch == "" {
o.Branch = plumbing.Master
}
return nil
}
// ResetMode defines the mode of a reset operation.
type ResetMode int8
const (
// MixedReset resets the index but not the working tree (i.e., the changed
// files are preserved but not marked for commit) and reports what has not
// been updated. This is the default action.
MixedReset ResetMode = iota
// HardReset resets the index and working tree. Any changes to tracked files
// in the working tree are discarded.
HardReset
// MergeReset resets the index and updates the files in the working tree
// that are different between Commit and HEAD, but keeps those which are
// different between the index and working tree (i.e. which have changes
// which have not been added).
//
// If a file that is different between Commit and the index has unstaged
// changes, reset is aborted.
MergeReset
// SoftReset does not touch the index file or the working tree at all (but
// resets the head to , just like all modes do). This leaves all
// your changed files "Changes to be committed", as git status would put it.
SoftReset
)
// ResetOptions describes how a reset operation should be performed.
type ResetOptions struct {
// Commit, if commit is present set the current branch head (HEAD) to it.
Commit plumbing.Hash
// Mode, form resets the current branch head to Commit and possibly updates
// the index (resetting it to the tree of Commit) and the working tree
// depending on Mode. If empty MixedReset is used.
Mode ResetMode
// Files, if not empty will constrain the reseting the index to only files
// specified in this list.
Files []string
}
// Validate validates the fields and sets the default values.
func (o *ResetOptions) Validate(r *Repository) error {
if o.Commit == plumbing.ZeroHash {
ref, err := r.Head()
if err != nil {
return err
}
o.Commit = ref.Hash()
} else {
_, err := r.CommitObject(o.Commit)
if err != nil {
return fmt.Errorf("invalid reset option: %w", err)
}
}
return nil
}
type LogOrder int8
const (
LogOrderDefault LogOrder = iota
LogOrderDFS
LogOrderDFSPost
LogOrderBSF
LogOrderCommitterTime
)
// LogOptions describes how a log action should be performed.
type LogOptions struct {
// When the From option is set the log will only contain commits
// reachable from it. If this option is not set, HEAD will be used as
// the default From.
From plumbing.Hash
// The default traversal algorithm is Depth-first search
// set Order=LogOrderCommitterTime for ordering by committer time (more compatible with `git log`)
// set Order=LogOrderBSF for Breadth-first search
Order LogOrder
// Show only those commits in which the specified file was inserted/updated.
// It is equivalent to running `git log -- `.
// this field is kept for compatibility, it can be replaced with PathFilter
FileName *string
// Filter commits based on the path of files that are updated
// takes file path as argument and should return true if the file is desired
// It can be used to implement `git log -- `
// either is a file path, or directory path, or a regexp of file/directory path
PathFilter func(string) bool
// Pretend as if all the refs in refs/, along with HEAD, are listed on the command line as .
// It is equivalent to running `git log --all`.
// If set on true, the From option will be ignored.
All bool
// Show commits more recent than a specific date.
// It is equivalent to running `git log --since ` or `git log --after `.
Since *time.Time
// Show commits older than a specific date.
// It is equivalent to running `git log --until ` or `git log --before `.
Until *time.Time
}
var (
ErrMissingAuthor = errors.New("author field is required")
)
// AddOptions describes how an `add` operation should be performed
type AddOptions struct {
// All equivalent to `git add -A`, update the index not only where the
// working tree has a file matching `Path` but also where the index already
// has an entry. This adds, modifies, and removes index entries to match the
// working tree. If no `Path` nor `Glob` is given when `All` option is
// used, all files in the entire working tree are updated.
All bool
// Path is the exact filepath to the file or directory to be added.
Path string
// Glob adds all paths, matching pattern, to the index. If pattern matches a
// directory path, all directory contents are added to the index recursively.
Glob string
// SkipStatus adds the path with no status check. This option is relevant only
// when the `Path` option is specified and does not apply when the `All` option is used.
// Notice that when passing an ignored path it will be added anyway.
// When true it can speed up adding files to the worktree in very large repositories.
SkipStatus bool
}
// Validate validates the fields and sets the default values.
func (o *AddOptions) Validate(r *Repository) error {
if o.Path != "" && o.Glob != "" {
return fmt.Errorf("fields Path and Glob are mutual exclusive")
}
return nil
}
// CommitOptions describes how a commit operation should be performed.
type CommitOptions struct {
// All automatically stage files that have been modified and deleted, but
// new files you have not told Git about are not affected.
All bool
// AllowEmptyCommits enable empty commits to be created. An empty commit
// is when no changes to the tree were made, but a new commit message is
// provided. The default behavior is false, which results in ErrEmptyCommit.
AllowEmptyCommits bool
// Author is the author's signature of the commit. If Author is empty the
// Name and Email is read from the config, and time.Now it's used as When.
Author *object.Signature
// Committer is the committer's signature of the commit. If Committer is
// nil the Author signature is used.
Committer *object.Signature
// Parents are the parents commits for the new commit, by default when
// len(Parents) is zero, the hash of HEAD reference is used.
Parents []plumbing.Hash
// SignKey denotes a key to sign the commit with. A nil value here means the
// commit will not be signed. The private key must be present and already
// decrypted.
SignKey *openpgp.Entity
// Signer denotes a cryptographic signer to sign the commit with.
// A nil value here means the commit will not be signed.
// Takes precedence over SignKey.
Signer Signer
// Amend will create a new commit object and replace the commit that HEAD currently
// points to. Cannot be used with All nor Parents.
Amend bool
}
// Validate validates the fields and sets the default values.
func (o *CommitOptions) Validate(r *Repository) error {
if o.All && o.Amend {
return errors.New("all and amend cannot be used together")
}
if o.Amend && len(o.Parents) > 0 {
return errors.New("parents cannot be used with amend")
}
if o.Author == nil {
if err := o.loadConfigAuthorAndCommitter(r); err != nil {
return err
}
}
if o.Committer == nil {
o.Committer = o.Author
}
if len(o.Parents) == 0 {
head, err := r.Head()
if err != nil && err != plumbing.ErrReferenceNotFound {
return err
}
if head != nil {
o.Parents = []plumbing.Hash{head.Hash()}
}
}
return nil
}
func (o *CommitOptions) loadConfigAuthorAndCommitter(r *Repository) error {
cfg, err := r.ConfigScoped(config.SystemScope)
if err != nil {
return err
}
if o.Author == nil && cfg.Author.Email != "" && cfg.Author.Name != "" {
o.Author = &object.Signature{
Name: cfg.Author.Name,
Email: cfg.Author.Email,
When: time.Now(),
}
}
if o.Committer == nil && cfg.Committer.Email != "" && cfg.Committer.Name != "" {
o.Committer = &object.Signature{
Name: cfg.Committer.Name,
Email: cfg.Committer.Email,
When: time.Now(),
}
}
if o.Author == nil && cfg.User.Email != "" && cfg.User.Name != "" {
o.Author = &object.Signature{
Name: cfg.User.Name,
Email: cfg.User.Email,
When: time.Now(),
}
}
if o.Author == nil {
return ErrMissingAuthor
}
return nil
}
var (
ErrMissingName = errors.New("name field is required")
ErrMissingTagger = errors.New("tagger field is required")
ErrMissingMessage = errors.New("message field is required")
)
// CreateTagOptions describes how a tag object should be created.
type CreateTagOptions struct {
// Tagger defines the signature of the tag creator. If Tagger is empty the
// Name and Email is read from the config, and time.Now it's used as When.
Tagger *object.Signature
// Message defines the annotation of the tag. It is canonicalized during
// validation into the format expected by git - no leading whitespace and
// ending in a newline.
Message string
// SignKey denotes a key to sign the tag with. A nil value here means the tag
// will not be signed. The private key must be present and already decrypted.
SignKey *openpgp.Entity
}
// Validate validates the fields and sets the default values.
func (o *CreateTagOptions) Validate(r *Repository, hash plumbing.Hash) error {
if o.Tagger == nil {
if err := o.loadConfigTagger(r); err != nil {
return err
}
}
if o.Message == "" {
return ErrMissingMessage
}
// Canonicalize the message into the expected message format.
o.Message = strings.TrimSpace(o.Message) + "\n"
return nil
}
func (o *CreateTagOptions) loadConfigTagger(r *Repository) error {
cfg, err := r.ConfigScoped(config.SystemScope)
if err != nil {
return err
}
if o.Tagger == nil && cfg.Author.Email != "" && cfg.Author.Name != "" {
o.Tagger = &object.Signature{
Name: cfg.Author.Name,
Email: cfg.Author.Email,
When: time.Now(),
}
}
if o.Tagger == nil && cfg.User.Email != "" && cfg.User.Name != "" {
o.Tagger = &object.Signature{
Name: cfg.User.Name,
Email: cfg.User.Email,
When: time.Now(),
}
}
if o.Tagger == nil {
return ErrMissingTagger
}
return nil
}
// ListOptions describes how a remote list should be performed.
type ListOptions struct {
// Auth credentials, if required, to use with the remote repository.
Auth transport.AuthMethod
// InsecureSkipTLS skips ssl verify if protocol is https
InsecureSkipTLS bool
// CABundle specify additional ca bundle with system cert pool
CABundle []byte
// PeelingOption defines how peeled objects are handled during a
// remote list.
PeelingOption PeelingOption
// ProxyOptions provides info required for connecting to a proxy.
ProxyOptions transport.ProxyOptions
// Timeout specifies the timeout in seconds for list operations
Timeout int
}
// PeelingOption represents the different ways to handle peeled references.
//
// Peeled references represent the underlying object of an annotated
// (or signed) tag. Refer to upstream documentation for more info:
// https://github.com/git/git/blob/master/Documentation/technical/reftable.txt
type PeelingOption uint8
const (
// IgnorePeeled ignores all peeled reference names. This is the default behavior.
IgnorePeeled PeelingOption = 0
// OnlyPeeled returns only peeled reference names.
OnlyPeeled PeelingOption = 1
// AppendPeeled appends peeled reference names to the reference list.
AppendPeeled PeelingOption = 2
)
// CleanOptions describes how a clean should be performed.
type CleanOptions struct {
Dir bool
}
// GrepOptions describes how a grep should be performed.
type GrepOptions struct {
// Patterns are compiled Regexp objects to be matched.
Patterns []*regexp.Regexp
// InvertMatch selects non-matching lines.
InvertMatch bool
// CommitHash is the hash of the commit from which worktree should be derived.
CommitHash plumbing.Hash
// ReferenceName is the branch or tag name from which worktree should be derived.
ReferenceName plumbing.ReferenceName
// PathSpecs are compiled Regexp objects of pathspec to use in the matching.
PathSpecs []*regexp.Regexp
}
var (
ErrHashOrReference = errors.New("ambiguous options, only one of CommitHash or ReferenceName can be passed")
)
// Validate validates the fields and sets the default values.
//
// TODO: deprecate in favor of Validate(r *Repository) in v6.
func (o *GrepOptions) Validate(w *Worktree) error {
return o.validate(w.r)
}
func (o *GrepOptions) validate(r *Repository) error {
if !o.CommitHash.IsZero() && o.ReferenceName != "" {
return ErrHashOrReference
}
// If none of CommitHash and ReferenceName are provided, set commit hash of
// the repository's head.
if o.CommitHash.IsZero() && o.ReferenceName == "" {
ref, err := r.Head()
if err != nil {
return err
}
o.CommitHash = ref.Hash()
}
return nil
}
// PlainOpenOptions describes how opening a plain repository should be
// performed.
type PlainOpenOptions struct {
// DetectDotGit defines whether parent directories should be
// walked until a .git directory or file is found.
DetectDotGit bool
// Enable .git/commondir support (see https://git-scm.com/docs/gitrepository-layout#Documentation/gitrepository-layout.txt).
// NOTE: This option will only work with the filesystem storage.
EnableDotGitCommonDir bool
}
// Validate validates the fields and sets the default values.
func (o *PlainOpenOptions) Validate() error { return nil }
type PlainInitOptions struct {
InitOptions
// Determines if the repository will have a worktree (non-bare) or not (bare).
Bare bool
ObjectFormat formatcfg.ObjectFormat
}
// Validate validates the fields and sets the default values.
func (o *PlainInitOptions) Validate() error { return nil }
var (
ErrNoRestorePaths = errors.New("you must specify path(s) to restore")
)
// RestoreOptions describes how a restore should be performed.
type RestoreOptions struct {
// Marks to restore the content in the index
Staged bool
// Marks to restore the content of the working tree
Worktree bool
// List of file paths that will be restored
Files []string
}
// Validate validates the fields and sets the default values.
func (o *RestoreOptions) Validate() error {
if len(o.Files) == 0 {
return ErrNoRestorePaths
}
return nil
}
go-git-5.13.2/options_test.go 0000664 0000000 0000000 00000005470 14744245500 0016064 0 ustar 00root root 0000000 0000000 package git
import (
"os"
"github.com/go-git/go-billy/v5/util"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/object"
. "gopkg.in/check.v1"
)
type OptionsSuite struct {
BaseSuite
}
var _ = Suite(&OptionsSuite{})
func (s *OptionsSuite) TestCommitOptionsParentsFromHEAD(c *C) {
o := CommitOptions{Author: &object.Signature{}}
err := o.Validate(s.Repository)
c.Assert(err, IsNil)
c.Assert(o.Parents, HasLen, 1)
}
func (s *OptionsSuite) TestResetOptionsCommitNotFound(c *C) {
o := ResetOptions{Commit: plumbing.NewHash("ab1b15c6f6487b4db16f10d8ec69bb8bf91dcabd")}
err := o.Validate(s.Repository)
c.Assert(err, NotNil)
}
func (s *OptionsSuite) TestCommitOptionsCommitter(c *C) {
sig := &object.Signature{}
o := CommitOptions{Author: sig}
err := o.Validate(s.Repository)
c.Assert(err, IsNil)
c.Assert(o.Committer, Equals, o.Author)
}
func (s *OptionsSuite) TestCommitOptionsLoadGlobalConfigUser(c *C) {
cfg := config.NewConfig()
cfg.User.Name = "foo"
cfg.User.Email = "foo@foo.com"
clean := s.writeGlobalConfig(c, cfg)
defer clean()
o := CommitOptions{}
err := o.Validate(s.Repository)
c.Assert(err, IsNil)
c.Assert(o.Author.Name, Equals, "foo")
c.Assert(o.Author.Email, Equals, "foo@foo.com")
c.Assert(o.Committer.Name, Equals, "foo")
c.Assert(o.Committer.Email, Equals, "foo@foo.com")
}
func (s *OptionsSuite) TestCommitOptionsLoadGlobalCommitter(c *C) {
cfg := config.NewConfig()
cfg.User.Name = "foo"
cfg.User.Email = "foo@foo.com"
cfg.Committer.Name = "bar"
cfg.Committer.Email = "bar@bar.com"
clean := s.writeGlobalConfig(c, cfg)
defer clean()
o := CommitOptions{}
err := o.Validate(s.Repository)
c.Assert(err, IsNil)
c.Assert(o.Author.Name, Equals, "foo")
c.Assert(o.Author.Email, Equals, "foo@foo.com")
c.Assert(o.Committer.Name, Equals, "bar")
c.Assert(o.Committer.Email, Equals, "bar@bar.com")
}
func (s *OptionsSuite) TestCreateTagOptionsLoadGlobal(c *C) {
cfg := config.NewConfig()
cfg.User.Name = "foo"
cfg.User.Email = "foo@foo.com"
clean := s.writeGlobalConfig(c, cfg)
defer clean()
o := CreateTagOptions{
Message: "foo",
}
err := o.Validate(s.Repository, plumbing.ZeroHash)
c.Assert(err, IsNil)
c.Assert(o.Tagger.Name, Equals, "foo")
c.Assert(o.Tagger.Email, Equals, "foo@foo.com")
}
func (s *OptionsSuite) writeGlobalConfig(c *C, cfg *config.Config) func() {
fs := s.TemporalFilesystem(c)
tmp, err := util.TempDir(fs, "", "test-options")
c.Assert(err, IsNil)
err = fs.MkdirAll(fs.Join(tmp, "git"), 0777)
c.Assert(err, IsNil)
os.Setenv("XDG_CONFIG_HOME", fs.Join(fs.Root(), tmp))
content, err := cfg.Marshal()
c.Assert(err, IsNil)
cfgFile := fs.Join(tmp, "git/config")
err = util.WriteFile(fs, cfgFile, content, 0777)
c.Assert(err, IsNil)
return func() {
os.Setenv("XDG_CONFIG_HOME", "")
}
}
go-git-5.13.2/oss-fuzz.sh 0000664 0000000 0000000 00000003633 14744245500 0015136 0 ustar 00root root 0000000 0000000 #!/bin/bash -eu
# Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
################################################################################
go mod download
go get github.com/AdamKorcz/go-118-fuzz-build/testing
if [ "$SANITIZER" != "coverage" ]; then
sed -i '/func (s \*DecoderSuite) TestDecode(/,/^}/ s/^/\/\//' plumbing/format/config/decoder_test.go
sed -n '35,$p' plumbing/format/packfile/common_test.go >> plumbing/format/packfile/delta_test.go
sed -n '20,53p' plumbing/object/object_test.go >> plumbing/object/tree_test.go
sed -i 's|func Test|// func Test|' plumbing/transport/common_test.go
fi
compile_native_go_fuzzer $(pwd)/internal/revision FuzzParser fuzz_parser
compile_native_go_fuzzer $(pwd)/plumbing/format/config FuzzDecoder fuzz_decoder_config
compile_native_go_fuzzer $(pwd)/plumbing/format/packfile FuzzPatchDelta fuzz_patch_delta
compile_native_go_fuzzer $(pwd)/plumbing/object FuzzParseSignedBytes fuzz_parse_signed_bytes
compile_native_go_fuzzer $(pwd)/plumbing/object FuzzDecode fuzz_decode
compile_native_go_fuzzer $(pwd)/plumbing/protocol/packp FuzzDecoder fuzz_decoder_packp
compile_native_go_fuzzer $(pwd)/plumbing/transport FuzzNewEndpoint fuzz_new_endpoint
go-git-5.13.2/plumbing/ 0000775 0000000 0000000 00000000000 14744245500 0014612 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/cache/ 0000775 0000000 0000000 00000000000 14744245500 0015655 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/cache/buffer_lru.go 0000664 0000000 0000000 00000004302 14744245500 0020336 0 ustar 00root root 0000000 0000000 package cache
import (
"container/list"
"sync"
)
// BufferLRU implements an object cache with an LRU eviction policy and a
// maximum size (measured in object size).
type BufferLRU struct {
MaxSize FileSize
actualSize FileSize
ll *list.List
cache map[int64]*list.Element
mut sync.Mutex
}
// NewBufferLRU creates a new BufferLRU with the given maximum size. The maximum
// size will never be exceeded.
func NewBufferLRU(maxSize FileSize) *BufferLRU {
return &BufferLRU{MaxSize: maxSize}
}
// NewBufferLRUDefault creates a new BufferLRU with the default cache size.
func NewBufferLRUDefault() *BufferLRU {
return &BufferLRU{MaxSize: DefaultMaxSize}
}
type buffer struct {
Key int64
Slice []byte
}
// Put puts a buffer into the cache. If the buffer is already in the cache, it
// will be marked as used. Otherwise, it will be inserted. A buffers might
// be evicted to make room for the new one.
func (c *BufferLRU) Put(key int64, slice []byte) {
c.mut.Lock()
defer c.mut.Unlock()
if c.cache == nil {
c.actualSize = 0
c.cache = make(map[int64]*list.Element, 1000)
c.ll = list.New()
}
bufSize := FileSize(len(slice))
if ee, ok := c.cache[key]; ok {
oldBuf := ee.Value.(buffer)
// in this case bufSize is a delta: new size - old size
bufSize -= FileSize(len(oldBuf.Slice))
c.ll.MoveToFront(ee)
ee.Value = buffer{key, slice}
} else {
if bufSize > c.MaxSize {
return
}
ee := c.ll.PushFront(buffer{key, slice})
c.cache[key] = ee
}
c.actualSize += bufSize
for c.actualSize > c.MaxSize {
last := c.ll.Back()
lastObj := last.Value.(buffer)
lastSize := FileSize(len(lastObj.Slice))
c.ll.Remove(last)
delete(c.cache, lastObj.Key)
c.actualSize -= lastSize
}
}
// Get returns a buffer by its key. It marks the buffer as used. If the buffer
// is not in the cache, (nil, false) will be returned.
func (c *BufferLRU) Get(key int64) ([]byte, bool) {
c.mut.Lock()
defer c.mut.Unlock()
ee, ok := c.cache[key]
if !ok {
return nil, false
}
c.ll.MoveToFront(ee)
return ee.Value.(buffer).Slice, true
}
// Clear the content of this buffer cache.
func (c *BufferLRU) Clear() {
c.mut.Lock()
defer c.mut.Unlock()
c.ll = nil
c.cache = nil
c.actualSize = 0
}
go-git-5.13.2/plumbing/cache/buffer_test.go 0000664 0000000 0000000 00000005652 14744245500 0020524 0 ustar 00root root 0000000 0000000 package cache
import (
"bytes"
"sync"
. "gopkg.in/check.v1"
)
type BufferSuite struct {
c map[string]Buffer
aBuffer []byte
bBuffer []byte
cBuffer []byte
dBuffer []byte
eBuffer []byte
}
var _ = Suite(&BufferSuite{})
func (s *BufferSuite) SetUpTest(c *C) {
s.aBuffer = []byte("a")
s.bBuffer = []byte("bbb")
s.cBuffer = []byte("c")
s.dBuffer = []byte("d")
s.eBuffer = []byte("ee")
s.c = make(map[string]Buffer)
s.c["two_bytes"] = NewBufferLRU(2 * Byte)
s.c["default_lru"] = NewBufferLRUDefault()
}
func (s *BufferSuite) TestPutSameBuffer(c *C) {
for _, o := range s.c {
o.Put(1, s.aBuffer)
o.Put(1, s.aBuffer)
_, ok := o.Get(1)
c.Assert(ok, Equals, true)
}
}
func (s *ObjectSuite) TestPutSameBufferWithDifferentSize(c *C) {
aBuffer := []byte("a")
bBuffer := []byte("bbb")
cBuffer := []byte("ccccc")
dBuffer := []byte("ddddddd")
cache := NewBufferLRU(7 * Byte)
cache.Put(1, aBuffer)
cache.Put(1, bBuffer)
cache.Put(1, cBuffer)
cache.Put(1, dBuffer)
c.Assert(cache.MaxSize, Equals, 7*Byte)
c.Assert(cache.actualSize, Equals, 7*Byte)
c.Assert(cache.ll.Len(), Equals, 1)
buf, ok := cache.Get(1)
c.Assert(bytes.Equal(buf, dBuffer), Equals, true)
c.Assert(FileSize(len(buf)), Equals, 7*Byte)
c.Assert(ok, Equals, true)
}
func (s *BufferSuite) TestPutBigBuffer(c *C) {
for _, o := range s.c {
o.Put(1, s.bBuffer)
_, ok := o.Get(2)
c.Assert(ok, Equals, false)
}
}
func (s *BufferSuite) TestPutCacheOverflow(c *C) {
// this test only works with an specific size
o := s.c["two_bytes"]
o.Put(1, s.aBuffer)
o.Put(2, s.cBuffer)
o.Put(3, s.dBuffer)
obj, ok := o.Get(1)
c.Assert(ok, Equals, false)
c.Assert(obj, IsNil)
obj, ok = o.Get(2)
c.Assert(ok, Equals, true)
c.Assert(obj, NotNil)
obj, ok = o.Get(3)
c.Assert(ok, Equals, true)
c.Assert(obj, NotNil)
}
func (s *BufferSuite) TestEvictMultipleBuffers(c *C) {
o := s.c["two_bytes"]
o.Put(1, s.cBuffer)
o.Put(2, s.dBuffer) // now cache is full with two objects
o.Put(3, s.eBuffer) // this put should evict all previous objects
obj, ok := o.Get(1)
c.Assert(ok, Equals, false)
c.Assert(obj, IsNil)
obj, ok = o.Get(2)
c.Assert(ok, Equals, false)
c.Assert(obj, IsNil)
obj, ok = o.Get(3)
c.Assert(ok, Equals, true)
c.Assert(obj, NotNil)
}
func (s *BufferSuite) TestClear(c *C) {
for _, o := range s.c {
o.Put(1, s.aBuffer)
o.Clear()
obj, ok := o.Get(1)
c.Assert(ok, Equals, false)
c.Assert(obj, IsNil)
}
}
func (s *BufferSuite) TestConcurrentAccess(c *C) {
for _, o := range s.c {
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(3)
go func(i int) {
o.Put(int64(i), []byte{00})
wg.Done()
}(i)
go func(i int) {
if i%30 == 0 {
o.Clear()
}
wg.Done()
}(i)
go func(i int) {
o.Get(int64(i))
wg.Done()
}(i)
}
wg.Wait()
}
}
func (s *BufferSuite) TestDefaultLRU(c *C) {
defaultLRU := s.c["default_lru"].(*BufferLRU)
c.Assert(defaultLRU.MaxSize, Equals, DefaultMaxSize)
}
go-git-5.13.2/plumbing/cache/common.go 0000664 0000000 0000000 00000002271 14744245500 0017476 0 ustar 00root root 0000000 0000000 package cache
import "github.com/go-git/go-git/v5/plumbing"
const (
Byte FileSize = 1 << (iota * 10)
KiByte
MiByte
GiByte
)
type FileSize int64
const DefaultMaxSize FileSize = 96 * MiByte
// Object is an interface to a object cache.
type Object interface {
// Put puts the given object into the cache. Whether this object will
// actually be put into the cache or not is implementation specific.
Put(o plumbing.EncodedObject)
// Get gets an object from the cache given its hash. The second return value
// is true if the object was returned, and false otherwise.
Get(k plumbing.Hash) (plumbing.EncodedObject, bool)
// Clear clears every object from the cache.
Clear()
}
// Buffer is an interface to a buffer cache.
type Buffer interface {
// Put puts a buffer into the cache. If the buffer is already in the cache,
// it will be marked as used. Otherwise, it will be inserted. Buffer might
// be evicted to make room for the new one.
Put(key int64, slice []byte)
// Get returns a buffer by its key. It marks the buffer as used. If the
// buffer is not in the cache, (nil, false) will be returned.
Get(key int64) ([]byte, bool)
// Clear clears every object from the cache.
Clear()
}
go-git-5.13.2/plumbing/cache/object_lru.go 0000664 0000000 0000000 00000004466 14744245500 0020346 0 ustar 00root root 0000000 0000000 package cache
import (
"container/list"
"sync"
"github.com/go-git/go-git/v5/plumbing"
)
// ObjectLRU implements an object cache with an LRU eviction policy and a
// maximum size (measured in object size).
type ObjectLRU struct {
MaxSize FileSize
actualSize FileSize
ll *list.List
cache map[interface{}]*list.Element
mut sync.Mutex
}
// NewObjectLRU creates a new ObjectLRU with the given maximum size. The maximum
// size will never be exceeded.
func NewObjectLRU(maxSize FileSize) *ObjectLRU {
return &ObjectLRU{MaxSize: maxSize}
}
// NewObjectLRUDefault creates a new ObjectLRU with the default cache size.
func NewObjectLRUDefault() *ObjectLRU {
return &ObjectLRU{MaxSize: DefaultMaxSize}
}
// Put puts an object into the cache. If the object is already in the cache, it
// will be marked as used. Otherwise, it will be inserted. A single object might
// be evicted to make room for the new object.
func (c *ObjectLRU) Put(obj plumbing.EncodedObject) {
c.mut.Lock()
defer c.mut.Unlock()
if c.cache == nil {
c.actualSize = 0
c.cache = make(map[interface{}]*list.Element, 1000)
c.ll = list.New()
}
objSize := FileSize(obj.Size())
key := obj.Hash()
if ee, ok := c.cache[key]; ok {
oldObj := ee.Value.(plumbing.EncodedObject)
// in this case objSize is a delta: new size - old size
objSize -= FileSize(oldObj.Size())
c.ll.MoveToFront(ee)
ee.Value = obj
} else {
if objSize > c.MaxSize {
return
}
ee := c.ll.PushFront(obj)
c.cache[key] = ee
}
c.actualSize += objSize
for c.actualSize > c.MaxSize {
last := c.ll.Back()
if last == nil {
c.actualSize = 0
break
}
lastObj := last.Value.(plumbing.EncodedObject)
lastSize := FileSize(lastObj.Size())
c.ll.Remove(last)
delete(c.cache, lastObj.Hash())
c.actualSize -= lastSize
}
}
// Get returns an object by its hash. It marks the object as used. If the object
// is not in the cache, (nil, false) will be returned.
func (c *ObjectLRU) Get(k plumbing.Hash) (plumbing.EncodedObject, bool) {
c.mut.Lock()
defer c.mut.Unlock()
ee, ok := c.cache[k]
if !ok {
return nil, false
}
c.ll.MoveToFront(ee)
return ee.Value.(plumbing.EncodedObject), true
}
// Clear the content of this object cache.
func (c *ObjectLRU) Clear() {
c.mut.Lock()
defer c.mut.Unlock()
c.ll = nil
c.cache = nil
c.actualSize = 0
}
go-git-5.13.2/plumbing/cache/object_test.go 0000664 0000000 0000000 00000010765 14744245500 0020522 0 ustar 00root root 0000000 0000000 package cache
import (
"fmt"
"io"
"sync"
"testing"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type ObjectSuite struct {
c map[string]Object
aObject plumbing.EncodedObject
bObject plumbing.EncodedObject
cObject plumbing.EncodedObject
dObject plumbing.EncodedObject
eObject plumbing.EncodedObject
}
var _ = Suite(&ObjectSuite{})
func (s *ObjectSuite) SetUpTest(c *C) {
s.aObject = newObject("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 1*Byte)
s.bObject = newObject("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", 3*Byte)
s.cObject = newObject("cccccccccccccccccccccccccccccccccccccccc", 1*Byte)
s.dObject = newObject("dddddddddddddddddddddddddddddddddddddddd", 1*Byte)
s.eObject = newObject("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", 2*Byte)
s.c = make(map[string]Object)
s.c["two_bytes"] = NewObjectLRU(2 * Byte)
s.c["default_lru"] = NewObjectLRUDefault()
}
func (s *ObjectSuite) TestPutSameObject(c *C) {
for _, o := range s.c {
o.Put(s.aObject)
o.Put(s.aObject)
_, ok := o.Get(s.aObject.Hash())
c.Assert(ok, Equals, true)
}
}
func (s *ObjectSuite) TestPutSameObjectWithDifferentSize(c *C) {
const hash = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
cache := NewObjectLRU(7 * Byte)
cache.Put(newObject(hash, 1*Byte))
cache.Put(newObject(hash, 3*Byte))
cache.Put(newObject(hash, 5*Byte))
cache.Put(newObject(hash, 7*Byte))
c.Assert(cache.MaxSize, Equals, 7*Byte)
c.Assert(cache.actualSize, Equals, 7*Byte)
c.Assert(cache.ll.Len(), Equals, 1)
obj, ok := cache.Get(plumbing.NewHash(hash))
c.Assert(obj.Hash(), Equals, plumbing.NewHash(hash))
c.Assert(FileSize(obj.Size()), Equals, 7*Byte)
c.Assert(ok, Equals, true)
}
func (s *ObjectSuite) TestPutBigObject(c *C) {
for _, o := range s.c {
o.Put(s.bObject)
_, ok := o.Get(s.aObject.Hash())
c.Assert(ok, Equals, false)
}
}
func (s *ObjectSuite) TestPutCacheOverflow(c *C) {
// this test only works with an specific size
o := s.c["two_bytes"]
o.Put(s.aObject)
o.Put(s.cObject)
o.Put(s.dObject)
obj, ok := o.Get(s.aObject.Hash())
c.Assert(ok, Equals, false)
c.Assert(obj, IsNil)
obj, ok = o.Get(s.cObject.Hash())
c.Assert(ok, Equals, true)
c.Assert(obj, NotNil)
obj, ok = o.Get(s.dObject.Hash())
c.Assert(ok, Equals, true)
c.Assert(obj, NotNil)
}
func (s *ObjectSuite) TestEvictMultipleObjects(c *C) {
o := s.c["two_bytes"]
o.Put(s.cObject)
o.Put(s.dObject) // now cache is full with two objects
o.Put(s.eObject) // this put should evict all previous objects
obj, ok := o.Get(s.cObject.Hash())
c.Assert(ok, Equals, false)
c.Assert(obj, IsNil)
obj, ok = o.Get(s.dObject.Hash())
c.Assert(ok, Equals, false)
c.Assert(obj, IsNil)
obj, ok = o.Get(s.eObject.Hash())
c.Assert(ok, Equals, true)
c.Assert(obj, NotNil)
}
func (s *ObjectSuite) TestClear(c *C) {
for _, o := range s.c {
o.Put(s.aObject)
o.Clear()
obj, ok := o.Get(s.aObject.Hash())
c.Assert(ok, Equals, false)
c.Assert(obj, IsNil)
}
}
func (s *ObjectSuite) TestConcurrentAccess(c *C) {
for _, o := range s.c {
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(3)
go func(i int) {
o.Put(newObject(fmt.Sprint(i), FileSize(i)))
wg.Done()
}(i)
go func(i int) {
if i%30 == 0 {
o.Clear()
}
wg.Done()
}(i)
go func(i int) {
o.Get(plumbing.NewHash(fmt.Sprint(i)))
wg.Done()
}(i)
}
wg.Wait()
}
}
func (s *ObjectSuite) TestDefaultLRU(c *C) {
defaultLRU := s.c["default_lru"].(*ObjectLRU)
c.Assert(defaultLRU.MaxSize, Equals, DefaultMaxSize)
}
func (s *ObjectSuite) TestObjectUpdateOverflow(c *C) {
o := NewObjectLRU(9 * Byte)
a1 := newObject(s.aObject.Hash().String(), 9*Byte)
a2 := newObject(s.aObject.Hash().String(), 1*Byte)
b := newObject(s.bObject.Hash().String(), 1*Byte)
o.Put(a1)
a1.SetSize(-5)
o.Put(a2)
o.Put(b)
}
type dummyObject struct {
hash plumbing.Hash
size FileSize
}
func newObject(hash string, size FileSize) plumbing.EncodedObject {
return &dummyObject{
hash: plumbing.NewHash(hash),
size: size,
}
}
func (d *dummyObject) Hash() plumbing.Hash { return d.hash }
func (*dummyObject) Type() plumbing.ObjectType { return plumbing.InvalidObject }
func (*dummyObject) SetType(plumbing.ObjectType) {}
func (d *dummyObject) Size() int64 { return int64(d.size) }
func (d *dummyObject) SetSize(s int64) { d.size = FileSize(s) }
func (*dummyObject) Reader() (io.ReadCloser, error) { return nil, nil }
func (*dummyObject) Writer() (io.WriteCloser, error) { return nil, nil }
go-git-5.13.2/plumbing/color/ 0000775 0000000 0000000 00000000000 14744245500 0015730 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/color/color.go 0000664 0000000 0000000 00000002106 14744245500 0017374 0 ustar 00root root 0000000 0000000 package color
// TODO read colors from a github.com/go-git/go-git/plumbing/format/config.Config struct
// TODO implement color parsing, see https://github.com/git/git/blob/v2.26.2/color.c
// Colors. See https://github.com/git/git/blob/v2.26.2/color.h#L24-L53.
const (
Normal = ""
Reset = "\033[m"
Bold = "\033[1m"
Red = "\033[31m"
Green = "\033[32m"
Yellow = "\033[33m"
Blue = "\033[34m"
Magenta = "\033[35m"
Cyan = "\033[36m"
BoldRed = "\033[1;31m"
BoldGreen = "\033[1;32m"
BoldYellow = "\033[1;33m"
BoldBlue = "\033[1;34m"
BoldMagenta = "\033[1;35m"
BoldCyan = "\033[1;36m"
FaintRed = "\033[2;31m"
FaintGreen = "\033[2;32m"
FaintYellow = "\033[2;33m"
FaintBlue = "\033[2;34m"
FaintMagenta = "\033[2;35m"
FaintCyan = "\033[2;36m"
BgRed = "\033[41m"
BgGreen = "\033[42m"
BgYellow = "\033[43m"
BgBlue = "\033[44m"
BgMagenta = "\033[45m"
BgCyan = "\033[46m"
Faint = "\033[2m"
FaintItalic = "\033[2;3m"
Reverse = "\033[7m"
)
go-git-5.13.2/plumbing/error.go 0000664 0000000 0000000 00000001115 14744245500 0016270 0 ustar 00root root 0000000 0000000 package plumbing
import "fmt"
type PermanentError struct {
Err error
}
func NewPermanentError(err error) *PermanentError {
if err == nil {
return nil
}
return &PermanentError{Err: err}
}
func (e *PermanentError) Error() string {
return fmt.Sprintf("permanent client error: %s", e.Err.Error())
}
type UnexpectedError struct {
Err error
}
func NewUnexpectedError(err error) *UnexpectedError {
if err == nil {
return nil
}
return &UnexpectedError{Err: err}
}
func (e *UnexpectedError) Error() string {
return fmt.Sprintf("unexpected client error: %s", e.Err.Error())
}
go-git-5.13.2/plumbing/filemode/ 0000775 0000000 0000000 00000000000 14744245500 0016376 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/filemode/filemode.go 0000664 0000000 0000000 00000013360 14744245500 0020514 0 ustar 00root root 0000000 0000000 package filemode
import (
"encoding/binary"
"fmt"
"os"
"strconv"
)
// A FileMode represents the kind of tree entries used by git. It
// resembles regular file systems modes, although FileModes are
// considerably simpler (there are not so many), and there are some,
// like Submodule that has no file system equivalent.
type FileMode uint32
const (
// Empty is used as the FileMode of tree elements when comparing
// trees in the following situations:
//
// - the mode of tree elements before their creation. - the mode of
// tree elements after their deletion. - the mode of unmerged
// elements when checking the index.
//
// Empty has no file system equivalent. As Empty is the zero value
// of FileMode, it is also returned by New and
// NewFromOsNewFromOSFileMode along with an error, when they fail.
Empty FileMode = 0
// Dir represent a Directory.
Dir FileMode = 0040000
// Regular represent non-executable files. Please note this is not
// the same as golang regular files, which include executable files.
Regular FileMode = 0100644
// Deprecated represent non-executable files with the group writable
// bit set. This mode was supported by the first versions of git,
// but it has been deprecated nowadays. This library uses them
// internally, so you can read old packfiles, but will treat them as
// Regulars when interfacing with the outside world. This is the
// standard git behaviour.
Deprecated FileMode = 0100664
// Executable represents executable files.
Executable FileMode = 0100755
// Symlink represents symbolic links to files.
Symlink FileMode = 0120000
// Submodule represents git submodules. This mode has no file system
// equivalent.
Submodule FileMode = 0160000
)
// New takes the octal string representation of a FileMode and returns
// the FileMode and a nil error. If the string can not be parsed to a
// 32 bit unsigned octal number, it returns Empty and the parsing error.
//
// Example: "40000" means Dir, "100644" means Regular.
//
// Please note this function does not check if the returned FileMode
// is valid in git or if it is malformed. For instance, "1" will
// return the malformed FileMode(1) and a nil error.
func New(s string) (FileMode, error) {
n, err := strconv.ParseUint(s, 8, 32)
if err != nil {
return Empty, err
}
return FileMode(n), nil
}
// NewFromOSFileMode returns the FileMode used by git to represent
// the provided file system modes and a nil error on success. If the
// file system mode cannot be mapped to any valid git mode (as with
// sockets or named pipes), it will return Empty and an error.
//
// Note that some git modes cannot be generated from os.FileModes, like
// Deprecated and Submodule; while Empty will be returned, along with an
// error, only when the method fails.
func NewFromOSFileMode(m os.FileMode) (FileMode, error) {
if m.IsRegular() {
if isSetTemporary(m) {
return Empty, fmt.Errorf("no equivalent git mode for %s", m)
}
if isSetCharDevice(m) {
return Empty, fmt.Errorf("no equivalent git mode for %s", m)
}
if isSetUserExecutable(m) {
return Executable, nil
}
return Regular, nil
}
if m.IsDir() {
return Dir, nil
}
if isSetSymLink(m) {
return Symlink, nil
}
return Empty, fmt.Errorf("no equivalent git mode for %s", m)
}
func isSetCharDevice(m os.FileMode) bool {
return m&os.ModeCharDevice != 0
}
func isSetTemporary(m os.FileMode) bool {
return m&os.ModeTemporary != 0
}
func isSetUserExecutable(m os.FileMode) bool {
return m&0100 != 0
}
func isSetSymLink(m os.FileMode) bool {
return m&os.ModeSymlink != 0
}
// Bytes return a slice of 4 bytes with the mode in little endian
// encoding.
func (m FileMode) Bytes() []byte {
ret := make([]byte, 4)
binary.LittleEndian.PutUint32(ret, uint32(m))
return ret
}
// IsMalformed returns if the FileMode should not appear in a git packfile,
// this is: Empty and any other mode not mentioned as a constant in this
// package.
func (m FileMode) IsMalformed() bool {
return m != Dir &&
m != Regular &&
m != Deprecated &&
m != Executable &&
m != Symlink &&
m != Submodule
}
// String returns the FileMode as a string in the standard git format,
// this is, an octal number padded with ceros to 7 digits. Malformed
// modes are printed in that same format, for easier debugging.
//
// Example: Regular is "0100644", Empty is "0000000".
func (m FileMode) String() string {
return fmt.Sprintf("%07o", uint32(m))
}
// IsRegular returns if the FileMode represents that of a regular file,
// this is, either Regular or Deprecated. Please note that Executable
// are not regular even though in the UNIX tradition, they usually are:
// See the IsFile method.
func (m FileMode) IsRegular() bool {
return m == Regular ||
m == Deprecated
}
// IsFile returns if the FileMode represents that of a file, this is,
// Regular, Deprecated, Executable or Link.
func (m FileMode) IsFile() bool {
return m == Regular ||
m == Deprecated ||
m == Executable ||
m == Symlink
}
// ToOSFileMode returns the os.FileMode to be used when creating file
// system elements with the given git mode and a nil error on success.
//
// When the provided mode cannot be mapped to a valid file system mode
// (e.g. Submodule) it returns os.FileMode(0) and an error.
//
// The returned file mode does not take into account the umask.
func (m FileMode) ToOSFileMode() (os.FileMode, error) {
switch m {
case Dir:
return os.ModePerm | os.ModeDir, nil
case Submodule:
return os.ModePerm | os.ModeDir, nil
case Regular:
return os.FileMode(0644), nil
// Deprecated is no longer allowed: treated as a Regular instead
case Deprecated:
return os.FileMode(0644), nil
case Executable:
return os.FileMode(0755), nil
case Symlink:
return os.ModePerm | os.ModeSymlink, nil
}
return os.FileMode(0), fmt.Errorf("malformed mode (%s)", m)
}
go-git-5.13.2/plumbing/filemode/filemode_test.go 0000664 0000000 0000000 00000023305 14744245500 0021553 0 ustar 00root root 0000000 0000000 package filemode
import (
"os"
"testing"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type ModeSuite struct{}
var _ = Suite(&ModeSuite{})
func (s *ModeSuite) TestNew(c *C) {
for _, test := range [...]struct {
input string
expected FileMode
}{
// these are the ones used in the packfile codification
// of the tree entries
{input: "40000", expected: Dir},
{input: "100644", expected: Regular},
{input: "100664", expected: Deprecated},
{input: "100755", expected: Executable},
{input: "120000", expected: Symlink},
{input: "160000", expected: Submodule},
// these are are not used by standard git to codify modes in
// packfiles, but they often appear when parsing some git
// outputs ("git diff-tree", for instance).
{input: "000000", expected: Empty},
{input: "040000", expected: Dir},
// these are valid inputs, but probably means there is a bug
// somewhere.
{input: "0", expected: Empty},
{input: "42", expected: FileMode(042)},
{input: "00000000000100644", expected: Regular},
} {
comment := Commentf("input = %q", test.input)
obtained, err := New(test.input)
c.Assert(obtained, Equals, test.expected, comment)
c.Assert(err, IsNil, comment)
}
}
func (s *ModeSuite) TestNewErrors(c *C) {
for _, input := range [...]string{
"0x81a4", // Regular in hex
"-rw-r--r--", // Regular in default UNIX representation
"",
"-42",
"9", // this is no octal
"09", // looks like octal, but it is not
"mode",
"-100644",
"+100644",
} {
comment := Commentf("input = %q", input)
obtained, err := New(input)
c.Assert(obtained, Equals, Empty, comment)
c.Assert(err, Not(IsNil), comment)
}
}
// fixtures for testing NewModeFromOSFileMode
type fixture struct {
input os.FileMode
expected FileMode
err string // error regexp, empty string for nil error
}
func (f fixture) test(c *C) {
obtained, err := NewFromOSFileMode(f.input)
comment := Commentf("input = %s (%07o)", f.input, uint32(f.input))
c.Assert(obtained, Equals, f.expected, comment)
if f.err != "" {
c.Assert(err, ErrorMatches, f.err, comment)
} else {
c.Assert(err, IsNil, comment)
}
}
func (s *ModeSuite) TestNewFromOsFileModeSimplePerms(c *C) {
for _, f := range [...]fixture{
{os.FileMode(0755) | os.ModeDir, Dir, ""}, // drwxr-xr-x
{os.FileMode(0700) | os.ModeDir, Dir, ""}, // drwx------
{os.FileMode(0500) | os.ModeDir, Dir, ""}, // dr-x------
{os.FileMode(0644), Regular, ""}, // -rw-r--r--
{os.FileMode(0660), Regular, ""}, // -rw-rw----
{os.FileMode(0640), Regular, ""}, // -rw-r-----
{os.FileMode(0600), Regular, ""}, // -rw-------
{os.FileMode(0400), Regular, ""}, // -r--------
{os.FileMode(0000), Regular, ""}, // ----------
{os.FileMode(0755), Executable, ""}, // -rwxr-xr-x
{os.FileMode(0700), Executable, ""}, // -rwx------
{os.FileMode(0500), Executable, ""}, // -r-x------
{os.FileMode(0744), Executable, ""}, // -rwxr--r--
{os.FileMode(0540), Executable, ""}, // -r-xr-----
{os.FileMode(0550), Executable, ""}, // -r-xr-x---
{os.FileMode(0777) | os.ModeSymlink, Symlink, ""}, // Lrwxrwxrwx
} {
f.test(c)
}
}
func (s *ModeSuite) TestNewFromOsFileModeAppend(c *C) {
// append files are just regular files
fixture{
input: os.FileMode(0644) | os.ModeAppend, // arw-r--r--
expected: Regular, err: "",
}.test(c)
}
func (s *ModeSuite) TestNewFromOsFileModeExclusive(c *C) {
// exclusive files are just regular or executable files
fixture{
input: os.FileMode(0644) | os.ModeExclusive, // lrw-r--r--
expected: Regular, err: "",
}.test(c)
fixture{
input: os.FileMode(0755) | os.ModeExclusive, // lrwxr-xr-x
expected: Executable, err: "",
}.test(c)
}
func (s *ModeSuite) TestNewFromOsFileModeTemporary(c *C) {
// temporary files are ignored
fixture{
input: os.FileMode(0644) | os.ModeTemporary, // Trw-r--r--
expected: Empty, err: "no equivalent.*",
}.test(c)
fixture{
input: os.FileMode(0755) | os.ModeTemporary, // Trwxr-xr-x
expected: Empty, err: "no equivalent.*",
}.test(c)
}
func (s *ModeSuite) TestNewFromOsFileModeDevice(c *C) {
// device files has no git equivalent
fixture{
input: os.FileMode(0644) | os.ModeDevice, // Drw-r--r--
expected: Empty, err: "no equivalent.*",
}.test(c)
}
func (s *ModeSuite) TestNewFromOsFileNamedPipe(c *C) {
// named pipes files has not git equivalent
fixture{
input: os.FileMode(0644) | os.ModeNamedPipe, // prw-r--r--
expected: Empty, err: "no equivalent.*",
}.test(c)
}
func (s *ModeSuite) TestNewFromOsFileModeSocket(c *C) {
// sockets has no git equivalent
fixture{
input: os.FileMode(0644) | os.ModeSocket, // Srw-r--r--
expected: Empty, err: "no equivalent.*",
}.test(c)
}
func (s *ModeSuite) TestNewFromOsFileModeSetuid(c *C) {
// Setuid are just executables
fixture{
input: os.FileMode(0755) | os.ModeSetuid, // urwxr-xr-x
expected: Executable, err: "",
}.test(c)
}
func (s *ModeSuite) TestNewFromOsFileModeSetgid(c *C) {
// Setguid are regular or executables, depending on the owner perms
fixture{
input: os.FileMode(0644) | os.ModeSetgid, // grw-r--r--
expected: Regular, err: "",
}.test(c)
fixture{
input: os.FileMode(0755) | os.ModeSetgid, // grwxr-xr-x
expected: Executable, err: "",
}.test(c)
}
func (s *ModeSuite) TestNewFromOsFileModeCharDevice(c *C) {
// char devices has no git equivalent
fixture{
input: os.FileMode(0644) | os.ModeCharDevice, // crw-r--r--
expected: Empty, err: "no equivalent.*",
}.test(c)
}
func (s *ModeSuite) TestNewFromOsFileModeSticky(c *C) {
// dirs with the sticky bit are just dirs
fixture{
input: os.FileMode(0755) | os.ModeDir | os.ModeSticky, // dtrwxr-xr-x
expected: Dir, err: "",
}.test(c)
}
func (s *ModeSuite) TestByte(c *C) {
for _, test := range [...]struct {
input FileMode
expected []byte
}{
{FileMode(0), []byte{0x00, 0x00, 0x00, 0x00}},
{FileMode(1), []byte{0x01, 0x00, 0x00, 0x00}},
{FileMode(15), []byte{0x0f, 0x00, 0x00, 0x00}},
{FileMode(16), []byte{0x10, 0x00, 0x00, 0x00}},
{FileMode(255), []byte{0xff, 0x00, 0x00, 0x00}},
{FileMode(256), []byte{0x00, 0x01, 0x00, 0x00}},
{Empty, []byte{0x00, 0x00, 0x00, 0x00}},
{Dir, []byte{0x00, 0x40, 0x00, 0x00}},
{Regular, []byte{0xa4, 0x81, 0x00, 0x00}},
{Deprecated, []byte{0xb4, 0x81, 0x00, 0x00}},
{Executable, []byte{0xed, 0x81, 0x00, 0x00}},
{Symlink, []byte{0x00, 0xa0, 0x00, 0x00}},
{Submodule, []byte{0x00, 0xe0, 0x00, 0x00}},
} {
c.Assert(test.input.Bytes(), DeepEquals, test.expected,
Commentf("input = %s", test.input))
}
}
func (s *ModeSuite) TestIsMalformed(c *C) {
for _, test := range [...]struct {
mode FileMode
expected bool
}{
{Empty, true},
{Dir, false},
{Regular, false},
{Deprecated, false},
{Executable, false},
{Symlink, false},
{Submodule, false},
{FileMode(01), true},
{FileMode(010), true},
{FileMode(0100), true},
{FileMode(01000), true},
{FileMode(010000), true},
{FileMode(0100000), true},
} {
c.Assert(test.mode.IsMalformed(), Equals, test.expected)
}
}
func (s *ModeSuite) TestString(c *C) {
for _, test := range [...]struct {
mode FileMode
expected string
}{
{Empty, "0000000"},
{Dir, "0040000"},
{Regular, "0100644"},
{Deprecated, "0100664"},
{Executable, "0100755"},
{Symlink, "0120000"},
{Submodule, "0160000"},
{FileMode(01), "0000001"},
{FileMode(010), "0000010"},
{FileMode(0100), "0000100"},
{FileMode(01000), "0001000"},
{FileMode(010000), "0010000"},
{FileMode(0100000), "0100000"},
} {
c.Assert(test.mode.String(), Equals, test.expected)
}
}
func (s *ModeSuite) TestIsRegular(c *C) {
for _, test := range [...]struct {
mode FileMode
expected bool
}{
{Empty, false},
{Dir, false},
{Regular, true},
{Deprecated, true},
{Executable, false},
{Symlink, false},
{Submodule, false},
{FileMode(01), false},
{FileMode(010), false},
{FileMode(0100), false},
{FileMode(01000), false},
{FileMode(010000), false},
{FileMode(0100000), false},
} {
c.Assert(test.mode.IsRegular(), Equals, test.expected)
}
}
func (s *ModeSuite) TestIsFile(c *C) {
for _, test := range [...]struct {
mode FileMode
expected bool
}{
{Empty, false},
{Dir, false},
{Regular, true},
{Deprecated, true},
{Executable, true},
{Symlink, true},
{Submodule, false},
{FileMode(01), false},
{FileMode(010), false},
{FileMode(0100), false},
{FileMode(01000), false},
{FileMode(010000), false},
{FileMode(0100000), false},
} {
c.Assert(test.mode.IsFile(), Equals, test.expected)
}
}
func (s *ModeSuite) TestToOSFileMode(c *C) {
for _, test := range [...]struct {
input FileMode
expected os.FileMode
errRegExp string // empty string for nil error
}{
{Empty, os.FileMode(0), "malformed.*"},
{Dir, os.ModePerm | os.ModeDir, ""},
{Regular, os.FileMode(0644), ""},
{Deprecated, os.FileMode(0644), ""},
{Executable, os.FileMode(0755), ""},
{Symlink, os.ModePerm | os.ModeSymlink, ""},
{Submodule, os.ModePerm | os.ModeDir, ""},
{FileMode(01), os.FileMode(0), "malformed.*"},
{FileMode(010), os.FileMode(0), "malformed.*"},
{FileMode(0100), os.FileMode(0), "malformed.*"},
{FileMode(01000), os.FileMode(0), "malformed.*"},
{FileMode(010000), os.FileMode(0), "malformed.*"},
{FileMode(0100000), os.FileMode(0), "malformed.*"},
} {
obtained, err := test.input.ToOSFileMode()
comment := Commentf("input = %s", test.input)
if test.errRegExp != "" {
c.Assert(obtained, Equals, os.FileMode(0), comment)
c.Assert(err, ErrorMatches, test.errRegExp, comment)
} else {
c.Assert(obtained, Equals, test.expected, comment)
c.Assert(err, IsNil, comment)
}
}
}
go-git-5.13.2/plumbing/format/ 0000775 0000000 0000000 00000000000 14744245500 0016102 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/format/commitgraph/ 0000775 0000000 0000000 00000000000 14744245500 0020414 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/format/commitgraph/commitgraph.go 0000664 0000000 0000000 00000003010 14744245500 0023247 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"time"
"github.com/go-git/go-git/v5/plumbing"
)
// CommitData is a reduced representation of Commit as presented in the commit graph
// file. It is merely useful as an optimization for walking the commit graphs.
//
// Deprecated: This package uses the wrong types for Generation and Index in CommitData.
// Use the v2 package instead.
type CommitData struct {
// TreeHash is the hash of the root tree of the commit.
TreeHash plumbing.Hash
// ParentIndexes are the indexes of the parent commits of the commit.
ParentIndexes []int
// ParentHashes are the hashes of the parent commits of the commit.
ParentHashes []plumbing.Hash
// Generation number is the pre-computed generation in the commit graph
// or zero if not available
Generation int
// When is the timestamp of the commit.
When time.Time
}
// Index represents a representation of commit graph that allows indexed
// access to the nodes using commit object hash
//
// Deprecated: This package uses the wrong types for Generation and Index in CommitData.
// Use the v2 package instead.
type Index interface {
// GetIndexByHash gets the index in the commit graph from commit hash, if available
GetIndexByHash(h plumbing.Hash) (int, error)
// GetNodeByIndex gets the commit node from the commit graph using index
// obtained from child node, if available
GetCommitDataByIndex(i int) (*CommitData, error)
// Hashes returns all the hashes that are available in the index
Hashes() []plumbing.Hash
}
go-git-5.13.2/plumbing/format/commitgraph/commitgraph_test.go 0000664 0000000 0000000 00000011014 14744245500 0024311 0 ustar 00root root 0000000 0000000 package commitgraph_test
import (
"os"
"testing"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/util"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/commitgraph"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type CommitgraphSuite struct {
fixtures.Suite
}
var _ = Suite(&CommitgraphSuite{})
func testDecodeHelper(c *C, fs billy.Filesystem, path string) {
reader, err := fs.Open(path)
c.Assert(err, IsNil)
defer reader.Close()
index, err := commitgraph.OpenFileIndex(reader)
c.Assert(err, IsNil)
// Root commit
nodeIndex, err := index.GetIndexByHash(plumbing.NewHash("347c91919944a68e9413581a1bc15519550a3afe"))
c.Assert(err, IsNil)
commitData, err := index.GetCommitDataByIndex(nodeIndex)
c.Assert(err, IsNil)
c.Assert(len(commitData.ParentIndexes), Equals, 0)
c.Assert(len(commitData.ParentHashes), Equals, 0)
// Regular commit
nodeIndex, err = index.GetIndexByHash(plumbing.NewHash("e713b52d7e13807e87a002e812041f248db3f643"))
c.Assert(err, IsNil)
commitData, err = index.GetCommitDataByIndex(nodeIndex)
c.Assert(err, IsNil)
c.Assert(len(commitData.ParentIndexes), Equals, 1)
c.Assert(len(commitData.ParentHashes), Equals, 1)
c.Assert(commitData.ParentHashes[0].String(), Equals, "347c91919944a68e9413581a1bc15519550a3afe")
// Merge commit
nodeIndex, err = index.GetIndexByHash(plumbing.NewHash("b29328491a0682c259bcce28741eac71f3499f7d"))
c.Assert(err, IsNil)
commitData, err = index.GetCommitDataByIndex(nodeIndex)
c.Assert(err, IsNil)
c.Assert(len(commitData.ParentIndexes), Equals, 2)
c.Assert(len(commitData.ParentHashes), Equals, 2)
c.Assert(commitData.ParentHashes[0].String(), Equals, "e713b52d7e13807e87a002e812041f248db3f643")
c.Assert(commitData.ParentHashes[1].String(), Equals, "03d2c021ff68954cf3ef0a36825e194a4b98f981")
// Octopus merge commit
nodeIndex, err = index.GetIndexByHash(plumbing.NewHash("6f6c5d2be7852c782be1dd13e36496dd7ad39560"))
c.Assert(err, IsNil)
commitData, err = index.GetCommitDataByIndex(nodeIndex)
c.Assert(err, IsNil)
c.Assert(len(commitData.ParentIndexes), Equals, 3)
c.Assert(len(commitData.ParentHashes), Equals, 3)
c.Assert(commitData.ParentHashes[0].String(), Equals, "ce275064ad67d51e99f026084e20827901a8361c")
c.Assert(commitData.ParentHashes[1].String(), Equals, "bb13916df33ed23004c3ce9ed3b8487528e655c1")
c.Assert(commitData.ParentHashes[2].String(), Equals, "a45273fe2d63300e1962a9e26a6b15c276cd7082")
// Check all hashes
hashes := index.Hashes()
c.Assert(len(hashes), Equals, 11)
c.Assert(hashes[0].String(), Equals, "03d2c021ff68954cf3ef0a36825e194a4b98f981")
c.Assert(hashes[10].String(), Equals, "e713b52d7e13807e87a002e812041f248db3f643")
}
func (s *CommitgraphSuite) TestDecode(c *C) {
fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) {
dotgit := f.DotGit()
testDecodeHelper(c, dotgit, dotgit.Join("objects", "info", "commit-graph"))
})
}
func (s *CommitgraphSuite) TestReencode(c *C) {
fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) {
dotgit := f.DotGit()
reader, err := dotgit.Open(dotgit.Join("objects", "info", "commit-graph"))
c.Assert(err, IsNil)
defer reader.Close()
index, err := commitgraph.OpenFileIndex(reader)
c.Assert(err, IsNil)
writer, err := util.TempFile(dotgit, "", "commit-graph")
c.Assert(err, IsNil)
tmpName := writer.Name()
defer os.Remove(tmpName)
encoder := commitgraph.NewEncoder(writer)
err = encoder.Encode(index)
c.Assert(err, IsNil)
writer.Close()
testDecodeHelper(c, dotgit, tmpName)
})
}
func (s *CommitgraphSuite) TestReencodeInMemory(c *C) {
fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) {
dotgit := f.DotGit()
reader, err := dotgit.Open(dotgit.Join("objects", "info", "commit-graph"))
c.Assert(err, IsNil)
index, err := commitgraph.OpenFileIndex(reader)
c.Assert(err, IsNil)
memoryIndex := commitgraph.NewMemoryIndex()
for i, hash := range index.Hashes() {
commitData, err := index.GetCommitDataByIndex(i)
c.Assert(err, IsNil)
memoryIndex.Add(hash, commitData)
}
reader.Close()
writer, err := util.TempFile(dotgit, "", "commit-graph")
c.Assert(err, IsNil)
tmpName := writer.Name()
defer os.Remove(tmpName)
encoder := commitgraph.NewEncoder(writer)
err = encoder.Encode(memoryIndex)
c.Assert(err, IsNil)
writer.Close()
testDecodeHelper(c, dotgit, tmpName)
})
}
go-git-5.13.2/plumbing/format/commitgraph/doc.go 0000664 0000000 0000000 00000010425 14744245500 0021512 0 ustar 00root root 0000000 0000000 // Package commitgraph implements encoding and decoding of commit-graph files.
//
// Deprecated: This package uses the wrong types for Generation and Index in CommitData.
// Use the v2 package instead.
//
// Git commit graph format
// =======================
//
// The Git commit graph stores a list of commit OIDs and some associated
// metadata, including:
//
// - The generation number of the commit. Commits with no parents have
// generation number 1; commits with parents have generation number
// one more than the maximum generation number of its parents. We
// reserve zero as special, and can be used to mark a generation
// number invalid or as "not computed".
//
// - The root tree OID.
//
// - The commit date.
//
// - The parents of the commit, stored using positional references within
// the graph file.
//
// These positional references are stored as unsigned 32-bit integers
// corresponding to the array position within the list of commit OIDs. Due
// to some special constants we use to track parents, we can store at most
// (1 << 30) + (1 << 29) + (1 << 28) - 1 (around 1.8 billion) commits.
//
// == Commit graph files have the following format:
//
// In order to allow extensions that add extra data to the graph, we organize
// the body into "chunks" and provide a binary lookup table at the beginning
// of the body. The header includes certain values, such as number of chunks
// and hash type.
//
// All 4-byte numbers are in network order.
//
// HEADER:
//
// 4-byte signature:
// The signature is: {'C', 'G', 'P', 'H'}
//
// 1-byte version number:
// Currently, the only valid version is 1.
//
// 1-byte Hash Version (1 = SHA-1)
// We infer the hash length (H) from this value.
//
// 1-byte number (C) of "chunks"
//
// 1-byte (reserved for later use)
// Current clients should ignore this value.
//
// CHUNK LOOKUP:
//
// (C + 1) * 12 bytes listing the table of contents for the chunks:
// First 4 bytes describe the chunk id. Value 0 is a terminating label.
// Other 8 bytes provide the byte-offset in current file for chunk to
// start. (Chunks are ordered contiguously in the file, so you can infer
// the length using the next chunk position if necessary.) Each chunk
// ID appears at most once.
//
// The remaining data in the body is described one chunk at a time, and
// these chunks may be given in any order. Chunks are required unless
// otherwise specified.
//
// CHUNK DATA:
//
// OID Fanout (ID: {'O', 'I', 'D', 'F'}) (256 * 4 bytes)
// The ith entry, F[i], stores the number of OIDs with first
// byte at most i. Thus F[255] stores the total
// number of commits (N).
//
// OID Lookup (ID: {'O', 'I', 'D', 'L'}) (N * H bytes)
// The OIDs for all commits in the graph, sorted in ascending order.
//
// Commit Data (ID: {'C', 'D', 'A', 'T' }) (N * (H + 16) bytes)
// * The first H bytes are for the OID of the root tree.
// * The next 8 bytes are for the positions of the first two parents
// of the ith commit. Stores value 0x7000000 if no parent in that
// position. If there are more than two parents, the second value
// has its most-significant bit on and the other bits store an array
// position into the Extra Edge List chunk.
// * The next 8 bytes store the generation number of the commit and
// the commit time in seconds since EPOCH. The generation number
// uses the higher 30 bits of the first 4 bytes, while the commit
// time uses the 32 bits of the second 4 bytes, along with the lowest
// 2 bits of the lowest byte, storing the 33rd and 34th bit of the
// commit time.
//
// Extra Edge List (ID: {'E', 'D', 'G', 'E'}) [Optional]
// This list of 4-byte values store the second through nth parents for
// all octopus merges. The second parent value in the commit data stores
// an array position within this list along with the most-significant bit
// on. Starting at that array position, iterate through this list of commit
// positions for the parents until reaching a value with the most-significant
// bit on. The other bits correspond to the position of the last parent.
//
// TRAILER:
//
// H-byte HASH-checksum of all of the above.
//
// Source:
// https://raw.githubusercontent.com/git/git/master/Documentation/technical/commit-graph-format.txt
package commitgraph
go-git-5.13.2/plumbing/format/commitgraph/encoder.go 0000664 0000000 0000000 00000013260 14744245500 0022364 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"crypto"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/utils/binary"
)
// Encoder writes MemoryIndex structs to an output stream.
//
// Deprecated: This package uses the wrong types for Generation and Index in CommitData.
// Use the v2 package instead.
type Encoder struct {
io.Writer
hash hash.Hash
}
// NewEncoder returns a new stream encoder that writes to w.
//
// Deprecated: This package uses the wrong types for Generation and Index in CommitData.
// Use the v2 package instead.
func NewEncoder(w io.Writer) *Encoder {
h := hash.New(hash.CryptoType)
mw := io.MultiWriter(w, h)
return &Encoder{mw, h}
}
// Encode writes an index into the commit-graph file
//
// Deprecated: This package uses the wrong types for Generation and Index in CommitData.
// Use the v2 package instead.
func (e *Encoder) Encode(idx Index) error {
// Get all the hashes in the input index
hashes := idx.Hashes()
// Sort the inout and prepare helper structures we'll need for encoding
hashToIndex, fanout, extraEdgesCount := e.prepare(idx, hashes)
chunkSignatures := [][]byte{oidFanoutSignature, oidLookupSignature, commitDataSignature}
chunkSizes := []uint64{4 * 256, uint64(len(hashes)) * hash.Size, uint64(len(hashes)) * (hash.Size + commitDataSize)}
if extraEdgesCount > 0 {
chunkSignatures = append(chunkSignatures, extraEdgeListSignature)
chunkSizes = append(chunkSizes, uint64(extraEdgesCount)*4)
}
if err := e.encodeFileHeader(len(chunkSignatures)); err != nil {
return err
}
if err := e.encodeChunkHeaders(chunkSignatures, chunkSizes); err != nil {
return err
}
if err := e.encodeFanout(fanout); err != nil {
return err
}
if err := e.encodeOidLookup(hashes); err != nil {
return err
}
if extraEdges, err := e.encodeCommitData(hashes, hashToIndex, idx); err == nil {
if err = e.encodeExtraEdges(extraEdges); err != nil {
return err
}
} else {
return err
}
return e.encodeChecksum()
}
func (e *Encoder) prepare(idx Index, hashes []plumbing.Hash) (hashToIndex map[plumbing.Hash]uint32, fanout []uint32, extraEdgesCount uint32) {
// Sort the hashes and build our index
plumbing.HashesSort(hashes)
hashToIndex = make(map[plumbing.Hash]uint32)
fanout = make([]uint32, 256)
for i, hash := range hashes {
hashToIndex[hash] = uint32(i)
fanout[hash[0]]++
}
// Convert the fanout to cumulative values
for i := 1; i <= 0xff; i++ {
fanout[i] += fanout[i-1]
}
// Find out if we will need extra edge table
for i := 0; i < len(hashes); i++ {
v, _ := idx.GetCommitDataByIndex(i)
if len(v.ParentHashes) > 2 {
extraEdgesCount += uint32(len(v.ParentHashes) - 1)
break
}
}
return
}
func (e *Encoder) encodeFileHeader(chunkCount int) (err error) {
if _, err = e.Write(commitFileSignature); err == nil {
version := byte(1)
if hash.CryptoType == crypto.SHA256 {
version = byte(2)
}
_, err = e.Write([]byte{1, version, byte(chunkCount), 0})
}
return
}
func (e *Encoder) encodeChunkHeaders(chunkSignatures [][]byte, chunkSizes []uint64) (err error) {
// 8 bytes of file header, 12 bytes for each chunk header and 12 byte for terminator
offset := uint64(8 + len(chunkSignatures)*12 + 12)
for i, signature := range chunkSignatures {
if _, err = e.Write(signature); err == nil {
err = binary.WriteUint64(e, offset)
}
if err != nil {
return
}
offset += chunkSizes[i]
}
if _, err = e.Write(lastSignature); err == nil {
err = binary.WriteUint64(e, offset)
}
return
}
func (e *Encoder) encodeFanout(fanout []uint32) (err error) {
for i := 0; i <= 0xff; i++ {
if err = binary.WriteUint32(e, fanout[i]); err != nil {
return
}
}
return
}
func (e *Encoder) encodeOidLookup(hashes []plumbing.Hash) (err error) {
for _, hash := range hashes {
if _, err = e.Write(hash[:]); err != nil {
return err
}
}
return
}
func (e *Encoder) encodeCommitData(hashes []plumbing.Hash, hashToIndex map[plumbing.Hash]uint32, idx Index) (extraEdges []uint32, err error) {
for _, hash := range hashes {
origIndex, _ := idx.GetIndexByHash(hash)
commitData, _ := idx.GetCommitDataByIndex(origIndex)
if _, err = e.Write(commitData.TreeHash[:]); err != nil {
return
}
var parent1, parent2 uint32
if len(commitData.ParentHashes) == 0 {
parent1 = parentNone
parent2 = parentNone
} else if len(commitData.ParentHashes) == 1 {
parent1 = hashToIndex[commitData.ParentHashes[0]]
parent2 = parentNone
} else if len(commitData.ParentHashes) == 2 {
parent1 = hashToIndex[commitData.ParentHashes[0]]
parent2 = hashToIndex[commitData.ParentHashes[1]]
} else if len(commitData.ParentHashes) > 2 {
parent1 = hashToIndex[commitData.ParentHashes[0]]
parent2 = uint32(len(extraEdges)) | parentOctopusUsed
for _, parentHash := range commitData.ParentHashes[1:] {
extraEdges = append(extraEdges, hashToIndex[parentHash])
}
extraEdges[len(extraEdges)-1] |= parentLast
}
if err = binary.WriteUint32(e, parent1); err == nil {
err = binary.WriteUint32(e, parent2)
}
if err != nil {
return
}
unixTime := uint64(commitData.When.Unix())
unixTime |= uint64(commitData.Generation) << 34
if err = binary.WriteUint64(e, unixTime); err != nil {
return
}
}
return
}
func (e *Encoder) encodeExtraEdges(extraEdges []uint32) (err error) {
for _, parent := range extraEdges {
if err = binary.WriteUint32(e, parent); err != nil {
return
}
}
return
}
func (e *Encoder) encodeChecksum() error {
_, err := e.Write(e.hash.Sum(nil)[:hash.Size])
return err
}
go-git-5.13.2/plumbing/format/commitgraph/file.go 0000664 0000000 0000000 00000017043 14744245500 0021667 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"bytes"
"crypto"
encbin "encoding/binary"
"errors"
"io"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/utils/binary"
)
// Deprecated: This package uses the wrong types for Generation and Index in CommitData.
// Use the v2 package instead.
var (
// ErrUnsupportedVersion is returned by OpenFileIndex when the commit graph
// file version is not supported.
ErrUnsupportedVersion = errors.New("unsupported version")
// ErrUnsupportedHash is returned by OpenFileIndex when the commit graph
// hash function is not supported. Currently only SHA-1 is defined and
// supported
ErrUnsupportedHash = errors.New("unsupported hash algorithm")
// ErrMalformedCommitGraphFile is returned by OpenFileIndex when the commit
// graph file is corrupted.
ErrMalformedCommitGraphFile = errors.New("malformed commit graph file")
commitFileSignature = []byte{'C', 'G', 'P', 'H'}
oidFanoutSignature = []byte{'O', 'I', 'D', 'F'}
oidLookupSignature = []byte{'O', 'I', 'D', 'L'}
commitDataSignature = []byte{'C', 'D', 'A', 'T'}
extraEdgeListSignature = []byte{'E', 'D', 'G', 'E'}
lastSignature = []byte{0, 0, 0, 0}
parentNone = uint32(0x70000000)
parentOctopusUsed = uint32(0x80000000)
parentOctopusMask = uint32(0x7fffffff)
parentLast = uint32(0x80000000)
)
const commitDataSize = 16
type fileIndex struct {
reader io.ReaderAt
fanout [256]int
oidFanoutOffset int64
oidLookupOffset int64
commitDataOffset int64
extraEdgeListOffset int64
}
// OpenFileIndex opens a serialized commit graph file in the format described at
// https://github.com/git/git/blob/master/Documentation/technical/commit-graph-format.txt
//
// Deprecated: This package uses the wrong types for Generation and Index in CommitData.
// Use the v2 package instead.
func OpenFileIndex(reader io.ReaderAt) (Index, error) {
fi := &fileIndex{reader: reader}
if err := fi.verifyFileHeader(); err != nil {
return nil, err
}
if err := fi.readChunkHeaders(); err != nil {
return nil, err
}
if err := fi.readFanout(); err != nil {
return nil, err
}
return fi, nil
}
func (fi *fileIndex) verifyFileHeader() error {
// Verify file signature
signature := make([]byte, 4)
if _, err := fi.reader.ReadAt(signature, 0); err != nil {
return err
}
if !bytes.Equal(signature, commitFileSignature) {
return ErrMalformedCommitGraphFile
}
// Read and verify the file header
header := make([]byte, 4)
if _, err := fi.reader.ReadAt(header, 4); err != nil {
return err
}
if header[0] != 1 {
return ErrUnsupportedVersion
}
if hash.CryptoType == crypto.SHA1 {
if header[1] != 1 {
return ErrUnsupportedVersion
}
} else if hash.CryptoType == crypto.SHA256 {
if header[1] != 2 {
return ErrUnsupportedVersion
}
} else {
// Unknown hash type
return ErrUnsupportedVersion
}
return nil
}
func (fi *fileIndex) readChunkHeaders() error {
chunkID := make([]byte, 4)
for i := 0; ; i++ {
chunkHeader := io.NewSectionReader(fi.reader, 8+(int64(i)*12), 12)
if _, err := io.ReadAtLeast(chunkHeader, chunkID, 4); err != nil {
return err
}
chunkOffset, err := binary.ReadUint64(chunkHeader)
if err != nil {
return err
}
if bytes.Equal(chunkID, oidFanoutSignature) {
fi.oidFanoutOffset = int64(chunkOffset)
} else if bytes.Equal(chunkID, oidLookupSignature) {
fi.oidLookupOffset = int64(chunkOffset)
} else if bytes.Equal(chunkID, commitDataSignature) {
fi.commitDataOffset = int64(chunkOffset)
} else if bytes.Equal(chunkID, extraEdgeListSignature) {
fi.extraEdgeListOffset = int64(chunkOffset)
} else if bytes.Equal(chunkID, lastSignature) {
break
}
}
if fi.oidFanoutOffset <= 0 || fi.oidLookupOffset <= 0 || fi.commitDataOffset <= 0 {
return ErrMalformedCommitGraphFile
}
return nil
}
func (fi *fileIndex) readFanout() error {
fanoutReader := io.NewSectionReader(fi.reader, fi.oidFanoutOffset, 256*4)
for i := 0; i < 256; i++ {
fanoutValue, err := binary.ReadUint32(fanoutReader)
if err != nil {
return err
}
if fanoutValue > 0x7fffffff {
return ErrMalformedCommitGraphFile
}
fi.fanout[i] = int(fanoutValue)
}
return nil
}
func (fi *fileIndex) GetIndexByHash(h plumbing.Hash) (int, error) {
var oid plumbing.Hash
// Find the hash in the oid lookup table
var low int
if h[0] == 0 {
low = 0
} else {
low = fi.fanout[h[0]-1]
}
high := fi.fanout[h[0]]
for low < high {
mid := (low + high) >> 1
offset := fi.oidLookupOffset + int64(mid)*hash.Size
if _, err := fi.reader.ReadAt(oid[:], offset); err != nil {
return 0, err
}
cmp := bytes.Compare(h[:], oid[:])
if cmp < 0 {
high = mid
} else if cmp == 0 {
return mid, nil
} else {
low = mid + 1
}
}
return 0, plumbing.ErrObjectNotFound
}
func (fi *fileIndex) GetCommitDataByIndex(idx int) (*CommitData, error) {
if idx >= fi.fanout[0xff] {
return nil, plumbing.ErrObjectNotFound
}
offset := fi.commitDataOffset + int64(idx)*(hash.Size+commitDataSize)
commitDataReader := io.NewSectionReader(fi.reader, offset, hash.Size+commitDataSize)
treeHash, err := binary.ReadHash(commitDataReader)
if err != nil {
return nil, err
}
parent1, err := binary.ReadUint32(commitDataReader)
if err != nil {
return nil, err
}
parent2, err := binary.ReadUint32(commitDataReader)
if err != nil {
return nil, err
}
genAndTime, err := binary.ReadUint64(commitDataReader)
if err != nil {
return nil, err
}
var parentIndexes []int
if parent2&parentOctopusUsed == parentOctopusUsed {
// Octopus merge
parentIndexes = []int{int(parent1 & parentOctopusMask)}
offset := fi.extraEdgeListOffset + 4*int64(parent2&parentOctopusMask)
buf := make([]byte, 4)
for {
_, err := fi.reader.ReadAt(buf, offset)
if err != nil {
return nil, err
}
parent := encbin.BigEndian.Uint32(buf)
offset += 4
parentIndexes = append(parentIndexes, int(parent&parentOctopusMask))
if parent&parentLast == parentLast {
break
}
}
} else if parent2 != parentNone {
parentIndexes = []int{int(parent1 & parentOctopusMask), int(parent2 & parentOctopusMask)}
} else if parent1 != parentNone {
parentIndexes = []int{int(parent1 & parentOctopusMask)}
}
parentHashes, err := fi.getHashesFromIndexes(parentIndexes)
if err != nil {
return nil, err
}
return &CommitData{
TreeHash: treeHash,
ParentIndexes: parentIndexes,
ParentHashes: parentHashes,
Generation: int(genAndTime >> 34),
When: time.Unix(int64(genAndTime&0x3FFFFFFFF), 0),
}, nil
}
func (fi *fileIndex) getHashesFromIndexes(indexes []int) ([]plumbing.Hash, error) {
hashes := make([]plumbing.Hash, len(indexes))
for i, idx := range indexes {
if idx >= fi.fanout[0xff] {
return nil, ErrMalformedCommitGraphFile
}
offset := fi.oidLookupOffset + int64(idx)*hash.Size
if _, err := fi.reader.ReadAt(hashes[i][:], offset); err != nil {
return nil, err
}
}
return hashes, nil
}
// Hashes returns all the hashes that are available in the index
func (fi *fileIndex) Hashes() []plumbing.Hash {
hashes := make([]plumbing.Hash, fi.fanout[0xff])
for i := 0; i < fi.fanout[0xff]; i++ {
offset := fi.oidLookupOffset + int64(i)*hash.Size
if n, err := fi.reader.ReadAt(hashes[i][:], offset); err != nil || n < hash.Size {
return nil
}
}
return hashes
}
go-git-5.13.2/plumbing/format/commitgraph/memory.go 0000664 0000000 0000000 00000004442 14744245500 0022257 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"github.com/go-git/go-git/v5/plumbing"
)
// MemoryIndex provides a way to build the commit-graph in memory
// for later encoding to file.
//
// Deprecated: This package uses the wrong types for Generation and Index in CommitData.
// Use the v2 package instead.
type MemoryIndex struct {
commitData []*CommitData
indexMap map[plumbing.Hash]int
}
// NewMemoryIndex creates in-memory commit graph representation
//
// Deprecated: This package uses the wrong types for Generation and Index in CommitData.
// Use the v2 package instead.
func NewMemoryIndex() *MemoryIndex {
return &MemoryIndex{
indexMap: make(map[plumbing.Hash]int),
}
}
// GetIndexByHash gets the index in the commit graph from commit hash, if available
func (mi *MemoryIndex) GetIndexByHash(h plumbing.Hash) (int, error) {
i, ok := mi.indexMap[h]
if ok {
return i, nil
}
return 0, plumbing.ErrObjectNotFound
}
// GetCommitDataByIndex gets the commit node from the commit graph using index
// obtained from child node, if available
func (mi *MemoryIndex) GetCommitDataByIndex(i int) (*CommitData, error) {
if i >= len(mi.commitData) {
return nil, plumbing.ErrObjectNotFound
}
commitData := mi.commitData[i]
// Map parent hashes to parent indexes
if commitData.ParentIndexes == nil {
parentIndexes := make([]int, len(commitData.ParentHashes))
for i, parentHash := range commitData.ParentHashes {
var err error
if parentIndexes[i], err = mi.GetIndexByHash(parentHash); err != nil {
return nil, err
}
}
commitData.ParentIndexes = parentIndexes
}
return commitData, nil
}
// Hashes returns all the hashes that are available in the index
func (mi *MemoryIndex) Hashes() []plumbing.Hash {
hashes := make([]plumbing.Hash, 0, len(mi.indexMap))
for k := range mi.indexMap {
hashes = append(hashes, k)
}
return hashes
}
// Add adds new node to the memory index
func (mi *MemoryIndex) Add(hash plumbing.Hash, commitData *CommitData) {
// The parent indexes are calculated lazily in GetNodeByIndex
// which allows adding nodes out of order as long as all parents
// are eventually resolved
commitData.ParentIndexes = nil
mi.indexMap[hash] = len(mi.commitData)
mi.commitData = append(mi.commitData, commitData)
}
go-git-5.13.2/plumbing/format/commitgraph/v2/ 0000775 0000000 0000000 00000000000 14744245500 0020743 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/format/commitgraph/v2/chain.go 0000664 0000000 0000000 00000005321 14744245500 0022355 0 ustar 00root root 0000000 0000000 package v2
import (
"bufio"
"io"
"path"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-git/v5/plumbing"
)
// OpenChainFile reads a commit chain file and returns a slice of the hashes within it
//
// Commit-Graph chains are described at https://git-scm.com/docs/commit-graph
// and are new line separated list of graph file hashes, oldest to newest.
//
// This function simply reads the file and returns the hashes as a slice.
func OpenChainFile(r io.Reader) ([]string, error) {
if r == nil {
return nil, io.ErrUnexpectedEOF
}
bufRd := bufio.NewReader(r)
chain := make([]string, 0, 8)
for {
line, err := bufRd.ReadSlice('\n')
if err != nil {
if err == io.EOF {
break
}
return nil, err
}
hashStr := string(line[:len(line)-1])
if !plumbing.IsHash(hashStr) {
return nil, ErrMalformedCommitGraphFile
}
chain = append(chain, hashStr)
}
return chain, nil
}
// OpenChainOrFileIndex expects a billy.Filesystem representing a .git directory.
// It will first attempt to read a commit-graph index file, before trying to read a
// commit-graph chain file and its index files. If neither are present, an error is returned.
// Otherwise an Index will be returned.
//
// See: https://git-scm.com/docs/commit-graph
func OpenChainOrFileIndex(fs billy.Filesystem) (Index, error) {
file, err := fs.Open(path.Join("objects", "info", "commit-graph"))
if err != nil {
// try to open a chain file
return OpenChainIndex(fs)
}
index, err := OpenFileIndex(file)
if err != nil {
// Ignore any file closing errors and return the error from OpenFileIndex instead
_ = file.Close()
return nil, err
}
return index, nil
}
// OpenChainIndex expects a billy.Filesystem representing a .git directory.
// It will read a commit-graph chain file and return a coalesced index.
// If the chain file or a graph in that chain is not present, an error is returned.
//
// See: https://git-scm.com/docs/commit-graph
func OpenChainIndex(fs billy.Filesystem) (Index, error) {
chainFile, err := fs.Open(path.Join("objects", "info", "commit-graphs", "commit-graph-chain"))
if err != nil {
return nil, err
}
chain, err := OpenChainFile(chainFile)
_ = chainFile.Close()
if err != nil {
return nil, err
}
var index Index
for _, hash := range chain {
file, err := fs.Open(path.Join("objects", "info", "commit-graphs", "graph-"+hash+".graph"))
if err != nil {
// Ignore all other file closing errors and return the error from opening the last file in the graph
_ = index.Close()
return nil, err
}
index, err = OpenFileIndexWithParent(file, index)
if err != nil {
// Ignore file closing errors and return the error from OpenFileIndex instead
_ = index.Close()
return nil, err
}
}
return index, nil
}
go-git-5.13.2/plumbing/format/commitgraph/v2/chain_test.go 0000664 0000000 0000000 00000010000 14744245500 0023402 0 ustar 00root root 0000000 0000000 package v2_test
import (
"bytes"
"crypto"
"strings"
commitgraph "github.com/go-git/go-git/v5/plumbing/format/commitgraph/v2"
"github.com/go-git/go-git/v5/plumbing/hash"
. "gopkg.in/check.v1"
)
func (s *CommitgraphSuite) TestOpenChainFile(c *C) {
sha1Data := []string{
"c336d16298a017486c4164c40f8acb28afe64e84",
"31eae7b619d166c366bf5df4991f04ba8cebea0a",
"b977a025ca21e3b5ca123d8093bd7917694f6da7",
"d2a38b4a5965d529566566640519d03d2bd10f6c",
"35b585759cbf29f8ec428ef89da20705d59f99ec",
"c2bbf9fe8009b22d0f390f3c8c3f13937067590f",
"fc9f0643b21cfe571046e27e0c4565f3a1ee96c8",
"c088fd6a7e1a38e9d5a9815265cb575bb08d08ff",
"5fddbeb678bd2c36c5e5c891ab8f2b143ced5baf",
"5d7303c49ac984a9fec60523f2d5297682e16646",
}
sha256Data := []string{
"b9efda7160f2647e0974ca623f8a8f8e25fb6944f1b8f78f4db1bf07932de8eb",
"7095c59f8bf46e12c21d2d9da344cfe383fae18d26f3ae4d4ab7b71e3d0ddfae",
"25a395cb62f7656294e40a001ee19fefcdf3013d265dfcf4b744cd2549891dec",
"7fbd564813a82227507d9dd70f1fd21fc1f180223cd3f42e0c3090c9a8b6a7d0",
"aa95db1db2df91bd7200a892dd1c03bc2704c4793400d016b3ca08c148b0f7c1",
"2176988184b570565dc33823a02f474ad59f667a0e971c86063a7fea64776a87",
"d0afc0e64171140eb7902110f807a1beaa38a603d4312fd4bd14a5db2784ba62",
"2822136f60bfc58bbd9d624cc19fbef9f0fc0efe2a61729242e1e5f9b77fa3d0",
"6f207b5c43463af96bc38c43b0bf45275fa327e656a8bba8e7fc55c5ab6870d8",
"6cf33782619b6ff0af9c081e46323f423f8b49bf3d043887c0549bef47d60f55",
"60ea0753d2d4e828983528294be3f57e2a3ba37df4f59e3236133c9e2b17afc5",
"6b3c9f4ba5092e0807774097953ec6e9f58e8371d775bd8738a0fa98d728ba3d",
"c97cab8564054e30515dbe67dda4e14638aabf17b3f042d18dc8461cd098b362",
"9f7ece76fd2c9dae08e75176347efffc1446ad74af66004dd34680edb205dfb5",
"23e7a7e481b00571b63c2a7d0432f9733dd85d18a9841a3d7b96743100da5824",
"e684b1253fa8eb6572f35bab2fd3b6efecabf8472ede43497cd9c171973cc341",
"8b9f04080b0c40f7ad2a6bb5e5296cd6c06e730dffce87a0375ae7bd0f85f86e",
"384a745f3b14edc89526a98b96b3247b2b548541c755aadee7664352ed7f12ae",
"b68c8a82cd5b839917e1058570a0408819b81d16dbab81db118cc8dfc3def044",
"fbaf04f1a401335be57e172f4326102c658d857fde6cf2bc987520d11fc99770",
"57acf2aa5ac736337b120c951536c8a2b2cb23a4f0f198e86f3433370fa63105",
"dd7fcba4c13b6ced0b6190cdb5861adcd08446a92d67f7ec0f02f9533e09bbb0",
"744ef481c9b13ebd3b6e43d7e9ba25f7c7a5c8e453e6f0d50f5d71aae1591689",
"2c573142f1edd52b64dcd42a9c3b0ca5c9c615f757d80d25bfb02ff3eb2257e2",
"ea65cc58ef8520cd0335de4318a0d3b3a1ac257b7e9f82e12483fa3bce6cc0cd",
"1dfa626ff1523b82e21a4c29476edcdc9a89842f3c7181f63a28cd4f46cc9923",
"aa1153e71af836121e6f6cc716cf64880c19221d8dc367ff42359de1b8ef30e9",
"a7c6ec6f6569e22d2fa6e8281639d27c59b633ea00ad8ef27a43171cc985fbda",
"627b706d63d2cfd5a388deeaa76655ef09146fe492ee17cb0043578cef9c2800",
"d40eaf091ef8357b734d1047a552436eaf057d99a0c6f2068b097c324099d360",
"87f0ef81641da4fd3438dcaae4819f0c92a0ade54e262b21f9ded4575ff3f234",
"3a00a29e08d29454b5197662f70ccab5699b0ce8c85af7fbf511b8915d97cfd0",
}
goodShas := sha1Data
badShas := sha256Data
if hash.CryptoType == crypto.SHA256 {
goodShas = sha256Data
badShas = sha1Data
}
chainData := strings.Join(goodShas, "\n") + "\n"
chainReader := strings.NewReader(chainData)
chain, err := commitgraph.OpenChainFile(chainReader)
c.Assert(err, IsNil)
c.Assert(goodShas, DeepEquals, chain)
// Test with bad shas
chainData = strings.Join(badShas, "\n") + "\n"
chainReader = strings.NewReader(chainData)
chain, err = commitgraph.OpenChainFile(chainReader)
c.Assert(err, Equals, commitgraph.ErrMalformedCommitGraphFile)
c.Assert(chain, IsNil)
// Test with empty file
emptyChainReader := bytes.NewReader(nil)
chain, err = commitgraph.OpenChainFile(emptyChainReader)
c.Assert(err, IsNil)
c.Assert(chain, DeepEquals, []string{})
// Test with file containing only newlines
newlineChainData := []byte("\n\n\n")
newlineChainReader := bytes.NewReader(newlineChainData)
chain, err = commitgraph.OpenChainFile(newlineChainReader)
c.Assert(err, Equals, commitgraph.ErrMalformedCommitGraphFile)
c.Assert(chain, IsNil)
}
go-git-5.13.2/plumbing/format/commitgraph/v2/chunk.go 0000664 0000000 0000000 00000004233 14744245500 0022404 0 ustar 00root root 0000000 0000000 package v2
import "bytes"
const (
szChunkSig = 4 // Length of a chunk signature
chunkSigOffset = 4 // Offset of each chunk signature in chunkSignatures
)
// chunkSignatures contains the coalesced byte signatures for each chunk type.
// The order of the signatures must match the order of the ChunkType constants.
// (When adding new chunk types you must avoid introducing ambiguity, and you may need to add padding separators to this list or reorder these signatures.)
// (i.e. it would not be possible to add a new chunk type with the signature "IDFO" without some reordering or the addition of separators.)
var chunkSignatures = []byte("OIDFOIDLCDATGDA2GDO2EDGEBIDXBDATBASE\000\000\000\000")
// ChunkType represents the type of a chunk in the commit graph file.
type ChunkType int
const (
OIDFanoutChunk ChunkType = iota // "OIDF"
OIDLookupChunk // "OIDL"
CommitDataChunk // "CDAT"
GenerationDataChunk // "GDA2"
GenerationDataOverflowChunk // "GDO2"
ExtraEdgeListChunk // "EDGE"
BloomFilterIndexChunk // "BIDX"
BloomFilterDataChunk // "BDAT"
BaseGraphsListChunk // "BASE"
ZeroChunk // "\000\000\000\000"
)
const lenChunks = int(ZeroChunk) // ZeroChunk is not a valid chunk type, but it is used to determine the length of the chunk type list.
// Signature returns the byte signature for the chunk type.
func (ct ChunkType) Signature() []byte {
if ct >= BaseGraphsListChunk || ct < 0 { // not a valid chunk type just return ZeroChunk
return chunkSignatures[ZeroChunk*chunkSigOffset : ZeroChunk*chunkSigOffset+szChunkSig]
}
return chunkSignatures[ct*chunkSigOffset : ct*chunkSigOffset+szChunkSig]
}
// ChunkTypeFromBytes returns the chunk type for the given byte signature.
func ChunkTypeFromBytes(b []byte) (ChunkType, bool) {
idx := bytes.Index(chunkSignatures, b)
if idx == -1 || idx%chunkSigOffset != 0 { // not found, or not aligned at chunkSigOffset
return -1, false
}
return ChunkType(idx / chunkSigOffset), true
}
go-git-5.13.2/plumbing/format/commitgraph/v2/commitgraph.go 0000664 0000000 0000000 00000004055 14744245500 0023610 0 ustar 00root root 0000000 0000000 package v2
import (
"io"
"math"
"time"
"github.com/go-git/go-git/v5/plumbing"
)
// CommitData is a reduced representation of Commit as presented in the commit graph
// file. It is merely useful as an optimization for walking the commit graphs.
type CommitData struct {
// TreeHash is the hash of the root tree of the commit.
TreeHash plumbing.Hash
// ParentIndexes are the indexes of the parent commits of the commit.
ParentIndexes []uint32
// ParentHashes are the hashes of the parent commits of the commit.
ParentHashes []plumbing.Hash
// Generation number is the pre-computed generation in the commit graph
// or zero if not available.
Generation uint64
// GenerationV2 stores the corrected commit date for the commits
// It combines the contents of the GDA2 and GDO2 sections of the commit-graph
// with the commit time portion of the CDAT section.
GenerationV2 uint64
// When is the timestamp of the commit.
When time.Time
}
// GenerationV2Data returns the corrected commit date for the commits
func (c *CommitData) GenerationV2Data() uint64 {
if c.GenerationV2 == 0 || c.GenerationV2 == math.MaxUint64 {
return 0
}
return c.GenerationV2 - uint64(c.When.Unix())
}
// Index represents a representation of commit graph that allows indexed
// access to the nodes using commit object hash
type Index interface {
// GetIndexByHash gets the index in the commit graph from commit hash, if available
GetIndexByHash(h plumbing.Hash) (uint32, error)
// GetHashByIndex gets the hash given an index in the commit graph
GetHashByIndex(i uint32) (plumbing.Hash, error)
// GetNodeByIndex gets the commit node from the commit graph using index
// obtained from child node, if available
GetCommitDataByIndex(i uint32) (*CommitData, error)
// Hashes returns all the hashes that are available in the index
Hashes() []plumbing.Hash
// HasGenerationV2 returns true if the commit graph has the corrected commit date data
HasGenerationV2() bool
// MaximumNumberOfHashes returns the maximum number of hashes within the index
MaximumNumberOfHashes() uint32
io.Closer
}
go-git-5.13.2/plumbing/format/commitgraph/v2/commitgraph_test.go 0000664 0000000 0000000 00000015143 14744245500 0024647 0 ustar 00root root 0000000 0000000 package v2_test
import (
"os"
"testing"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/util"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
commitgraph "github.com/go-git/go-git/v5/plumbing/format/commitgraph/v2"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/storage/filesystem"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type CommitgraphSuite struct {
fixtures.Suite
}
var _ = Suite(&CommitgraphSuite{})
func testReadIndex(c *C, fs billy.Filesystem, path string) commitgraph.Index {
reader, err := fs.Open(path)
c.Assert(err, IsNil)
index, err := commitgraph.OpenFileIndex(reader)
c.Assert(err, IsNil)
c.Assert(index, NotNil)
return index
}
func testDecodeHelper(c *C, index commitgraph.Index) {
// Root commit
nodeIndex, err := index.GetIndexByHash(plumbing.NewHash("347c91919944a68e9413581a1bc15519550a3afe"))
c.Assert(err, IsNil)
commitData, err := index.GetCommitDataByIndex(nodeIndex)
c.Assert(err, IsNil)
c.Assert(len(commitData.ParentIndexes), Equals, 0)
c.Assert(len(commitData.ParentHashes), Equals, 0)
// Regular commit
nodeIndex, err = index.GetIndexByHash(plumbing.NewHash("e713b52d7e13807e87a002e812041f248db3f643"))
c.Assert(err, IsNil)
commitData, err = index.GetCommitDataByIndex(nodeIndex)
c.Assert(err, IsNil)
c.Assert(len(commitData.ParentIndexes), Equals, 1)
c.Assert(len(commitData.ParentHashes), Equals, 1)
c.Assert(commitData.ParentHashes[0].String(), Equals, "347c91919944a68e9413581a1bc15519550a3afe")
// Merge commit
nodeIndex, err = index.GetIndexByHash(plumbing.NewHash("b29328491a0682c259bcce28741eac71f3499f7d"))
c.Assert(err, IsNil)
commitData, err = index.GetCommitDataByIndex(nodeIndex)
c.Assert(err, IsNil)
c.Assert(len(commitData.ParentIndexes), Equals, 2)
c.Assert(len(commitData.ParentHashes), Equals, 2)
c.Assert(commitData.ParentHashes[0].String(), Equals, "e713b52d7e13807e87a002e812041f248db3f643")
c.Assert(commitData.ParentHashes[1].String(), Equals, "03d2c021ff68954cf3ef0a36825e194a4b98f981")
// Octopus merge commit
nodeIndex, err = index.GetIndexByHash(plumbing.NewHash("6f6c5d2be7852c782be1dd13e36496dd7ad39560"))
c.Assert(err, IsNil)
commitData, err = index.GetCommitDataByIndex(nodeIndex)
c.Assert(err, IsNil)
c.Assert(len(commitData.ParentIndexes), Equals, 3)
c.Assert(len(commitData.ParentHashes), Equals, 3)
c.Assert(commitData.ParentHashes[0].String(), Equals, "ce275064ad67d51e99f026084e20827901a8361c")
c.Assert(commitData.ParentHashes[1].String(), Equals, "bb13916df33ed23004c3ce9ed3b8487528e655c1")
c.Assert(commitData.ParentHashes[2].String(), Equals, "a45273fe2d63300e1962a9e26a6b15c276cd7082")
// Check all hashes
hashes := index.Hashes()
c.Assert(len(hashes), Equals, 11)
c.Assert(hashes[0].String(), Equals, "03d2c021ff68954cf3ef0a36825e194a4b98f981")
c.Assert(hashes[10].String(), Equals, "e713b52d7e13807e87a002e812041f248db3f643")
}
func (s *CommitgraphSuite) TestDecodeMultiChain(c *C) {
fixtures.ByTag("commit-graph-chain-2").Test(c, func(f *fixtures.Fixture) {
dotgit := f.DotGit()
index, err := commitgraph.OpenChainOrFileIndex(dotgit)
c.Assert(err, IsNil)
defer index.Close()
storer := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
p := f.Packfile()
defer p.Close()
packfile.UpdateObjectStorage(storer, p)
for idx, hash := range index.Hashes() {
idx2, err := index.GetIndexByHash(hash)
c.Assert(err, IsNil)
c.Assert(idx2, Equals, uint32(idx))
hash2, err := index.GetHashByIndex(idx2)
c.Assert(err, IsNil)
c.Assert(hash2.String(), Equals, hash.String())
commitData, err := index.GetCommitDataByIndex(uint32(idx))
c.Assert(err, IsNil)
commit, err := object.GetCommit(storer, hash)
c.Assert(err, IsNil)
for i, parent := range commit.ParentHashes {
c.Assert(hash.String()+":"+parent.String(), Equals, hash.String()+":"+commitData.ParentHashes[i].String())
}
}
})
}
func (s *CommitgraphSuite) TestDecode(c *C) {
fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) {
dotgit := f.DotGit()
index := testReadIndex(c, dotgit, dotgit.Join("objects", "info", "commit-graph"))
defer index.Close()
testDecodeHelper(c, index)
})
}
func (s *CommitgraphSuite) TestDecodeChain(c *C) {
fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) {
dotgit := f.DotGit()
index, err := commitgraph.OpenChainOrFileIndex(dotgit)
c.Assert(err, IsNil)
defer index.Close()
testDecodeHelper(c, index)
})
fixtures.ByTag("commit-graph-chain").Test(c, func(f *fixtures.Fixture) {
dotgit := f.DotGit()
index, err := commitgraph.OpenChainOrFileIndex(dotgit)
c.Assert(err, IsNil)
defer index.Close()
testDecodeHelper(c, index)
})
}
func (s *CommitgraphSuite) TestReencode(c *C) {
fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) {
dotgit := f.DotGit()
reader, err := dotgit.Open(dotgit.Join("objects", "info", "commit-graph"))
c.Assert(err, IsNil)
defer reader.Close()
index, err := commitgraph.OpenFileIndex(reader)
c.Assert(err, IsNil)
defer index.Close()
writer, err := util.TempFile(dotgit, "", "commit-graph")
c.Assert(err, IsNil)
tmpName := writer.Name()
defer os.Remove(tmpName)
encoder := commitgraph.NewEncoder(writer)
err = encoder.Encode(index)
c.Assert(err, IsNil)
writer.Close()
tmpIndex := testReadIndex(c, dotgit, tmpName)
defer tmpIndex.Close()
testDecodeHelper(c, tmpIndex)
})
}
func (s *CommitgraphSuite) TestReencodeInMemory(c *C) {
fixtures.ByTag("commit-graph").Test(c, func(f *fixtures.Fixture) {
dotgit := f.DotGit()
reader, err := dotgit.Open(dotgit.Join("objects", "info", "commit-graph"))
c.Assert(err, IsNil)
index, err := commitgraph.OpenFileIndex(reader)
c.Assert(err, IsNil)
memoryIndex := commitgraph.NewMemoryIndex()
defer memoryIndex.Close()
for i, hash := range index.Hashes() {
commitData, err := index.GetCommitDataByIndex(uint32(i))
c.Assert(err, IsNil)
memoryIndex.Add(hash, commitData)
}
index.Close()
writer, err := util.TempFile(dotgit, "", "commit-graph")
c.Assert(err, IsNil)
tmpName := writer.Name()
defer os.Remove(tmpName)
encoder := commitgraph.NewEncoder(writer)
err = encoder.Encode(memoryIndex)
c.Assert(err, IsNil)
writer.Close()
tmpIndex := testReadIndex(c, dotgit, tmpName)
defer tmpIndex.Close()
testDecodeHelper(c, tmpIndex)
})
}
go-git-5.13.2/plumbing/format/commitgraph/v2/doc.go 0000664 0000000 0000000 00000010367 14744245500 0022046 0 ustar 00root root 0000000 0000000 // Package v2 implements encoding and decoding of commit-graph files.
//
// This package was created to work around the issues of the incorrect types in
// the commitgraph package.
//
// Git commit graph format
// =======================
//
// The Git commit graph stores a list of commit OIDs and some associated
// metadata, including:
//
// - The generation number of the commit. Commits with no parents have
// generation number 1; commits with parents have generation number
// one more than the maximum generation number of its parents. We
// reserve zero as special, and can be used to mark a generation
// number invalid or as "not computed".
//
// - The root tree OID.
//
// - The commit date.
//
// - The parents of the commit, stored using positional references within
// the graph file.
//
// These positional references are stored as unsigned 32-bit integers
// corresponding to the array position within the list of commit OIDs. Due
// to some special constants we use to track parents, we can store at most
// (1 << 30) + (1 << 29) + (1 << 28) - 1 (around 1.8 billion) commits.
//
// == Commit graph files have the following format:
//
// In order to allow extensions that add extra data to the graph, we organize
// the body into "chunks" and provide a binary lookup table at the beginning
// of the body. The header includes certain values, such as number of chunks
// and hash type.
//
// All 4-byte numbers are in network order.
//
// HEADER:
//
// 4-byte signature:
// The signature is: {'C', 'G', 'P', 'H'}
//
// 1-byte version number:
// Currently, the only valid version is 1.
//
// 1-byte Hash Version (1 = SHA-1)
// We infer the hash length (H) from this value.
//
// 1-byte number (C) of "chunks"
//
// 1-byte (reserved for later use)
// Current clients should ignore this value.
//
// CHUNK LOOKUP:
//
// (C + 1) * 12 bytes listing the table of contents for the chunks:
// First 4 bytes describe the chunk id. Value 0 is a terminating label.
// Other 8 bytes provide the byte-offset in current file for chunk to
// start. (Chunks are ordered contiguously in the file, so you can infer
// the length using the next chunk position if necessary.) Each chunk
// ID appears at most once.
//
// The remaining data in the body is described one chunk at a time, and
// these chunks may be given in any order. Chunks are required unless
// otherwise specified.
//
// CHUNK DATA:
//
// OID Fanout (ID: {'O', 'I', 'D', 'F'}) (256 * 4 bytes)
// The ith entry, F[i], stores the number of OIDs with first
// byte at most i. Thus F[255] stores the total
// number of commits (N).
//
// OID Lookup (ID: {'O', 'I', 'D', 'L'}) (N * H bytes)
// The OIDs for all commits in the graph, sorted in ascending order.
//
// Commit Data (ID: {'C', 'D', 'A', 'T' }) (N * (H + 16) bytes)
// * The first H bytes are for the OID of the root tree.
// * The next 8 bytes are for the positions of the first two parents
// of the ith commit. Stores value 0x7000000 if no parent in that
// position. If there are more than two parents, the second value
// has its most-significant bit on and the other bits store an array
// position into the Extra Edge List chunk.
// * The next 8 bytes store the generation number of the commit and
// the commit time in seconds since EPOCH. The generation number
// uses the higher 30 bits of the first 4 bytes, while the commit
// time uses the 32 bits of the second 4 bytes, along with the lowest
// 2 bits of the lowest byte, storing the 33rd and 34th bit of the
// commit time.
//
// Extra Edge List (ID: {'E', 'D', 'G', 'E'}) [Optional]
// This list of 4-byte values store the second through nth parents for
// all octopus merges. The second parent value in the commit data stores
// an array position within this list along with the most-significant bit
// on. Starting at that array position, iterate through this list of commit
// positions for the parents until reaching a value with the most-significant
// bit on. The other bits correspond to the position of the last parent.
//
// TRAILER:
//
// H-byte HASH-checksum of all of the above.
//
// Source:
// https://raw.githubusercontent.com/git/git/master/Documentation/technical/commit-graph-format.txt
package v2
go-git-5.13.2/plumbing/format/commitgraph/v2/encoder.go 0000664 0000000 0000000 00000015610 14744245500 0022714 0 ustar 00root root 0000000 0000000 package v2
import (
"crypto"
"io"
"math"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/utils/binary"
)
// Encoder writes MemoryIndex structs to an output stream.
type Encoder struct {
io.Writer
hash hash.Hash
}
// NewEncoder returns a new stream encoder that writes to w.
func NewEncoder(w io.Writer) *Encoder {
h := hash.New(hash.CryptoType)
mw := io.MultiWriter(w, h)
return &Encoder{mw, h}
}
// Encode writes an index into the commit-graph file
func (e *Encoder) Encode(idx Index) error {
// Get all the hashes in the input index
hashes := idx.Hashes()
// Sort the inout and prepare helper structures we'll need for encoding
hashToIndex, fanout, extraEdgesCount, generationV2OverflowCount := e.prepare(idx, hashes)
chunkSignatures := [][]byte{OIDFanoutChunk.Signature(), OIDLookupChunk.Signature(), CommitDataChunk.Signature()}
chunkSizes := []uint64{szUint32 * lenFanout, uint64(len(hashes)) * hash.Size, uint64(len(hashes)) * (hash.Size + szCommitData)}
if extraEdgesCount > 0 {
chunkSignatures = append(chunkSignatures, ExtraEdgeListChunk.Signature())
chunkSizes = append(chunkSizes, uint64(extraEdgesCount)*szUint32)
}
if idx.HasGenerationV2() {
chunkSignatures = append(chunkSignatures, GenerationDataChunk.Signature())
chunkSizes = append(chunkSizes, uint64(len(hashes))*szUint32)
if generationV2OverflowCount > 0 {
chunkSignatures = append(chunkSignatures, GenerationDataOverflowChunk.Signature())
chunkSizes = append(chunkSizes, uint64(generationV2OverflowCount)*szUint64)
}
}
if err := e.encodeFileHeader(len(chunkSignatures)); err != nil {
return err
}
if err := e.encodeChunkHeaders(chunkSignatures, chunkSizes); err != nil {
return err
}
if err := e.encodeFanout(fanout); err != nil {
return err
}
if err := e.encodeOidLookup(hashes); err != nil {
return err
}
extraEdges, generationV2Data, err := e.encodeCommitData(hashes, hashToIndex, idx)
if err != nil {
return err
}
if err = e.encodeExtraEdges(extraEdges); err != nil {
return err
}
if idx.HasGenerationV2() {
overflows, err := e.encodeGenerationV2Data(generationV2Data)
if err != nil {
return err
}
if err = e.encodeGenerationV2Overflow(overflows); err != nil {
return err
}
}
return e.encodeChecksum()
}
func (e *Encoder) prepare(idx Index, hashes []plumbing.Hash) (hashToIndex map[plumbing.Hash]uint32, fanout []uint32, extraEdgesCount uint32, generationV2OverflowCount uint32) {
// Sort the hashes and build our index
plumbing.HashesSort(hashes)
hashToIndex = make(map[plumbing.Hash]uint32)
fanout = make([]uint32, lenFanout)
for i, hash := range hashes {
hashToIndex[hash] = uint32(i)
fanout[hash[0]]++
}
// Convert the fanout to cumulative values
for i := 1; i < lenFanout; i++ {
fanout[i] += fanout[i-1]
}
hasGenerationV2 := idx.HasGenerationV2()
// Find out if we will need extra edge table
for i := 0; i < len(hashes); i++ {
v, _ := idx.GetCommitDataByIndex(uint32(i))
if len(v.ParentHashes) > 2 {
extraEdgesCount += uint32(len(v.ParentHashes) - 1)
}
if hasGenerationV2 && v.GenerationV2Data() > math.MaxUint32 {
generationV2OverflowCount++
}
}
return
}
func (e *Encoder) encodeFileHeader(chunkCount int) (err error) {
if _, err = e.Write(commitFileSignature); err == nil {
version := byte(1)
if hash.CryptoType == crypto.SHA256 {
version = byte(2)
}
_, err = e.Write([]byte{1, version, byte(chunkCount), 0})
}
return
}
func (e *Encoder) encodeChunkHeaders(chunkSignatures [][]byte, chunkSizes []uint64) (err error) {
// 8 bytes of file header, 12 bytes for each chunk header and 12 byte for terminator
offset := uint64(szSignature + szHeader + (len(chunkSignatures)+1)*(szChunkSig+szUint64))
for i, signature := range chunkSignatures {
if _, err = e.Write(signature); err == nil {
err = binary.WriteUint64(e, offset)
}
if err != nil {
return
}
offset += chunkSizes[i]
}
if _, err = e.Write(ZeroChunk.Signature()); err == nil {
err = binary.WriteUint64(e, offset)
}
return
}
func (e *Encoder) encodeFanout(fanout []uint32) (err error) {
for i := 0; i <= 0xff; i++ {
if err = binary.WriteUint32(e, fanout[i]); err != nil {
return
}
}
return
}
func (e *Encoder) encodeOidLookup(hashes []plumbing.Hash) (err error) {
for _, hash := range hashes {
if _, err = e.Write(hash[:]); err != nil {
return err
}
}
return
}
func (e *Encoder) encodeCommitData(hashes []plumbing.Hash, hashToIndex map[plumbing.Hash]uint32, idx Index) (extraEdges []uint32, generationV2Data []uint64, err error) {
if idx.HasGenerationV2() {
generationV2Data = make([]uint64, 0, len(hashes))
}
for _, hash := range hashes {
origIndex, _ := idx.GetIndexByHash(hash)
commitData, _ := idx.GetCommitDataByIndex(origIndex)
if _, err = e.Write(commitData.TreeHash[:]); err != nil {
return
}
var parent1, parent2 uint32
if len(commitData.ParentHashes) == 0 {
parent1 = parentNone
parent2 = parentNone
} else if len(commitData.ParentHashes) == 1 {
parent1 = hashToIndex[commitData.ParentHashes[0]]
parent2 = parentNone
} else if len(commitData.ParentHashes) == 2 {
parent1 = hashToIndex[commitData.ParentHashes[0]]
parent2 = hashToIndex[commitData.ParentHashes[1]]
} else if len(commitData.ParentHashes) > 2 {
parent1 = hashToIndex[commitData.ParentHashes[0]]
parent2 = uint32(len(extraEdges)) | parentOctopusUsed
for _, parentHash := range commitData.ParentHashes[1:] {
extraEdges = append(extraEdges, hashToIndex[parentHash])
}
extraEdges[len(extraEdges)-1] |= parentLast
}
if err = binary.WriteUint32(e, parent1); err == nil {
err = binary.WriteUint32(e, parent2)
}
if err != nil {
return
}
unixTime := uint64(commitData.When.Unix())
unixTime |= uint64(commitData.Generation) << 34
if err = binary.WriteUint64(e, unixTime); err != nil {
return
}
if generationV2Data != nil {
generationV2Data = append(generationV2Data, commitData.GenerationV2Data())
}
}
return
}
func (e *Encoder) encodeExtraEdges(extraEdges []uint32) (err error) {
for _, parent := range extraEdges {
if err = binary.WriteUint32(e, parent); err != nil {
return
}
}
return
}
func (e *Encoder) encodeGenerationV2Data(generationV2Data []uint64) (overflows []uint64, err error) {
head := 0
for _, data := range generationV2Data {
if data >= 0x80000000 {
// overflow
if err = binary.WriteUint32(e, uint32(head)|0x80000000); err != nil {
return nil, err
}
generationV2Data[head] = data
head++
continue
}
if err = binary.WriteUint32(e, uint32(data)); err != nil {
return nil, err
}
}
return generationV2Data[:head], nil
}
func (e *Encoder) encodeGenerationV2Overflow(overflows []uint64) (err error) {
for _, overflow := range overflows {
if err = binary.WriteUint64(e, overflow); err != nil {
return
}
}
return
}
func (e *Encoder) encodeChecksum() error {
_, err := e.Write(e.hash.Sum(nil)[:hash.Size])
return err
}
go-git-5.13.2/plumbing/format/commitgraph/v2/file.go 0000664 0000000 0000000 00000026123 14744245500 0022215 0 ustar 00root root 0000000 0000000 package v2
import (
"bytes"
"crypto"
encbin "encoding/binary"
"errors"
"io"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/utils/binary"
)
var (
// ErrUnsupportedVersion is returned by OpenFileIndex when the commit graph
// file version is not supported.
ErrUnsupportedVersion = errors.New("unsupported version")
// ErrUnsupportedHash is returned by OpenFileIndex when the commit graph
// hash function is not supported. Currently only SHA-1 is defined and
// supported.
ErrUnsupportedHash = errors.New("unsupported hash algorithm")
// ErrMalformedCommitGraphFile is returned by OpenFileIndex when the commit
// graph file is corrupted.
ErrMalformedCommitGraphFile = errors.New("malformed commit graph file")
commitFileSignature = []byte{'C', 'G', 'P', 'H'}
parentNone = uint32(0x70000000)
parentOctopusUsed = uint32(0x80000000)
parentOctopusMask = uint32(0x7fffffff)
parentLast = uint32(0x80000000)
)
const (
szUint32 = 4
szUint64 = 8
szSignature = 4
szHeader = 4
szCommitData = 2*szUint32 + szUint64
lenFanout = 256
)
type fileIndex struct {
reader ReaderAtCloser
fanout [lenFanout]uint32
offsets [lenChunks]int64
parent Index
hasGenerationV2 bool
minimumNumberOfHashes uint32
}
// ReaderAtCloser is an interface that combines io.ReaderAt and io.Closer.
type ReaderAtCloser interface {
io.ReaderAt
io.Closer
}
// OpenFileIndex opens a serialized commit graph file in the format described at
// https://github.com/git/git/blob/master/Documentation/technical/commit-graph-format.txt
func OpenFileIndex(reader ReaderAtCloser) (Index, error) {
return OpenFileIndexWithParent(reader, nil)
}
// OpenFileIndexWithParent opens a serialized commit graph file in the format described at
// https://github.com/git/git/blob/master/Documentation/technical/commit-graph-format.txt
func OpenFileIndexWithParent(reader ReaderAtCloser, parent Index) (Index, error) {
if reader == nil {
return nil, io.ErrUnexpectedEOF
}
fi := &fileIndex{reader: reader, parent: parent}
if err := fi.verifyFileHeader(); err != nil {
return nil, err
}
if err := fi.readChunkHeaders(); err != nil {
return nil, err
}
if err := fi.readFanout(); err != nil {
return nil, err
}
fi.hasGenerationV2 = fi.offsets[GenerationDataChunk] > 0
if fi.parent != nil {
fi.hasGenerationV2 = fi.hasGenerationV2 && fi.parent.HasGenerationV2()
}
if fi.parent != nil {
fi.minimumNumberOfHashes = fi.parent.MaximumNumberOfHashes()
}
return fi, nil
}
// Close closes the underlying reader and the parent index if it exists.
func (fi *fileIndex) Close() (err error) {
if fi.parent != nil {
defer func() {
parentErr := fi.parent.Close()
// only report the error from the parent if there is no error from the reader
if err == nil {
err = parentErr
}
}()
}
err = fi.reader.Close()
return
}
func (fi *fileIndex) verifyFileHeader() error {
// Verify file signature
signature := make([]byte, szSignature)
if _, err := fi.reader.ReadAt(signature, 0); err != nil {
return err
}
if !bytes.Equal(signature, commitFileSignature) {
return ErrMalformedCommitGraphFile
}
// Read and verify the file header
header := make([]byte, szHeader)
if _, err := fi.reader.ReadAt(header, szHeader); err != nil {
return err
}
if header[0] != 1 {
return ErrUnsupportedVersion
}
if !(hash.CryptoType == crypto.SHA1 && header[1] == 1) &&
!(hash.CryptoType == crypto.SHA256 && header[1] == 2) {
// Unknown hash type / unsupported hash type
return ErrUnsupportedHash
}
return nil
}
func (fi *fileIndex) readChunkHeaders() error {
// The chunk table is a list of 4-byte chunk signatures and uint64 offsets into the file
chunkID := make([]byte, szChunkSig)
for i := 0; ; i++ {
chunkHeader := io.NewSectionReader(fi.reader, szSignature+szHeader+(int64(i)*(szChunkSig+szUint64)), szChunkSig+szUint64)
if _, err := io.ReadAtLeast(chunkHeader, chunkID, szChunkSig); err != nil {
return err
}
chunkOffset, err := binary.ReadUint64(chunkHeader)
if err != nil {
return err
}
chunkType, ok := ChunkTypeFromBytes(chunkID)
if !ok {
continue
}
if chunkType == ZeroChunk || int(chunkType) >= len(fi.offsets) {
break
}
fi.offsets[chunkType] = int64(chunkOffset)
}
if fi.offsets[OIDFanoutChunk] <= 0 || fi.offsets[OIDLookupChunk] <= 0 || fi.offsets[CommitDataChunk] <= 0 {
return ErrMalformedCommitGraphFile
}
return nil
}
func (fi *fileIndex) readFanout() error {
// The Fanout table is a 256 entry table of the number (as uint32) of OIDs with first byte at most i.
// Thus F[255] stores the total number of commits (N)
fanoutReader := io.NewSectionReader(fi.reader, fi.offsets[OIDFanoutChunk], lenFanout*szUint32)
for i := 0; i < 256; i++ {
fanoutValue, err := binary.ReadUint32(fanoutReader)
if err != nil {
return err
}
if fanoutValue > 0x7fffffff {
return ErrMalformedCommitGraphFile
}
fi.fanout[i] = fanoutValue
}
return nil
}
// GetIndexByHash looks up the provided hash in the commit-graph fanout and returns the index of the commit data for the given hash.
func (fi *fileIndex) GetIndexByHash(h plumbing.Hash) (uint32, error) {
var oid plumbing.Hash
// Find the hash in the oid lookup table
var low uint32
if h[0] == 0 {
low = 0
} else {
low = fi.fanout[h[0]-1]
}
high := fi.fanout[h[0]]
for low < high {
mid := (low + high) >> 1
offset := fi.offsets[OIDLookupChunk] + int64(mid)*hash.Size
if _, err := fi.reader.ReadAt(oid[:], offset); err != nil {
return 0, err
}
cmp := bytes.Compare(h[:], oid[:])
if cmp < 0 {
high = mid
} else if cmp == 0 {
return mid + fi.minimumNumberOfHashes, nil
} else {
low = mid + 1
}
}
if fi.parent != nil {
idx, err := fi.parent.GetIndexByHash(h)
if err != nil {
return 0, err
}
return idx, nil
}
return 0, plumbing.ErrObjectNotFound
}
// GetCommitDataByIndex returns the commit data for the given index in the commit-graph.
func (fi *fileIndex) GetCommitDataByIndex(idx uint32) (*CommitData, error) {
if idx < fi.minimumNumberOfHashes {
if fi.parent != nil {
data, err := fi.parent.GetCommitDataByIndex(idx)
if err != nil {
return nil, err
}
return data, nil
}
return nil, plumbing.ErrObjectNotFound
}
idx -= fi.minimumNumberOfHashes
if idx >= fi.fanout[0xff] {
return nil, plumbing.ErrObjectNotFound
}
offset := fi.offsets[CommitDataChunk] + int64(idx)*(hash.Size+szCommitData)
commitDataReader := io.NewSectionReader(fi.reader, offset, hash.Size+szCommitData)
treeHash, err := binary.ReadHash(commitDataReader)
if err != nil {
return nil, err
}
parent1, err := binary.ReadUint32(commitDataReader)
if err != nil {
return nil, err
}
parent2, err := binary.ReadUint32(commitDataReader)
if err != nil {
return nil, err
}
genAndTime, err := binary.ReadUint64(commitDataReader)
if err != nil {
return nil, err
}
var parentIndexes []uint32
if parent2&parentOctopusUsed == parentOctopusUsed {
// Octopus merge - Look-up the extra parents from the extra edge list
// The extra edge list is a list of uint32s, each of which is an index into the Commit Data table, terminated by a index with the most significant bit on.
parentIndexes = []uint32{parent1 & parentOctopusMask}
offset := fi.offsets[ExtraEdgeListChunk] + szUint32*int64(parent2&parentOctopusMask)
buf := make([]byte, szUint32)
for {
_, err := fi.reader.ReadAt(buf, offset)
if err != nil {
return nil, err
}
parent := encbin.BigEndian.Uint32(buf)
offset += szUint32
parentIndexes = append(parentIndexes, parent&parentOctopusMask)
if parent&parentLast == parentLast {
break
}
}
} else if parent2 != parentNone {
parentIndexes = []uint32{parent1 & parentOctopusMask, parent2 & parentOctopusMask}
} else if parent1 != parentNone {
parentIndexes = []uint32{parent1 & parentOctopusMask}
}
parentHashes, err := fi.getHashesFromIndexes(parentIndexes)
if err != nil {
return nil, err
}
generationV2 := uint64(0)
if fi.hasGenerationV2 {
// set the GenerationV2 result to the commit time
generationV2 = uint64(genAndTime & 0x3FFFFFFFF)
// Next read the generation (offset) data from the generation data chunk
offset := fi.offsets[GenerationDataChunk] + int64(idx)*szUint32
buf := make([]byte, szUint32)
if _, err := fi.reader.ReadAt(buf, offset); err != nil {
return nil, err
}
genV2Data := encbin.BigEndian.Uint32(buf)
// check if the data is an overflow that needs to be looked up in the overflow chunk
if genV2Data&0x80000000 > 0 {
// Overflow
offset := fi.offsets[GenerationDataOverflowChunk] + int64(genV2Data&0x7fffffff)*szUint64
buf := make([]byte, 8)
if _, err := fi.reader.ReadAt(buf, offset); err != nil {
return nil, err
}
generationV2 += encbin.BigEndian.Uint64(buf)
} else {
generationV2 += uint64(genV2Data)
}
}
return &CommitData{
TreeHash: treeHash,
ParentIndexes: parentIndexes,
ParentHashes: parentHashes,
Generation: genAndTime >> 34,
GenerationV2: generationV2,
When: time.Unix(int64(genAndTime&0x3FFFFFFFF), 0),
}, nil
}
// GetHashByIndex looks up the hash for the given index in the commit-graph.
func (fi *fileIndex) GetHashByIndex(idx uint32) (found plumbing.Hash, err error) {
if idx < fi.minimumNumberOfHashes {
if fi.parent != nil {
return fi.parent.GetHashByIndex(idx)
}
return found, ErrMalformedCommitGraphFile
}
idx -= fi.minimumNumberOfHashes
if idx >= fi.fanout[0xff] {
return found, ErrMalformedCommitGraphFile
}
offset := fi.offsets[OIDLookupChunk] + int64(idx)*hash.Size
if _, err := fi.reader.ReadAt(found[:], offset); err != nil {
return found, err
}
return found, nil
}
func (fi *fileIndex) getHashesFromIndexes(indexes []uint32) ([]plumbing.Hash, error) {
hashes := make([]plumbing.Hash, len(indexes))
for i, idx := range indexes {
if idx < fi.minimumNumberOfHashes {
if fi.parent != nil {
hash, err := fi.parent.GetHashByIndex(idx)
if err != nil {
return nil, err
}
hashes[i] = hash
continue
}
return nil, ErrMalformedCommitGraphFile
}
idx -= fi.minimumNumberOfHashes
if idx >= fi.fanout[0xff] {
return nil, ErrMalformedCommitGraphFile
}
offset := fi.offsets[OIDLookupChunk] + int64(idx)*hash.Size
if _, err := fi.reader.ReadAt(hashes[i][:], offset); err != nil {
return nil, err
}
}
return hashes, nil
}
// Hashes returns all the hashes that are available in the index.
func (fi *fileIndex) Hashes() []plumbing.Hash {
hashes := make([]plumbing.Hash, fi.fanout[0xff]+fi.minimumNumberOfHashes)
for i := uint32(0); i < fi.minimumNumberOfHashes; i++ {
hash, err := fi.parent.GetHashByIndex(i)
if err != nil {
return nil
}
hashes[i] = hash
}
for i := uint32(0); i < fi.fanout[0xff]; i++ {
offset := fi.offsets[OIDLookupChunk] + int64(i)*hash.Size
if n, err := fi.reader.ReadAt(hashes[i+fi.minimumNumberOfHashes][:], offset); err != nil || n < hash.Size {
return nil
}
}
return hashes
}
func (fi *fileIndex) HasGenerationV2() bool {
return fi.hasGenerationV2
}
func (fi *fileIndex) MaximumNumberOfHashes() uint32 {
return fi.minimumNumberOfHashes + fi.fanout[0xff]
}
go-git-5.13.2/plumbing/format/commitgraph/v2/memory.go 0000664 0000000 0000000 00000005540 14744245500 0022606 0 ustar 00root root 0000000 0000000 package v2
import (
"math"
"github.com/go-git/go-git/v5/plumbing"
)
// MemoryIndex provides a way to build the commit-graph in memory
// for later encoding to file.
type MemoryIndex struct {
commitData []commitData
indexMap map[plumbing.Hash]uint32
hasGenerationV2 bool
}
type commitData struct {
Hash plumbing.Hash
*CommitData
}
// NewMemoryIndex creates in-memory commit graph representation
func NewMemoryIndex() *MemoryIndex {
return &MemoryIndex{
indexMap: make(map[plumbing.Hash]uint32),
hasGenerationV2: true,
}
}
// GetIndexByHash gets the index in the commit graph from commit hash, if available
func (mi *MemoryIndex) GetIndexByHash(h plumbing.Hash) (uint32, error) {
i, ok := mi.indexMap[h]
if ok {
return i, nil
}
return 0, plumbing.ErrObjectNotFound
}
// GetHashByIndex gets the hash given an index in the commit graph
func (mi *MemoryIndex) GetHashByIndex(i uint32) (plumbing.Hash, error) {
if i >= uint32(len(mi.commitData)) {
return plumbing.ZeroHash, plumbing.ErrObjectNotFound
}
return mi.commitData[i].Hash, nil
}
// GetCommitDataByIndex gets the commit node from the commit graph using index
// obtained from child node, if available
func (mi *MemoryIndex) GetCommitDataByIndex(i uint32) (*CommitData, error) {
if i >= uint32(len(mi.commitData)) {
return nil, plumbing.ErrObjectNotFound
}
commitData := mi.commitData[i]
// Map parent hashes to parent indexes
if commitData.ParentIndexes == nil {
parentIndexes := make([]uint32, len(commitData.ParentHashes))
for i, parentHash := range commitData.ParentHashes {
var err error
if parentIndexes[i], err = mi.GetIndexByHash(parentHash); err != nil {
return nil, err
}
}
commitData.ParentIndexes = parentIndexes
}
return commitData.CommitData, nil
}
// Hashes returns all the hashes that are available in the index
func (mi *MemoryIndex) Hashes() []plumbing.Hash {
hashes := make([]plumbing.Hash, 0, len(mi.indexMap))
for k := range mi.indexMap {
hashes = append(hashes, k)
}
return hashes
}
// Add adds new node to the memory index
func (mi *MemoryIndex) Add(hash plumbing.Hash, data *CommitData) {
// The parent indexes are calculated lazily in GetNodeByIndex
// which allows adding nodes out of order as long as all parents
// are eventually resolved
data.ParentIndexes = nil
mi.indexMap[hash] = uint32(len(mi.commitData))
mi.commitData = append(mi.commitData, commitData{Hash: hash, CommitData: data})
if data.GenerationV2 == math.MaxUint64 { // if GenerationV2 is not available reset it to zero
data.GenerationV2 = 0
}
mi.hasGenerationV2 = mi.hasGenerationV2 && data.GenerationV2 != 0
}
func (mi *MemoryIndex) HasGenerationV2() bool {
return mi.hasGenerationV2
}
// Close closes the index
func (mi *MemoryIndex) Close() error {
return nil
}
func (mi *MemoryIndex) MaximumNumberOfHashes() uint32 {
return uint32(len(mi.indexMap))
}
go-git-5.13.2/plumbing/format/config/ 0000775 0000000 0000000 00000000000 14744245500 0017347 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/format/config/common.go 0000664 0000000 0000000 00000005127 14744245500 0021173 0 ustar 00root root 0000000 0000000 package config
// New creates a new config instance.
func New() *Config {
return &Config{}
}
// Config contains all the sections, comments and includes from a config file.
type Config struct {
Comment *Comment
Sections Sections
Includes Includes
}
// Includes is a list of Includes in a config file.
type Includes []*Include
// Include is a reference to an included config file.
type Include struct {
Path string
Config *Config
}
// Comment string without the prefix '#' or ';'.
type Comment string
const (
// NoSubsection token is passed to Config.Section and Config.SetSection to
// represent the absence of a section.
NoSubsection = ""
)
// Section returns a existing section with the given name or creates a new one.
func (c *Config) Section(name string) *Section {
for i := len(c.Sections) - 1; i >= 0; i-- {
s := c.Sections[i]
if s.IsName(name) {
return s
}
}
s := &Section{Name: name}
c.Sections = append(c.Sections, s)
return s
}
// HasSection checks if the Config has a section with the specified name.
func (c *Config) HasSection(name string) bool {
for _, s := range c.Sections {
if s.IsName(name) {
return true
}
}
return false
}
// RemoveSection removes a section from a config file.
func (c *Config) RemoveSection(name string) *Config {
result := Sections{}
for _, s := range c.Sections {
if !s.IsName(name) {
result = append(result, s)
}
}
c.Sections = result
return c
}
// RemoveSubsection remove a subsection from a config file.
func (c *Config) RemoveSubsection(section string, subsection string) *Config {
for _, s := range c.Sections {
if s.IsName(section) {
result := Subsections{}
for _, ss := range s.Subsections {
if !ss.IsName(subsection) {
result = append(result, ss)
}
}
s.Subsections = result
}
}
return c
}
// AddOption adds an option to a given section and subsection. Use the
// NoSubsection constant for the subsection argument if no subsection is wanted.
func (c *Config) AddOption(section string, subsection string, key string, value string) *Config {
if subsection == "" {
c.Section(section).AddOption(key, value)
} else {
c.Section(section).Subsection(subsection).AddOption(key, value)
}
return c
}
// SetOption sets an option to a given section and subsection. Use the
// NoSubsection constant for the subsection argument if no subsection is wanted.
func (c *Config) SetOption(section string, subsection string, key string, value string) *Config {
if subsection == "" {
c.Section(section).SetOption(key, value)
} else {
c.Section(section).Subsection(subsection).SetOption(key, value)
}
return c
}
go-git-5.13.2/plumbing/format/config/common_test.go 0000664 0000000 0000000 00000004725 14744245500 0022235 0 ustar 00root root 0000000 0000000 package config
import (
"testing"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type CommonSuite struct{}
var _ = Suite(&CommonSuite{})
func (s *CommonSuite) TestConfig_SetOption(c *C) {
obtained := New().SetOption("section", NoSubsection, "key1", "value1")
expected := &Config{
Sections: []*Section{
{
Name: "section",
Options: []*Option{
{Key: "key1", Value: "value1"},
},
},
},
}
c.Assert(obtained, DeepEquals, expected)
obtained = obtained.SetOption("section", NoSubsection, "key1", "value1")
c.Assert(obtained, DeepEquals, expected)
obtained = New().SetOption("section", "subsection", "key1", "value1")
expected = &Config{
Sections: []*Section{
{
Name: "section",
Subsections: []*Subsection{
{
Name: "subsection",
Options: []*Option{
{Key: "key1", Value: "value1"},
},
},
},
},
},
}
c.Assert(obtained, DeepEquals, expected)
obtained = obtained.SetOption("section", "subsection", "key1", "value1")
c.Assert(obtained, DeepEquals, expected)
}
func (s *CommonSuite) TestConfig_AddOption(c *C) {
obtained := New().AddOption("section", NoSubsection, "key1", "value1")
expected := &Config{
Sections: []*Section{
{
Name: "section",
Options: []*Option{
{Key: "key1", Value: "value1"},
},
},
},
}
c.Assert(obtained, DeepEquals, expected)
}
func (s *CommonSuite) TestConfig_HasSection(c *C) {
sect := New().
AddOption("section1", "sub1", "key1", "value1").
AddOption("section1", "sub2", "key1", "value1")
c.Assert(sect.HasSection("section1"), Equals, true)
c.Assert(sect.HasSection("section2"), Equals, false)
}
func (s *CommonSuite) TestConfig_RemoveSection(c *C) {
sect := New().
AddOption("section1", NoSubsection, "key1", "value1").
AddOption("section2", NoSubsection, "key1", "value1")
expected := New().
AddOption("section1", NoSubsection, "key1", "value1")
c.Assert(sect.RemoveSection("other"), DeepEquals, sect)
c.Assert(sect.RemoveSection("section2"), DeepEquals, expected)
}
func (s *CommonSuite) TestConfig_RemoveSubsection(c *C) {
sect := New().
AddOption("section1", "sub1", "key1", "value1").
AddOption("section1", "sub2", "key1", "value1")
expected := New().
AddOption("section1", "sub1", "key1", "value1")
c.Assert(sect.RemoveSubsection("section1", "other"), DeepEquals, sect)
c.Assert(sect.RemoveSubsection("other", "other"), DeepEquals, sect)
c.Assert(sect.RemoveSubsection("section1", "sub2"), DeepEquals, expected)
}
go-git-5.13.2/plumbing/format/config/decoder.go 0000664 0000000 0000000 00000001340 14744245500 0021301 0 ustar 00root root 0000000 0000000 package config
import (
"io"
"github.com/go-git/gcfg"
)
// A Decoder reads and decodes config files from an input stream.
type Decoder struct {
io.Reader
}
// NewDecoder returns a new decoder that reads from r.
func NewDecoder(r io.Reader) *Decoder {
return &Decoder{r}
}
// Decode reads the whole config from its input and stores it in the
// value pointed to by config.
func (d *Decoder) Decode(config *Config) error {
cb := func(s string, ss string, k string, v string, bv bool) error {
if ss == "" && k == "" {
config.Section(s)
return nil
}
if ss != "" && k == "" {
config.Section(s).Subsection(ss)
return nil
}
config.AddOption(s, ss, k, v)
return nil
}
return gcfg.ReadWithCallback(d, cb)
}
go-git-5.13.2/plumbing/format/config/decoder_test.go 0000664 0000000 0000000 00000003571 14744245500 0022350 0 ustar 00root root 0000000 0000000 package config
import (
"bytes"
"testing"
. "gopkg.in/check.v1"
)
type DecoderSuite struct{}
var _ = Suite(&DecoderSuite{})
func (s *DecoderSuite) TestDecode(c *C) {
for idx, fixture := range fixtures {
r := bytes.NewReader([]byte(fixture.Raw))
d := NewDecoder(r)
cfg := &Config{}
err := d.Decode(cfg)
c.Assert(err, IsNil, Commentf("decoder error for fixture: %d", idx))
buf := bytes.NewBuffer(nil)
e := NewEncoder(buf)
_ = e.Encode(cfg)
c.Assert(cfg, DeepEquals, fixture.Config, Commentf("bad result for fixture: %d, %s", idx, buf.String()))
}
}
func (s *DecoderSuite) TestDecodeFailsWithIdentBeforeSection(c *C) {
t := `
key=value
[section]
key=value
`
decodeFails(c, t)
}
func (s *DecoderSuite) TestDecodeFailsWithEmptySectionName(c *C) {
t := `
[]
key=value
`
decodeFails(c, t)
}
func (s *DecoderSuite) TestDecodeFailsWithEmptySubsectionName(c *C) {
t := `
[remote ""]
key=value
`
decodeFails(c, t)
}
func (s *DecoderSuite) TestDecodeFailsWithBadSubsectionName(c *C) {
t := `
[remote origin"]
key=value
`
decodeFails(c, t)
t = `
[remote "origin]
key=value
`
decodeFails(c, t)
}
func (s *DecoderSuite) TestDecodeFailsWithTrailingGarbage(c *C) {
t := `
[remote]garbage
key=value
`
decodeFails(c, t)
t = `
[remote "origin"]garbage
key=value
`
decodeFails(c, t)
}
func (s *DecoderSuite) TestDecodeFailsWithGarbage(c *C) {
decodeFails(c, "---")
decodeFails(c, "????")
decodeFails(c, "[sect\nkey=value")
decodeFails(c, "sect]\nkey=value")
decodeFails(c, `[section]key="value`)
decodeFails(c, `[section]key=value"`)
}
func decodeFails(c *C, text string) {
r := bytes.NewReader([]byte(text))
d := NewDecoder(r)
cfg := &Config{}
err := d.Decode(cfg)
c.Assert(err, NotNil)
}
func FuzzDecoder(f *testing.F) {
f.Fuzz(func(t *testing.T, input []byte) {
d := NewDecoder(bytes.NewReader(input))
cfg := &Config{}
d.Decode(cfg)
})
}
go-git-5.13.2/plumbing/format/config/doc.go 0000664 0000000 0000000 00000011734 14744245500 0020451 0 ustar 00root root 0000000 0000000 // Package config implements encoding and decoding of git config files.
//
// Configuration File
// ------------------
//
// The Git configuration file contains a number of variables that affect
// the Git commands' behavior. The `.git/config` file in each repository
// is used to store the configuration for that repository, and
// `$HOME/.gitconfig` is used to store a per-user configuration as
// fallback values for the `.git/config` file. The file `/etc/gitconfig`
// can be used to store a system-wide default configuration.
//
// The configuration variables are used by both the Git plumbing
// and the porcelains. The variables are divided into sections, wherein
// the fully qualified variable name of the variable itself is the last
// dot-separated segment and the section name is everything before the last
// dot. The variable names are case-insensitive, allow only alphanumeric
// characters and `-`, and must start with an alphabetic character. Some
// variables may appear multiple times; we say then that the variable is
// multivalued.
//
// Syntax
// ~~~~~~
//
// The syntax is fairly flexible and permissive; whitespaces are mostly
// ignored. The '#' and ';' characters begin comments to the end of line,
// blank lines are ignored.
//
// The file consists of sections and variables. A section begins with
// the name of the section in square brackets and continues until the next
// section begins. Section names are case-insensitive. Only alphanumeric
// characters, `-` and `.` are allowed in section names. Each variable
// must belong to some section, which means that there must be a section
// header before the first setting of a variable.
//
// Sections can be further divided into subsections. To begin a subsection
// put its name in double quotes, separated by space from the section name,
// in the section header, like in the example below:
//
// --------
// [section "subsection"]
//
// --------
//
// Subsection names are case sensitive and can contain any characters except
// newline (doublequote `"` and backslash can be included by escaping them
// as `\"` and `\\`, respectively). Section headers cannot span multiple
// lines. Variables may belong directly to a section or to a given subsection.
// You can have `[section]` if you have `[section "subsection"]`, but you
// don't need to.
//
// There is also a deprecated `[section.subsection]` syntax. With this
// syntax, the subsection name is converted to lower-case and is also
// compared case sensitively. These subsection names follow the same
// restrictions as section names.
//
// All the other lines (and the remainder of the line after the section
// header) are recognized as setting variables, in the form
// 'name = value' (or just 'name', which is a short-hand to say that
// the variable is the boolean "true").
// The variable names are case-insensitive, allow only alphanumeric characters
// and `-`, and must start with an alphabetic character.
//
// A line that defines a value can be continued to the next line by
// ending it with a `\`; the backquote and the end-of-line are
// stripped. Leading whitespaces after 'name =', the remainder of the
// line after the first comment character '#' or ';', and trailing
// whitespaces of the line are discarded unless they are enclosed in
// double quotes. Internal whitespaces within the value are retained
// verbatim.
//
// Inside double quotes, double quote `"` and backslash `\` characters
// must be escaped: use `\"` for `"` and `\\` for `\`.
//
// The following escape sequences (beside `\"` and `\\`) are recognized:
// `\n` for newline character (NL), `\t` for horizontal tabulation (HT, TAB)
// and `\b` for backspace (BS). Other char escape sequences (including octal
// escape sequences) are invalid.
//
// Includes
// ~~~~~~~~
//
// You can include one config file from another by setting the special
// `include.path` variable to the name of the file to be included. The
// variable takes a pathname as its value, and is subject to tilde
// expansion.
//
// The included file is expanded immediately, as if its contents had been
// found at the location of the include directive. If the value of the
// `include.path` variable is a relative path, the path is considered to be
// relative to the configuration file in which the include directive was
// found. See below for examples.
//
//
// Example
// ~~~~~~~
//
// # Core variables
// [core]
// ; Don't trust file modes
// filemode = false
//
// # Our diff algorithm
// [diff]
// external = /usr/local/bin/diff-wrapper
// renames = true
//
// [branch "devel"]
// remote = origin
// merge = refs/heads/devel
//
// # Proxy settings
// [core]
// gitProxy="ssh" for "kernel.org"
// gitProxy=default-proxy ; for the rest
//
// [include]
// path = /path/to/foo.inc ; include by absolute path
// path = foo ; expand "foo" relative to the current file
// path = ~/foo ; expand "foo" in your `$HOME` directory
//
package config
go-git-5.13.2/plumbing/format/config/encoder.go 0000664 0000000 0000000 00000003370 14744245500 0021320 0 ustar 00root root 0000000 0000000 package config
import (
"fmt"
"io"
"strings"
)
// An Encoder writes config files to an output stream.
type Encoder struct {
w io.Writer
}
var (
subsectionReplacer = strings.NewReplacer(`"`, `\"`, `\`, `\\`)
valueReplacer = strings.NewReplacer(`"`, `\"`, `\`, `\\`, "\n", `\n`, "\t", `\t`, "\b", `\b`)
)
// NewEncoder returns a new encoder that writes to w.
func NewEncoder(w io.Writer) *Encoder {
return &Encoder{w}
}
// Encode writes the config in git config format to the stream of the encoder.
func (e *Encoder) Encode(cfg *Config) error {
for _, s := range cfg.Sections {
if err := e.encodeSection(s); err != nil {
return err
}
}
return nil
}
func (e *Encoder) encodeSection(s *Section) error {
if len(s.Options) > 0 {
if err := e.printf("[%s]\n", s.Name); err != nil {
return err
}
if err := e.encodeOptions(s.Options); err != nil {
return err
}
}
for _, ss := range s.Subsections {
if err := e.encodeSubsection(s.Name, ss); err != nil {
return err
}
}
return nil
}
func (e *Encoder) encodeSubsection(sectionName string, s *Subsection) error {
if err := e.printf("[%s \"%s\"]\n", sectionName, subsectionReplacer.Replace(s.Name)); err != nil {
return err
}
return e.encodeOptions(s.Options)
}
func (e *Encoder) encodeOptions(opts Options) error {
for _, o := range opts {
var value string
if strings.ContainsAny(o.Value, "#;\"\t\n\\") || strings.HasPrefix(o.Value, " ") || strings.HasSuffix(o.Value, " ") {
value = `"`+valueReplacer.Replace(o.Value)+`"`
} else {
value = o.Value
}
if err := e.printf("\t%s = %s\n", o.Key, value); err != nil {
return err
}
}
return nil
}
func (e *Encoder) printf(msg string, args ...interface{}) error {
_, err := fmt.Fprintf(e.w, msg, args...)
return err
}
go-git-5.13.2/plumbing/format/config/encoder_test.go 0000664 0000000 0000000 00000000703 14744245500 0022354 0 ustar 00root root 0000000 0000000 package config
import (
"bytes"
. "gopkg.in/check.v1"
)
type EncoderSuite struct{}
var _ = Suite(&EncoderSuite{})
func (s *EncoderSuite) TestEncode(c *C) {
for idx, fixture := range fixtures {
buf := &bytes.Buffer{}
e := NewEncoder(buf)
err := e.Encode(fixture.Config)
c.Assert(err, IsNil, Commentf("encoder error for fixture: %d", idx))
c.Assert(buf.String(), Equals, fixture.Text, Commentf("bad result for fixture: %d", idx))
}
}
go-git-5.13.2/plumbing/format/config/fixtures_test.go 0000664 0000000 0000000 00000006673 14744245500 0022622 0 ustar 00root root 0000000 0000000 package config
type Fixture struct {
Text string
Raw string
Config *Config
}
var fixtures = []*Fixture{
{
Raw: "",
Text: "",
Config: New(),
},
{
Raw: ";Comments only",
Text: "",
Config: New(),
},
{
Raw: "#Comments only",
Text: "",
Config: New(),
},
{
Raw: "[core]\nrepositoryformatversion=0",
Text: "[core]\n\trepositoryformatversion = 0\n",
Config: New().AddOption("core", "", "repositoryformatversion", "0"),
},
{
Raw: "[core]\n\trepositoryformatversion = 0\n",
Text: "[core]\n\trepositoryformatversion = 0\n",
Config: New().AddOption("core", "", "repositoryformatversion", "0"),
},
{
Raw: ";Commment\n[core]\n;Comment\nrepositoryformatversion = 0\n",
Text: "[core]\n\trepositoryformatversion = 0\n",
Config: New().AddOption("core", "", "repositoryformatversion", "0"),
},
{
Raw: "#Commment\n#Comment\n[core]\n#Comment\nrepositoryformatversion = 0\n",
Text: "[core]\n\trepositoryformatversion = 0\n",
Config: New().AddOption("core", "", "repositoryformatversion", "0"),
},
{
Raw: `[section]
option1 = "has # hash"
option2 = "has \" quote"
option3 = "has \\ backslash"
option4 = "has ; semicolon"
option5 = "has \n line-feed"
option6 = "has \t tab"
option7 = " has leading spaces"
option8 = "has trailing spaces "
option9 = has no special characters
option10 = has unusual ` + "\x01\x7f\xc8\x80 characters\n",
Text: `[section]
option1 = "has # hash"
option2 = "has \" quote"
option3 = "has \\ backslash"
option4 = "has ; semicolon"
option5 = "has \n line-feed"
option6 = "has \t tab"
option7 = " has leading spaces"
option8 = "has trailing spaces "
option9 = has no special characters
option10 = has unusual ` + "\x01\x7f\xc8\x80 characters\n",
Config: New().
AddOption("section", "", "option1", `has # hash`).
AddOption("section", "", "option2", `has " quote`).
AddOption("section", "", "option3", `has \ backslash`).
AddOption("section", "", "option4", `has ; semicolon`).
AddOption("section", "", "option5", "has \n line-feed").
AddOption("section", "", "option6", "has \t tab").
AddOption("section", "", "option7", ` has leading spaces`).
AddOption("section", "", "option8", `has trailing spaces `).
AddOption("section", "", "option9", `has no special characters`).
AddOption("section", "", "option10", "has unusual \x01\x7f\u0200 characters"),
},
{
Raw: `
[sect1]
opt1 = value1
[sect1 "subsect1"]
opt2 = value2
`,
Text: `[sect1]
opt1 = value1
[sect1 "subsect1"]
opt2 = value2
`,
Config: New().
AddOption("sect1", "", "opt1", "value1").
AddOption("sect1", "subsect1", "opt2", "value2"),
},
{
Raw: `
[sect1]
opt1 = value1
[sect1 "subsect1"]
opt2 = value2
[sect1]
opt1 = value1b
[sect1 "subsect1"]
opt2 = value2b
[sect1 "subsect2"]
opt2 = value2
`,
Text: `[sect1]
opt1 = value1
opt1 = value1b
[sect1 "subsect1"]
opt2 = value2
opt2 = value2b
[sect1 "subsect2"]
opt2 = value2
`,
Config: New().
AddOption("sect1", "", "opt1", "value1").
AddOption("sect1", "", "opt1", "value1b").
AddOption("sect1", "subsect1", "opt2", "value2").
AddOption("sect1", "subsect1", "opt2", "value2b").
AddOption("sect1", "subsect2", "opt2", "value2"),
},
{
Raw: `
[sect1]
opt1 = value1
opt1 = value2
`,
Text: `[sect1]
opt1 = value1
opt1 = value2
`,
Config: New().
AddOption("sect1", "", "opt1", "value1").
AddOption("sect1", "", "opt1", "value2"),
},
}
go-git-5.13.2/plumbing/format/config/format.go 0000664 0000000 0000000 00000003440 14744245500 0021167 0 ustar 00root root 0000000 0000000 package config
// RepositoryFormatVersion represents the repository format version,
// as per defined at:
//
// https://git-scm.com/docs/repository-version
type RepositoryFormatVersion string
const (
// Version_0 is the format defined by the initial version of git,
// including but not limited to the format of the repository
// directory, the repository configuration file, and the object
// and ref storage.
//
// Specifying the complete behavior of git is beyond the scope
// of this document.
Version_0 = "0"
// Version_1 is identical to version 0, with the following exceptions:
//
// 1. When reading the core.repositoryformatversion variable, a git
// implementation which supports version 1 MUST also read any
// configuration keys found in the extensions section of the
// configuration file.
//
// 2. If a version-1 repository specifies any extensions.* keys that
// the running git has not implemented, the operation MUST NOT proceed.
// Similarly, if the value of any known key is not understood by the
// implementation, the operation MUST NOT proceed.
//
// Note that if no extensions are specified in the config file, then
// core.repositoryformatversion SHOULD be set to 0 (setting it to 1 provides
// no benefit, and makes the repository incompatible with older
// implementations of git).
Version_1 = "1"
// DefaultRepositoryFormatVersion holds the default repository format version.
DefaultRepositoryFormatVersion = Version_0
)
// ObjectFormat defines the object format.
type ObjectFormat string
const (
// SHA1 represents the object format used for SHA1.
SHA1 ObjectFormat = "sha1"
// SHA256 represents the object format used for SHA256.
SHA256 ObjectFormat = "sha256"
// DefaultObjectFormat holds the default object format.
DefaultObjectFormat = SHA1
)
go-git-5.13.2/plumbing/format/config/option.go 0000664 0000000 0000000 00000005007 14744245500 0021210 0 ustar 00root root 0000000 0000000 package config
import (
"fmt"
"strings"
)
// Option defines a key/value entity in a config file.
type Option struct {
// Key preserving original caseness.
// Use IsKey instead to compare key regardless of caseness.
Key string
// Original value as string, could be not normalized.
Value string
}
type Options []*Option
// IsKey returns true if the given key matches
// this option's key in a case-insensitive comparison.
func (o *Option) IsKey(key string) bool {
return strings.EqualFold(o.Key, key)
}
func (opts Options) GoString() string {
var strs []string
for _, opt := range opts {
strs = append(strs, fmt.Sprintf("%#v", opt))
}
return strings.Join(strs, ", ")
}
// Get gets the value for the given key if set,
// otherwise it returns the empty string.
//
// Note that there is no difference
//
// This matches git behaviour since git v1.8.1-rc1,
// if there are multiple definitions of a key, the
// last one wins.
//
// See: http://article.gmane.org/gmane.linux.kernel/1407184
//
// In order to get all possible values for the same key,
// use GetAll.
func (opts Options) Get(key string) string {
for i := len(opts) - 1; i >= 0; i-- {
o := opts[i]
if o.IsKey(key) {
return o.Value
}
}
return ""
}
// Has checks if an Option exist with the given key.
func (opts Options) Has(key string) bool {
for _, o := range opts {
if o.IsKey(key) {
return true
}
}
return false
}
// GetAll returns all possible values for the same key.
func (opts Options) GetAll(key string) []string {
result := []string{}
for _, o := range opts {
if o.IsKey(key) {
result = append(result, o.Value)
}
}
return result
}
func (opts Options) withoutOption(key string) Options {
result := Options{}
for _, o := range opts {
if !o.IsKey(key) {
result = append(result, o)
}
}
return result
}
func (opts Options) withAddedOption(key string, value string) Options {
return append(opts, &Option{key, value})
}
func (opts Options) withSettedOption(key string, values ...string) Options {
var result Options
var added []string
for _, o := range opts {
if !o.IsKey(key) {
result = append(result, o)
continue
}
if contains(values, o.Value) {
added = append(added, o.Value)
result = append(result, o)
continue
}
}
for _, value := range values {
if contains(added, value) {
continue
}
result = result.withAddedOption(key, value)
}
return result
}
func contains(haystack []string, needle string) bool {
for _, s := range haystack {
if s == needle {
return true
}
}
return false
}
go-git-5.13.2/plumbing/format/config/option_test.go 0000664 0000000 0000000 00000002407 14744245500 0022250 0 ustar 00root root 0000000 0000000 package config
import (
. "gopkg.in/check.v1"
)
type OptionSuite struct{}
var _ = Suite(&OptionSuite{})
func (s *OptionSuite) TestOptions_Has(c *C) {
o := Options{
&Option{"k", "v"},
&Option{"ok", "v1"},
&Option{"K", "v2"},
}
c.Assert(o.Has("k"), Equals, true)
c.Assert(o.Has("K"), Equals, true)
c.Assert(o.Has("ok"), Equals, true)
c.Assert(o.Has("unexistant"), Equals, false)
o = Options{}
c.Assert(o.Has("k"), Equals, false)
}
func (s *OptionSuite) TestOptions_GetAll(c *C) {
o := Options{
&Option{"k", "v"},
&Option{"ok", "v1"},
&Option{"K", "v2"},
}
c.Assert(o.GetAll("k"), DeepEquals, []string{"v", "v2"})
c.Assert(o.GetAll("K"), DeepEquals, []string{"v", "v2"})
c.Assert(o.GetAll("ok"), DeepEquals, []string{"v1"})
c.Assert(o.GetAll("unexistant"), DeepEquals, []string{})
o = Options{}
c.Assert(o.GetAll("k"), DeepEquals, []string{})
}
func (s *OptionSuite) TestOption_IsKey(c *C) {
c.Assert((&Option{Key: "key"}).IsKey("key"), Equals, true)
c.Assert((&Option{Key: "key"}).IsKey("KEY"), Equals, true)
c.Assert((&Option{Key: "KEY"}).IsKey("key"), Equals, true)
c.Assert((&Option{Key: "key"}).IsKey("other"), Equals, false)
c.Assert((&Option{Key: "key"}).IsKey(""), Equals, false)
c.Assert((&Option{Key: ""}).IsKey("key"), Equals, false)
}
go-git-5.13.2/plumbing/format/config/section.go 0000664 0000000 0000000 00000012175 14744245500 0021350 0 ustar 00root root 0000000 0000000 package config
import (
"fmt"
"strings"
)
// Section is the representation of a section inside git configuration files.
// Each Section contains Options that are used by both the Git plumbing
// and the porcelains.
// Sections can be further divided into subsections. To begin a subsection
// put its name in double quotes, separated by space from the section name,
// in the section header, like in the example below:
//
// [section "subsection"]
//
// All the other lines (and the remainder of the line after the section header)
// are recognized as option variables, in the form "name = value" (or just name,
// which is a short-hand to say that the variable is the boolean "true").
// The variable names are case-insensitive, allow only alphanumeric characters
// and -, and must start with an alphabetic character:
//
// [section "subsection1"]
// option1 = value1
// option2
// [section "subsection2"]
// option3 = value2
//
type Section struct {
Name string
Options Options
Subsections Subsections
}
type Subsection struct {
Name string
Options Options
}
type Sections []*Section
func (s Sections) GoString() string {
var strs []string
for _, ss := range s {
strs = append(strs, fmt.Sprintf("%#v", ss))
}
return strings.Join(strs, ", ")
}
type Subsections []*Subsection
func (s Subsections) GoString() string {
var strs []string
for _, ss := range s {
strs = append(strs, fmt.Sprintf("%#v", ss))
}
return strings.Join(strs, ", ")
}
// IsName checks if the name provided is equals to the Section name, case insensitive.
func (s *Section) IsName(name string) bool {
return strings.EqualFold(s.Name, name)
}
// Subsection returns a Subsection from the specified Section. If the
// Subsection does not exists, new one is created and added to Section.
func (s *Section) Subsection(name string) *Subsection {
for i := len(s.Subsections) - 1; i >= 0; i-- {
ss := s.Subsections[i]
if ss.IsName(name) {
return ss
}
}
ss := &Subsection{Name: name}
s.Subsections = append(s.Subsections, ss)
return ss
}
// HasSubsection checks if the Section has a Subsection with the specified name.
func (s *Section) HasSubsection(name string) bool {
for _, ss := range s.Subsections {
if ss.IsName(name) {
return true
}
}
return false
}
// RemoveSubsection removes a subsection from a Section.
func (s *Section) RemoveSubsection(name string) *Section {
result := Subsections{}
for _, s := range s.Subsections {
if !s.IsName(name) {
result = append(result, s)
}
}
s.Subsections = result
return s
}
// Option returns the value for the specified key. Empty string is returned if
// key does not exists.
func (s *Section) Option(key string) string {
return s.Options.Get(key)
}
// OptionAll returns all possible values for an option with the specified key.
// If the option does not exists, an empty slice will be returned.
func (s *Section) OptionAll(key string) []string {
return s.Options.GetAll(key)
}
// HasOption checks if the Section has an Option with the given key.
func (s *Section) HasOption(key string) bool {
return s.Options.Has(key)
}
// AddOption adds a new Option to the Section. The updated Section is returned.
func (s *Section) AddOption(key string, value string) *Section {
s.Options = s.Options.withAddedOption(key, value)
return s
}
// SetOption adds a new Option to the Section. If the option already exists, is replaced.
// The updated Section is returned.
func (s *Section) SetOption(key string, value string) *Section {
s.Options = s.Options.withSettedOption(key, value)
return s
}
// Remove an option with the specified key. The updated Section is returned.
func (s *Section) RemoveOption(key string) *Section {
s.Options = s.Options.withoutOption(key)
return s
}
// IsName checks if the name of the subsection is exactly the specified name.
func (s *Subsection) IsName(name string) bool {
return s.Name == name
}
// Option returns an option with the specified key. If the option does not exists,
// empty spring will be returned.
func (s *Subsection) Option(key string) string {
return s.Options.Get(key)
}
// OptionAll returns all possible values for an option with the specified key.
// If the option does not exists, an empty slice will be returned.
func (s *Subsection) OptionAll(key string) []string {
return s.Options.GetAll(key)
}
// HasOption checks if the Subsection has an Option with the given key.
func (s *Subsection) HasOption(key string) bool {
return s.Options.Has(key)
}
// AddOption adds a new Option to the Subsection. The updated Subsection is returned.
func (s *Subsection) AddOption(key string, value string) *Subsection {
s.Options = s.Options.withAddedOption(key, value)
return s
}
// SetOption adds a new Option to the Subsection. If the option already exists, is replaced.
// The updated Subsection is returned.
func (s *Subsection) SetOption(key string, value ...string) *Subsection {
s.Options = s.Options.withSettedOption(key, value...)
return s
}
// RemoveOption removes the option with the specified key. The updated Subsection is returned.
func (s *Subsection) RemoveOption(key string) *Subsection {
s.Options = s.Options.withoutOption(key)
return s
}
go-git-5.13.2/plumbing/format/config/section_test.go 0000664 0000000 0000000 00000017507 14744245500 0022413 0 ustar 00root root 0000000 0000000 package config
import (
. "gopkg.in/check.v1"
)
type SectionSuite struct{}
var _ = Suite(&SectionSuite{})
func (s *SectionSuite) TestSections_GoString(c *C) {
sects := Sections{
&Section{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
},
},
&Section{
Options: []*Option{
{Key: "key1", Value: "value3"},
{Key: "key2", Value: "value4"},
},
},
}
expected := "&config.Section{Name:\"\", Options:&config.Option{Key:\"key1\", Value:\"value1\"}, &config.Option{Key:\"key2\", Value:\"value2\"}, Subsections:}, &config.Section{Name:\"\", Options:&config.Option{Key:\"key1\", Value:\"value3\"}, &config.Option{Key:\"key2\", Value:\"value4\"}, Subsections:}"
c.Assert(sects.GoString(), Equals, expected)
}
func (s *SectionSuite) TestSubsections_GoString(c *C) {
sects := Subsections{
&Subsection{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
{Key: "key1", Value: "value3"},
},
},
&Subsection{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
{Key: "key1", Value: "value3"},
},
},
}
expected := "&config.Subsection{Name:\"\", Options:&config.Option{Key:\"key1\", Value:\"value1\"}, &config.Option{Key:\"key2\", Value:\"value2\"}, &config.Option{Key:\"key1\", Value:\"value3\"}}, &config.Subsection{Name:\"\", Options:&config.Option{Key:\"key1\", Value:\"value1\"}, &config.Option{Key:\"key2\", Value:\"value2\"}, &config.Option{Key:\"key1\", Value:\"value3\"}}"
c.Assert(sects.GoString(), Equals, expected)
}
func (s *SectionSuite) TestSection_IsName(c *C) {
sect := &Section{
Name: "name1",
}
c.Assert(sect.IsName("name1"), Equals, true)
c.Assert(sect.IsName("Name1"), Equals, true)
}
func (s *SectionSuite) TestSection_Subsection(c *C) {
subSect1 := &Subsection{
Name: "name1",
Options: Options{
&Option{Key: "key1", Value: "value1"},
},
}
sect := &Section{
Subsections: Subsections{
subSect1,
},
}
c.Assert(sect.Subsection("name1"), DeepEquals, subSect1)
subSect2 := &Subsection{
Name: "name2",
}
c.Assert(sect.Subsection("name2"), DeepEquals, subSect2)
}
func (s *SectionSuite) TestSection_HasSubsection(c *C) {
sect := &Section{
Subsections: Subsections{
&Subsection{
Name: "name1",
},
},
}
c.Assert(sect.HasSubsection("name1"), Equals, true)
c.Assert(sect.HasSubsection("name2"), Equals, false)
}
func (s *SectionSuite) TestSection_RemoveSubsection(c *C) {
sect := &Section{
Subsections: Subsections{
&Subsection{
Name: "name1",
},
&Subsection{
Name: "name2",
},
},
}
expected := &Section{
Subsections: Subsections{
&Subsection{
Name: "name2",
},
},
}
c.Assert(sect.RemoveSubsection("name1"), DeepEquals, expected)
c.Assert(sect.HasSubsection("name1"), Equals, false)
c.Assert(sect.HasSubsection("name2"), Equals, true)
}
func (s *SectionSuite) TestSection_Option(c *C) {
sect := &Section{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
{Key: "key1", Value: "value3"},
},
}
c.Assert(sect.Option("otherkey"), Equals, "")
c.Assert(sect.Option("key2"), Equals, "value2")
c.Assert(sect.Option("key1"), Equals, "value3")
}
func (s *SectionSuite) TestSection_OptionAll(c *C) {
sect := &Section{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
{Key: "key1", Value: "value3"},
},
}
c.Assert(sect.OptionAll("otherkey"), DeepEquals, []string{})
c.Assert(sect.OptionAll("key2"), DeepEquals, []string{"value2"})
c.Assert(sect.OptionAll("key1"), DeepEquals, []string{"value1", "value3"})
}
func (s *SectionSuite) TestSection_HasOption(c *C) {
sect := &Section{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
{Key: "key1", Value: "value3"},
},
}
c.Assert(sect.HasOption("otherkey"), Equals, false)
c.Assert(sect.HasOption("key2"), Equals, true)
c.Assert(sect.HasOption("key1"), Equals, true)
}
func (s *SectionSuite) TestSection_AddOption(c *C) {
sect := &Section{
Options: []*Option{
{"key1", "value1"},
},
}
sect1 := &Section{
Options: []*Option{
{"key1", "value1"},
{"key2", "value2"},
},
}
c.Assert(sect.AddOption("key2", "value2"), DeepEquals, sect1)
sect2 := &Section{
Options: []*Option{
{"key1", "value1"},
{"key2", "value2"},
{"key1", "value3"},
},
}
c.Assert(sect.AddOption("key1", "value3"), DeepEquals, sect2)
}
func (s *SectionSuite) TestSection_SetOption(c *C) {
sect := &Section{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
},
}
expected := &Section{
Options: []*Option{
{Key: "key2", Value: "value2"},
{Key: "key1", Value: "value4"},
},
}
c.Assert(sect.SetOption("key1", "value4"), DeepEquals, expected)
}
func (s *SectionSuite) TestSection_RemoveOption(c *C) {
sect := &Section{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
{Key: "key1", Value: "value3"},
},
}
c.Assert(sect.RemoveOption("otherkey"), DeepEquals, sect)
expected := &Section{
Options: []*Option{
{Key: "key2", Value: "value2"},
},
}
c.Assert(sect.RemoveOption("key1"), DeepEquals, expected)
}
func (s *SectionSuite) TestSubsection_IsName(c *C) {
sect := &Subsection{
Name: "name1",
}
c.Assert(sect.IsName("name1"), Equals, true)
c.Assert(sect.IsName("Name1"), Equals, false)
}
func (s *SectionSuite) TestSubsection_Option(c *C) {
sect := &Subsection{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
{Key: "key1", Value: "value3"},
},
}
c.Assert(sect.Option("otherkey"), Equals, "")
c.Assert(sect.Option("key2"), Equals, "value2")
c.Assert(sect.Option("key1"), Equals, "value3")
}
func (s *SectionSuite) TestSubsection_OptionAll(c *C) {
sect := &Subsection{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
{Key: "key1", Value: "value3"},
},
}
c.Assert(sect.OptionAll("otherkey"), DeepEquals, []string{})
c.Assert(sect.OptionAll("key2"), DeepEquals, []string{"value2"})
c.Assert(sect.OptionAll("key1"), DeepEquals, []string{"value1", "value3"})
}
func (s *SectionSuite) TestSubsection_HasOption(c *C) {
sect := &Subsection{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
{Key: "key1", Value: "value3"},
},
}
c.Assert(sect.HasOption("otherkey"), Equals, false)
c.Assert(sect.HasOption("key2"), Equals, true)
c.Assert(sect.HasOption("key1"), Equals, true)
}
func (s *SectionSuite) TestSubsection_AddOption(c *C) {
sect := &Subsection{
Options: []*Option{
{"key1", "value1"},
},
}
sect1 := &Subsection{
Options: []*Option{
{"key1", "value1"},
{"key2", "value2"},
},
}
c.Assert(sect.AddOption("key2", "value2"), DeepEquals, sect1)
sect2 := &Subsection{
Options: []*Option{
{"key1", "value1"},
{"key2", "value2"},
{"key1", "value3"},
},
}
c.Assert(sect.AddOption("key1", "value3"), DeepEquals, sect2)
}
func (s *SectionSuite) TestSubsection_SetOption(c *C) {
sect := &Subsection{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
{Key: "key1", Value: "value3"},
},
}
expected := &Subsection{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
{Key: "key1", Value: "value4"},
},
}
c.Assert(sect.SetOption("key1", "value1", "value4"), DeepEquals, expected)
}
func (s *SectionSuite) TestSubsection_RemoveOption(c *C) {
sect := &Subsection{
Options: []*Option{
{Key: "key1", Value: "value1"},
{Key: "key2", Value: "value2"},
{Key: "key1", Value: "value3"},
},
}
c.Assert(sect.RemoveOption("otherkey"), DeepEquals, sect)
expected := &Subsection{
Options: []*Option{
{Key: "key2", Value: "value2"},
},
}
c.Assert(sect.RemoveOption("key1"), DeepEquals, expected)
}
go-git-5.13.2/plumbing/format/diff/ 0000775 0000000 0000000 00000000000 14744245500 0017012 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/format/diff/colorconfig.go 0000664 0000000 0000000 00000006604 14744245500 0021653 0 ustar 00root root 0000000 0000000 package diff
import "github.com/go-git/go-git/v5/plumbing/color"
// A ColorKey is a key into a ColorConfig map and also equal to the key in the
// diff.color subsection of the config. See
// https://github.com/git/git/blob/v2.26.2/diff.c#L83-L106.
type ColorKey string
// ColorKeys.
const (
Context ColorKey = "context"
Meta ColorKey = "meta"
Frag ColorKey = "frag"
Old ColorKey = "old"
New ColorKey = "new"
Commit ColorKey = "commit"
Whitespace ColorKey = "whitespace"
Func ColorKey = "func"
OldMoved ColorKey = "oldMoved"
OldMovedAlternative ColorKey = "oldMovedAlternative"
OldMovedDimmed ColorKey = "oldMovedDimmed"
OldMovedAlternativeDimmed ColorKey = "oldMovedAlternativeDimmed"
NewMoved ColorKey = "newMoved"
NewMovedAlternative ColorKey = "newMovedAlternative"
NewMovedDimmed ColorKey = "newMovedDimmed"
NewMovedAlternativeDimmed ColorKey = "newMovedAlternativeDimmed"
ContextDimmed ColorKey = "contextDimmed"
OldDimmed ColorKey = "oldDimmed"
NewDimmed ColorKey = "newDimmed"
ContextBold ColorKey = "contextBold"
OldBold ColorKey = "oldBold"
NewBold ColorKey = "newBold"
)
// A ColorConfig is a color configuration. A nil or empty ColorConfig
// corresponds to no color.
type ColorConfig map[ColorKey]string
// A ColorConfigOption sets an option on a ColorConfig.
type ColorConfigOption func(ColorConfig)
// WithColor sets the color for key.
func WithColor(key ColorKey, color string) ColorConfigOption {
return func(cc ColorConfig) {
cc[key] = color
}
}
// defaultColorConfig is the default color configuration. See
// https://github.com/git/git/blob/v2.26.2/diff.c#L57-L81.
var defaultColorConfig = ColorConfig{
Context: color.Normal,
Meta: color.Bold,
Frag: color.Cyan,
Old: color.Red,
New: color.Green,
Commit: color.Yellow,
Whitespace: color.BgRed,
Func: color.Normal,
OldMoved: color.BoldMagenta,
OldMovedAlternative: color.BoldBlue,
OldMovedDimmed: color.Faint,
OldMovedAlternativeDimmed: color.FaintItalic,
NewMoved: color.BoldCyan,
NewMovedAlternative: color.BoldYellow,
NewMovedDimmed: color.Faint,
NewMovedAlternativeDimmed: color.FaintItalic,
ContextDimmed: color.Faint,
OldDimmed: color.FaintRed,
NewDimmed: color.FaintGreen,
ContextBold: color.Bold,
OldBold: color.BoldRed,
NewBold: color.BoldGreen,
}
// NewColorConfig returns a new ColorConfig.
func NewColorConfig(options ...ColorConfigOption) ColorConfig {
cc := make(ColorConfig)
for key, value := range defaultColorConfig {
cc[key] = value
}
for _, option := range options {
option(cc)
}
return cc
}
// Reset returns the ANSI escape sequence to reset the color with key set from
// cc. If no color was set then no reset is needed so it returns the empty
// string.
func (cc ColorConfig) Reset(key ColorKey) string {
if cc[key] == "" {
return ""
}
return color.Reset
}
go-git-5.13.2/plumbing/format/diff/patch.go 0000664 0000000 0000000 00000003334 14744245500 0020443 0 ustar 00root root 0000000 0000000 package diff
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
)
// Operation defines the operation of a diff item.
type Operation int
const (
// Equal item represents an equals diff.
Equal Operation = iota
// Add item represents an insert diff.
Add
// Delete item represents a delete diff.
Delete
)
// Patch represents a collection of steps to transform several files.
type Patch interface {
// FilePatches returns a slice of patches per file.
FilePatches() []FilePatch
// Message returns an optional message that can be at the top of the
// Patch representation.
Message() string
}
// FilePatch represents the necessary steps to transform one file into another.
type FilePatch interface {
// IsBinary returns true if this patch is representing a binary file.
IsBinary() bool
// Files returns the from and to Files, with all the necessary metadata
// about them. If the patch creates a new file, "from" will be nil.
// If the patch deletes a file, "to" will be nil.
Files() (from, to File)
// Chunks returns a slice of ordered changes to transform "from" File into
// "to" File. If the file is a binary one, Chunks will be empty.
Chunks() []Chunk
}
// File contains all the file metadata necessary to print some patch formats.
type File interface {
// Hash returns the File Hash.
Hash() plumbing.Hash
// Mode returns the FileMode.
Mode() filemode.FileMode
// Path returns the complete Path to the file, including the filename.
Path() string
}
// Chunk represents a portion of a file transformation into another.
type Chunk interface {
// Content contains the portion of the file.
Content() string
// Type contains the Operation to do with this Chunk.
Type() Operation
}
go-git-5.13.2/plumbing/format/diff/unified_encoder.go 0000664 0000000 0000000 00000022143 14744245500 0022465 0 ustar 00root root 0000000 0000000 package diff
import (
"fmt"
"io"
"regexp"
"strconv"
"strings"
"github.com/go-git/go-git/v5/plumbing"
)
// DefaultContextLines is the default number of context lines.
const DefaultContextLines = 3
var (
splitLinesRegexp = regexp.MustCompile(`[^\n]*(\n|$)`)
operationChar = map[Operation]byte{
Add: '+',
Delete: '-',
Equal: ' ',
}
operationColorKey = map[Operation]ColorKey{
Add: New,
Delete: Old,
Equal: Context,
}
)
// UnifiedEncoder encodes an unified diff into the provided Writer. It does not
// support similarity index for renames or sorting hash representations.
type UnifiedEncoder struct {
io.Writer
// contextLines is the count of unchanged lines that will appear surrounding
// a change.
contextLines int
// srcPrefix and dstPrefix are prepended to file paths when encoding a diff.
srcPrefix string
dstPrefix string
// colorConfig is the color configuration. The default is no color.
color ColorConfig
}
// NewUnifiedEncoder returns a new UnifiedEncoder that writes to w.
func NewUnifiedEncoder(w io.Writer, contextLines int) *UnifiedEncoder {
return &UnifiedEncoder{
Writer: w,
srcPrefix: "a/",
dstPrefix: "b/",
contextLines: contextLines,
}
}
// SetColor sets e's color configuration and returns e.
func (e *UnifiedEncoder) SetColor(colorConfig ColorConfig) *UnifiedEncoder {
e.color = colorConfig
return e
}
// SetSrcPrefix sets e's srcPrefix and returns e.
func (e *UnifiedEncoder) SetSrcPrefix(prefix string) *UnifiedEncoder {
e.srcPrefix = prefix
return e
}
// SetDstPrefix sets e's dstPrefix and returns e.
func (e *UnifiedEncoder) SetDstPrefix(prefix string) *UnifiedEncoder {
e.dstPrefix = prefix
return e
}
// Encode encodes patch.
func (e *UnifiedEncoder) Encode(patch Patch) error {
sb := &strings.Builder{}
if message := patch.Message(); message != "" {
sb.WriteString(message)
if !strings.HasSuffix(message, "\n") {
sb.WriteByte('\n')
}
}
for _, filePatch := range patch.FilePatches() {
e.writeFilePatchHeader(sb, filePatch)
g := newHunksGenerator(filePatch.Chunks(), e.contextLines)
for _, hunk := range g.Generate() {
hunk.writeTo(sb, e.color)
}
}
_, err := e.Write([]byte(sb.String()))
return err
}
func (e *UnifiedEncoder) writeFilePatchHeader(sb *strings.Builder, filePatch FilePatch) {
from, to := filePatch.Files()
if from == nil && to == nil {
return
}
isBinary := filePatch.IsBinary()
var lines []string
switch {
case from != nil && to != nil:
hashEquals := from.Hash() == to.Hash()
lines = append(lines,
fmt.Sprintf("diff --git %s%s %s%s",
e.srcPrefix, from.Path(), e.dstPrefix, to.Path()),
)
if from.Mode() != to.Mode() {
lines = append(lines,
fmt.Sprintf("old mode %o", from.Mode()),
fmt.Sprintf("new mode %o", to.Mode()),
)
}
if from.Path() != to.Path() {
lines = append(lines,
fmt.Sprintf("rename from %s", from.Path()),
fmt.Sprintf("rename to %s", to.Path()),
)
}
if from.Mode() != to.Mode() && !hashEquals {
lines = append(lines,
fmt.Sprintf("index %s..%s", from.Hash(), to.Hash()),
)
} else if !hashEquals {
lines = append(lines,
fmt.Sprintf("index %s..%s %o", from.Hash(), to.Hash(), from.Mode()),
)
}
if !hashEquals {
lines = e.appendPathLines(lines, e.srcPrefix+from.Path(), e.dstPrefix+to.Path(), isBinary)
}
case from == nil:
lines = append(lines,
fmt.Sprintf("diff --git %s %s", e.srcPrefix+to.Path(), e.dstPrefix+to.Path()),
fmt.Sprintf("new file mode %o", to.Mode()),
fmt.Sprintf("index %s..%s", plumbing.ZeroHash, to.Hash()),
)
lines = e.appendPathLines(lines, "/dev/null", e.dstPrefix+to.Path(), isBinary)
case to == nil:
lines = append(lines,
fmt.Sprintf("diff --git %s %s", e.srcPrefix+from.Path(), e.dstPrefix+from.Path()),
fmt.Sprintf("deleted file mode %o", from.Mode()),
fmt.Sprintf("index %s..%s", from.Hash(), plumbing.ZeroHash),
)
lines = e.appendPathLines(lines, e.srcPrefix+from.Path(), "/dev/null", isBinary)
}
sb.WriteString(e.color[Meta])
sb.WriteString(lines[0])
for _, line := range lines[1:] {
sb.WriteByte('\n')
sb.WriteString(line)
}
sb.WriteString(e.color.Reset(Meta))
sb.WriteByte('\n')
}
func (e *UnifiedEncoder) appendPathLines(lines []string, fromPath, toPath string, isBinary bool) []string {
if isBinary {
return append(lines,
fmt.Sprintf("Binary files %s and %s differ", fromPath, toPath),
)
}
return append(lines,
fmt.Sprintf("--- %s", fromPath),
fmt.Sprintf("+++ %s", toPath),
)
}
type hunksGenerator struct {
fromLine, toLine int
ctxLines int
chunks []Chunk
current *hunk
hunks []*hunk
beforeContext, afterContext []string
}
func newHunksGenerator(chunks []Chunk, ctxLines int) *hunksGenerator {
return &hunksGenerator{
chunks: chunks,
ctxLines: ctxLines,
}
}
func (g *hunksGenerator) Generate() []*hunk {
for i, chunk := range g.chunks {
lines := splitLines(chunk.Content())
nLines := len(lines)
switch chunk.Type() {
case Equal:
g.fromLine += nLines
g.toLine += nLines
g.processEqualsLines(lines, i)
case Delete:
if nLines != 0 {
g.fromLine++
}
g.processHunk(i, chunk.Type())
g.fromLine += nLines - 1
g.current.AddOp(chunk.Type(), lines...)
case Add:
if nLines != 0 {
g.toLine++
}
g.processHunk(i, chunk.Type())
g.toLine += nLines - 1
g.current.AddOp(chunk.Type(), lines...)
}
if i == len(g.chunks)-1 && g.current != nil {
g.hunks = append(g.hunks, g.current)
}
}
return g.hunks
}
func (g *hunksGenerator) processHunk(i int, op Operation) {
if g.current != nil {
return
}
var ctxPrefix string
linesBefore := len(g.beforeContext)
if linesBefore > g.ctxLines {
ctxPrefix = g.beforeContext[linesBefore-g.ctxLines-1]
g.beforeContext = g.beforeContext[linesBefore-g.ctxLines:]
linesBefore = g.ctxLines
}
g.current = &hunk{ctxPrefix: strings.TrimSuffix(ctxPrefix, "\n")}
g.current.AddOp(Equal, g.beforeContext...)
switch op {
case Delete:
g.current.fromLine, g.current.toLine =
g.addLineNumbers(g.fromLine, g.toLine, linesBefore, i, Add)
case Add:
g.current.toLine, g.current.fromLine =
g.addLineNumbers(g.toLine, g.fromLine, linesBefore, i, Delete)
}
g.beforeContext = nil
}
// addLineNumbers obtains the line numbers in a new chunk.
func (g *hunksGenerator) addLineNumbers(la, lb int, linesBefore int, i int, op Operation) (cla, clb int) {
cla = la - linesBefore
// we need to search for a reference for the next diff
switch {
case linesBefore != 0 && g.ctxLines != 0:
if lb > g.ctxLines {
clb = lb - g.ctxLines + 1
} else {
clb = 1
}
case g.ctxLines == 0:
clb = lb
case i != len(g.chunks)-1:
next := g.chunks[i+1]
if next.Type() == op || next.Type() == Equal {
// this diff will be into this chunk
clb = lb + 1
}
}
return
}
func (g *hunksGenerator) processEqualsLines(ls []string, i int) {
if g.current == nil {
g.beforeContext = append(g.beforeContext, ls...)
return
}
g.afterContext = append(g.afterContext, ls...)
if len(g.afterContext) <= g.ctxLines*2 && i != len(g.chunks)-1 {
g.current.AddOp(Equal, g.afterContext...)
g.afterContext = nil
} else {
ctxLines := g.ctxLines
if ctxLines > len(g.afterContext) {
ctxLines = len(g.afterContext)
}
g.current.AddOp(Equal, g.afterContext[:ctxLines]...)
g.hunks = append(g.hunks, g.current)
g.current = nil
g.beforeContext = g.afterContext[ctxLines:]
g.afterContext = nil
}
}
func splitLines(s string) []string {
out := splitLinesRegexp.FindAllString(s, -1)
if out[len(out)-1] == "" {
out = out[:len(out)-1]
}
return out
}
type hunk struct {
fromLine int
toLine int
fromCount int
toCount int
ctxPrefix string
ops []*op
}
func (h *hunk) writeTo(sb *strings.Builder, color ColorConfig) {
sb.WriteString(color[Frag])
sb.WriteString("@@ -")
if h.fromCount == 1 {
sb.WriteString(strconv.Itoa(h.fromLine))
} else {
sb.WriteString(strconv.Itoa(h.fromLine))
sb.WriteByte(',')
sb.WriteString(strconv.Itoa(h.fromCount))
}
sb.WriteString(" +")
if h.toCount == 1 {
sb.WriteString(strconv.Itoa(h.toLine))
} else {
sb.WriteString(strconv.Itoa(h.toLine))
sb.WriteByte(',')
sb.WriteString(strconv.Itoa(h.toCount))
}
sb.WriteString(" @@")
sb.WriteString(color.Reset(Frag))
if h.ctxPrefix != "" {
sb.WriteByte(' ')
sb.WriteString(color[Func])
sb.WriteString(h.ctxPrefix)
sb.WriteString(color.Reset(Func))
}
sb.WriteByte('\n')
for _, op := range h.ops {
op.writeTo(sb, color)
}
}
func (h *hunk) AddOp(t Operation, ss ...string) {
n := len(ss)
switch t {
case Add:
h.toCount += n
case Delete:
h.fromCount += n
case Equal:
h.toCount += n
h.fromCount += n
}
for _, s := range ss {
h.ops = append(h.ops, &op{s, t})
}
}
type op struct {
text string
t Operation
}
func (o *op) writeTo(sb *strings.Builder, color ColorConfig) {
colorKey := operationColorKey[o.t]
sb.WriteString(color[colorKey])
sb.WriteByte(operationChar[o.t])
if strings.HasSuffix(o.text, "\n") {
sb.WriteString(strings.TrimSuffix(o.text, "\n"))
} else {
sb.WriteString(o.text + "\n\\ No newline at end of file")
}
sb.WriteString(color.Reset(colorKey))
sb.WriteByte('\n')
}
go-git-5.13.2/plumbing/format/diff/unified_encoder_test.go 0000664 0000000 0000000 00000047553 14744245500 0023540 0 ustar 00root root 0000000 0000000 package diff
import (
"bytes"
"testing"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/color"
"github.com/go-git/go-git/v5/plumbing/filemode"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type UnifiedEncoderTestSuite struct{}
var _ = Suite(&UnifiedEncoderTestSuite{})
func (s *UnifiedEncoderTestSuite) TestBothFilesEmpty(c *C) {
buffer := bytes.NewBuffer(nil)
e := NewUnifiedEncoder(buffer, 1)
err := e.Encode(testPatch{filePatches: []testFilePatch{{}}})
c.Assert(err, IsNil)
}
func (s *UnifiedEncoderTestSuite) TestBinaryFile(c *C) {
buffer := bytes.NewBuffer(nil)
e := NewUnifiedEncoder(buffer, 1)
p := testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "binary",
seed: "something",
},
to: &testFile{
mode: filemode.Regular,
path: "binary",
seed: "otherthing",
},
}},
}
err := e.Encode(p)
c.Assert(err, IsNil)
c.Assert(buffer.String(), Equals, `diff --git a/binary b/binary
index a459bc245bdbc45e1bca99e7fe61731da5c48da4..6879395eacf3cc7e5634064ccb617ac7aa62be7d 100644
Binary files a/binary and b/binary differ
`)
}
func (s *UnifiedEncoderTestSuite) TestCustomSrcDstPrefix(c *C) {
buffer := bytes.NewBuffer(nil)
e := NewUnifiedEncoder(buffer, 1).SetSrcPrefix("source/prefix/").SetDstPrefix("dest/prefix/")
p := testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "binary",
seed: "something",
},
to: &testFile{
mode: filemode.Regular,
path: "binary",
seed: "otherthing",
},
}},
}
err := e.Encode(p)
c.Assert(err, IsNil)
c.Assert(buffer.String(), Equals, `diff --git source/prefix/binary dest/prefix/binary
index a459bc245bdbc45e1bca99e7fe61731da5c48da4..6879395eacf3cc7e5634064ccb617ac7aa62be7d 100644
Binary files source/prefix/binary and dest/prefix/binary differ
`)
}
func (s *UnifiedEncoderTestSuite) TestEncode(c *C) {
for _, f := range fixtures {
c.Log("executing: ", f.desc)
buffer := bytes.NewBuffer(nil)
e := NewUnifiedEncoder(buffer, f.context).SetColor(f.color)
err := e.Encode(f.patch)
c.Assert(err, IsNil)
c.Assert(buffer.String(), Equals, f.diff)
}
}
var oneChunkPatch Patch = testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "onechunk.txt",
seed: "A\nB\nC\nD\nE\nF\nG\nH\nI\nJ\nK\nL\nM\nN\nÑ\nO\nP\nQ\nR\nS\nT\nU\nV\nW\nX\nY\nZ",
},
to: &testFile{
mode: filemode.Regular,
path: "onechunk.txt",
seed: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\nY\nZ",
},
chunks: []testChunk{{
content: "A\n",
op: Delete,
}, {
content: "B\nC\nD\nE\nF\nG\n",
op: Equal,
}, {
content: "H\n",
op: Delete,
}, {
content: "I\nJ\nK\nL\nM\nN\n",
op: Equal,
}, {
content: "Ñ\n",
op: Delete,
}, {
content: "O\nP\nQ\nR\nS\nT\n",
op: Equal,
}, {
content: "U\n",
op: Delete,
}, {
content: "V\nW\nX\nY\nZ",
op: Equal,
}},
}},
}
var oneChunkPatchInverted Patch = testPatch{
message: "",
filePatches: []testFilePatch{{
to: &testFile{
mode: filemode.Regular,
path: "onechunk.txt",
seed: "A\nB\nC\nD\nE\nF\nG\nH\nI\nJ\nK\nL\nM\nN\nÑ\nO\nP\nQ\nR\nS\nT\nU\nV\nW\nX\nY\nZ",
},
from: &testFile{
mode: filemode.Regular,
path: "onechunk.txt",
seed: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\nY\nZ",
},
chunks: []testChunk{{
content: "A\n",
op: Add,
}, {
content: "B\nC\nD\nE\nF\nG\n",
op: Equal,
}, {
content: "H\n",
op: Add,
}, {
content: "I\nJ\nK\nL\nM\nN\n",
op: Equal,
}, {
content: "Ñ\n",
op: Add,
}, {
content: "O\nP\nQ\nR\nS\nT\n",
op: Equal,
}, {
content: "U\n",
op: Add,
}, {
content: "V\nW\nX\nY\nZ",
op: Equal,
}},
}},
}
var fixtures []*fixture = []*fixture{{
patch: testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "README.md",
seed: "hello\nworld\n",
},
to: &testFile{
mode: filemode.Regular,
path: "README.md",
seed: "hello\nbug\n",
},
chunks: []testChunk{{
content: "hello\n",
op: Equal,
}, {
content: "world\n",
op: Delete,
}, {
content: "bug\n",
op: Add,
}},
}},
},
desc: "positive negative number",
context: 2,
diff: `diff --git a/README.md b/README.md
index 94954abda49de8615a048f8d2e64b5de848e27a1..f3dad9514629b9ff9136283ae331ad1fc95748a8 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,2 @@
hello
-world
+bug
`,
}, {
patch: testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "test.txt",
seed: "test",
},
to: &testFile{
mode: filemode.Executable,
path: "test.txt",
seed: "test",
},
chunks: nil,
}},
},
desc: "make executable",
context: 1,
diff: `diff --git a/test.txt b/test.txt
old mode 100644
new mode 100755
`,
}, {
patch: testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "test.txt",
seed: "test",
},
to: &testFile{
mode: filemode.Regular,
path: "test1.txt",
seed: "test",
},
chunks: nil,
}},
},
desc: "rename file",
context: 1,
diff: `diff --git a/test.txt b/test1.txt
rename from test.txt
rename to test1.txt
`,
}, {
patch: testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "test.txt",
seed: "test\n",
},
to: &testFile{
mode: filemode.Regular,
path: "test1.txt",
seed: "test1\n",
},
chunks: []testChunk{{
content: "test\n",
op: Delete,
}, {
content: "test1\n",
op: Add,
}},
}},
},
desc: "rename file with changes",
context: 1,
diff: `diff --git a/test.txt b/test1.txt
rename from test.txt
rename to test1.txt
index 9daeafb9864cf43055ae93beb0afd6c7d144bfa4..a5bce3fd2565d8f458555a0c6f42d0504a848bd5 100644
--- a/test.txt
+++ b/test1.txt
@@ -1 +1 @@
-test
+test1
`,
}, {
patch: testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "test.txt",
seed: "test",
},
to: &testFile{
mode: filemode.Executable,
path: "test1.txt",
seed: "test",
},
chunks: nil,
}},
},
desc: "rename with file mode change",
context: 1,
diff: `diff --git a/test.txt b/test1.txt
old mode 100644
new mode 100755
rename from test.txt
rename to test1.txt
`,
}, {
patch: testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "test.txt",
seed: "test\n",
},
to: &testFile{
mode: filemode.Regular,
path: "test.txt",
seed: "test2\n",
},
chunks: []testChunk{{
content: "test\n",
op: Delete,
}, {
content: "test2\n",
op: Add,
}},
}},
},
desc: "one line change",
context: 1,
diff: `diff --git a/test.txt b/test.txt
index 9daeafb9864cf43055ae93beb0afd6c7d144bfa4..180cf8328022becee9aaa2577a8f84ea2b9f3827 100644
--- a/test.txt
+++ b/test.txt
@@ -1 +1 @@
-test
+test2
`,
}, {
patch: testPatch{
message: "this is the message\n",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "test.txt",
seed: "test\n",
},
to: &testFile{
mode: filemode.Regular,
path: "test.txt",
seed: "test2\n",
},
chunks: []testChunk{{
content: "test\n",
op: Delete,
}, {
content: "test2\n",
op: Add,
}},
}},
},
desc: "one line change with message",
context: 1,
diff: `this is the message
diff --git a/test.txt b/test.txt
index 9daeafb9864cf43055ae93beb0afd6c7d144bfa4..180cf8328022becee9aaa2577a8f84ea2b9f3827 100644
--- a/test.txt
+++ b/test.txt
@@ -1 +1 @@
-test
+test2
`,
}, {
patch: testPatch{
message: "this is the message",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "test.txt",
seed: "test",
},
to: &testFile{
mode: filemode.Regular,
path: "test.txt",
seed: "test2",
},
chunks: []testChunk{{
content: "test",
op: Delete,
}, {
content: "test2",
op: Add,
}},
}},
},
desc: "one line change with message and no end of line",
context: 1,
diff: `this is the message
diff --git a/test.txt b/test.txt
index 30d74d258442c7c65512eafab474568dd706c430..d606037cb232bfda7788a8322492312d55b2ae9d 100644
--- a/test.txt
+++ b/test.txt
@@ -1 +1 @@
-test
\ No newline at end of file
+test2
\ No newline at end of file
`,
}, {
patch: testPatch{
message: "",
filePatches: []testFilePatch{{
from: nil,
to: &testFile{
mode: filemode.Regular,
path: "new.txt",
seed: "test\ntest2\ntest3",
},
chunks: []testChunk{{
content: "test\ntest2\ntest3",
op: Add,
}},
}},
},
desc: "new file",
context: 1,
diff: `diff --git a/new.txt b/new.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3ceaab5442b64a0c2b33dd25fae67ccdb4fd1ea8
--- /dev/null
+++ b/new.txt
@@ -0,0 +1,3 @@
+test
+test2
+test3
\ No newline at end of file
`,
}, {
patch: testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "old.txt",
seed: "test",
},
to: nil,
chunks: []testChunk{{
content: "test",
op: Delete,
}},
}},
},
desc: "delete file",
context: 1,
diff: `diff --git a/old.txt b/old.txt
deleted file mode 100644
index 30d74d258442c7c65512eafab474568dd706c430..0000000000000000000000000000000000000000
--- a/old.txt
+++ /dev/null
@@ -1 +0,0 @@
-test
\ No newline at end of file
`,
}, {
patch: oneChunkPatch,
desc: "modified deleting lines file with context to 1",
context: 1,
diff: `diff --git a/onechunk.txt b/onechunk.txt
index ab5eed5d4a2c33aeef67e0188ee79bed666bde6f..0adddcde4fd38042c354518351820eb06c417c82 100644
--- a/onechunk.txt
+++ b/onechunk.txt
@@ -1,2 +1 @@
-A
B
@@ -7,3 +6,2 @@ F
G
-H
I
@@ -14,3 +12,2 @@ M
N
-Ñ
O
@@ -21,3 +18,2 @@ S
T
-U
V
`,
}, {
patch: oneChunkPatch,
desc: "modified deleting lines file with context to 2",
context: 2,
diff: `diff --git a/onechunk.txt b/onechunk.txt
index ab5eed5d4a2c33aeef67e0188ee79bed666bde6f..0adddcde4fd38042c354518351820eb06c417c82 100644
--- a/onechunk.txt
+++ b/onechunk.txt
@@ -1,3 +1,2 @@
-A
B
C
@@ -6,5 +5,4 @@ E
F
G
-H
I
J
@@ -13,5 +11,4 @@ L
M
N
-Ñ
O
P
@@ -20,5 +17,4 @@ R
S
T
-U
V
W
`,
}, {
patch: oneChunkPatch,
desc: "modified deleting lines file with context to 6",
context: 6,
diff: `diff --git a/onechunk.txt b/onechunk.txt
index ab5eed5d4a2c33aeef67e0188ee79bed666bde6f..0adddcde4fd38042c354518351820eb06c417c82 100644
--- a/onechunk.txt
+++ b/onechunk.txt
@@ -1,27 +1,23 @@
-A
B
C
D
E
F
G
-H
I
J
K
L
M
N
-Ñ
O
P
Q
R
S
T
-U
V
W
X
Y
Z
\ No newline at end of file
`,
}, {
patch: oneChunkPatch,
desc: "modified deleting lines file with context to 3",
context: 3,
diff: `diff --git a/onechunk.txt b/onechunk.txt
index ab5eed5d4a2c33aeef67e0188ee79bed666bde6f..0adddcde4fd38042c354518351820eb06c417c82 100644
--- a/onechunk.txt
+++ b/onechunk.txt
@@ -1,25 +1,21 @@
-A
B
C
D
E
F
G
-H
I
J
K
L
M
N
-Ñ
O
P
Q
R
S
T
-U
V
W
X
`,
}, {
patch: oneChunkPatch,
desc: "modified deleting lines file with context to 4",
context: 4,
diff: `diff --git a/onechunk.txt b/onechunk.txt
index ab5eed5d4a2c33aeef67e0188ee79bed666bde6f..0adddcde4fd38042c354518351820eb06c417c82 100644
--- a/onechunk.txt
+++ b/onechunk.txt
@@ -1,26 +1,22 @@
-A
B
C
D
E
F
G
-H
I
J
K
L
M
N
-Ñ
O
P
Q
R
S
T
-U
V
W
X
Y
`,
}, {
patch: oneChunkPatch,
desc: "modified deleting lines file with context to 0",
context: 0,
diff: `diff --git a/onechunk.txt b/onechunk.txt
index ab5eed5d4a2c33aeef67e0188ee79bed666bde6f..0adddcde4fd38042c354518351820eb06c417c82 100644
--- a/onechunk.txt
+++ b/onechunk.txt
@@ -1 +0,0 @@
-A
@@ -8 +6,0 @@ G
-H
@@ -15 +12,0 @@ N
-Ñ
@@ -22 +18,0 @@ T
-U
`,
}, {
patch: oneChunkPatchInverted,
desc: "modified adding lines file with context to 1",
context: 1,
diff: `diff --git a/onechunk.txt b/onechunk.txt
index 0adddcde4fd38042c354518351820eb06c417c82..ab5eed5d4a2c33aeef67e0188ee79bed666bde6f 100644
--- a/onechunk.txt
+++ b/onechunk.txt
@@ -1 +1,2 @@
+A
B
@@ -6,2 +7,3 @@ F
G
+H
I
@@ -12,2 +14,3 @@ M
N
+Ñ
O
@@ -18,2 +21,3 @@ S
T
+U
V
`,
}, {
patch: oneChunkPatchInverted,
desc: "modified adding lines file with context to 2",
context: 2,
diff: `diff --git a/onechunk.txt b/onechunk.txt
index 0adddcde4fd38042c354518351820eb06c417c82..ab5eed5d4a2c33aeef67e0188ee79bed666bde6f 100644
--- a/onechunk.txt
+++ b/onechunk.txt
@@ -1,2 +1,3 @@
+A
B
C
@@ -5,4 +6,5 @@ E
F
G
+H
I
J
@@ -11,4 +13,5 @@ L
M
N
+Ñ
O
P
@@ -17,4 +20,5 @@ R
S
T
+U
V
W
`,
}, {
patch: oneChunkPatchInverted,
desc: "modified adding lines file with context to 3",
context: 3,
diff: `diff --git a/onechunk.txt b/onechunk.txt
index 0adddcde4fd38042c354518351820eb06c417c82..ab5eed5d4a2c33aeef67e0188ee79bed666bde6f 100644
--- a/onechunk.txt
+++ b/onechunk.txt
@@ -1,21 +1,25 @@
+A
B
C
D
E
F
G
+H
I
J
K
L
M
N
+Ñ
O
P
Q
R
S
T
+U
V
W
X
`,
}, {
patch: oneChunkPatchInverted,
desc: "modified adding lines file with context to 4",
context: 4,
diff: `diff --git a/onechunk.txt b/onechunk.txt
index 0adddcde4fd38042c354518351820eb06c417c82..ab5eed5d4a2c33aeef67e0188ee79bed666bde6f 100644
--- a/onechunk.txt
+++ b/onechunk.txt
@@ -1,22 +1,26 @@
+A
B
C
D
E
F
G
+H
I
J
K
L
M
N
+Ñ
O
P
Q
R
S
T
+U
V
W
X
Y
`,
}, {
patch: oneChunkPatchInverted,
desc: "modified adding lines file with context to 0",
context: 0,
diff: `diff --git a/onechunk.txt b/onechunk.txt
index 0adddcde4fd38042c354518351820eb06c417c82..ab5eed5d4a2c33aeef67e0188ee79bed666bde6f 100644
--- a/onechunk.txt
+++ b/onechunk.txt
@@ -0,0 +1 @@
+A
@@ -6,0 +8 @@ G
+H
@@ -12,0 +15 @@ N
+Ñ
@@ -18,0 +22 @@ T
+U
`,
}, {
patch: testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "onechunk.txt",
seed: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\nY\nZ",
},
to: &testFile{
mode: filemode.Regular,
path: "onechunk.txt",
seed: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\nY\n",
},
chunks: []testChunk{{
content: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\nY\n",
op: Equal,
}, {
content: "Z",
op: Delete,
}},
}},
},
desc: "remove last letter",
context: 0,
diff: `diff --git a/onechunk.txt b/onechunk.txt
index 0adddcde4fd38042c354518351820eb06c417c82..553ae669c7a9303cf848fcc749a2569228ac5309 100644
--- a/onechunk.txt
+++ b/onechunk.txt
@@ -23 +22,0 @@ Y
-Z
\ No newline at end of file
`,
}, {
patch: testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "onechunk.txt",
seed: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\nY\nZ",
},
to: &testFile{
mode: filemode.Regular,
path: "onechunk.txt",
seed: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\nY",
},
chunks: []testChunk{{
content: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\n",
op: Equal,
}, {
content: "Y\nZ",
op: Delete,
}, {
content: "Y",
op: Add,
}},
}},
},
desc: "remove last letter and no newline at end of file",
context: 0,
diff: `diff --git a/onechunk.txt b/onechunk.txt
index 0adddcde4fd38042c354518351820eb06c417c82..d39ae38aad7ba9447b5e7998b2e4714f26c9218d 100644
--- a/onechunk.txt
+++ b/onechunk.txt
@@ -22,2 +21 @@ X
-Y
-Z
\ No newline at end of file
+Y
\ No newline at end of file
`,
}, {
patch: testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "README.md",
seed: "hello\nworld\n",
},
to: &testFile{
mode: filemode.Regular,
path: "README.md",
seed: "hello\nbug\n",
},
chunks: []testChunk{{
content: "hello\n",
op: Equal,
}, {
content: "world\n",
op: Delete,
}, {
content: "bug\n",
op: Add,
}},
}},
},
desc: "positive negative number with color",
context: 2,
color: NewColorConfig(),
diff: "" +
color.Bold + "diff --git a/README.md b/README.md\n" +
"index 94954abda49de8615a048f8d2e64b5de848e27a1..f3dad9514629b9ff9136283ae331ad1fc95748a8 100644\n" +
"--- a/README.md\n" +
"+++ b/README.md" + color.Reset + "\n" +
color.Cyan + "@@ -1,2 +1,2 @@" + color.Reset + "\n" +
" hello\n" +
color.Red + "-world" + color.Reset + "\n" +
color.Green + "+bug" + color.Reset + "\n",
}, {
patch: testPatch{
message: "",
filePatches: []testFilePatch{{
from: &testFile{
mode: filemode.Regular,
path: "test.txt",
seed: "test\n",
},
to: &testFile{
mode: filemode.Regular,
path: "test.txt",
seed: "test2\n",
},
chunks: []testChunk{{
content: "test\n",
op: Delete,
}, {
content: "test2\n",
op: Add,
}},
}},
},
desc: "one line change with color",
context: 1,
color: NewColorConfig(
WithColor(Func, color.Reverse),
),
diff: "" +
color.Bold + "diff --git a/test.txt b/test.txt\n" +
"index 9daeafb9864cf43055ae93beb0afd6c7d144bfa4..180cf8328022becee9aaa2577a8f84ea2b9f3827 100644\n" +
"--- a/test.txt\n" +
"+++ b/test.txt" + color.Reset + "\n" +
color.Cyan + "@@ -1 +1 @@" + color.Reset + "\n" +
color.Red + "-test" + color.Reset + "\n" +
color.Green + "+test2" + color.Reset + "\n",
}, {
patch: oneChunkPatch,
desc: "modified deleting lines file with context to 1 with color",
context: 1,
color: NewColorConfig(
WithColor(Func, color.Reverse),
),
diff: "" +
color.Bold + "diff --git a/onechunk.txt b/onechunk.txt\n" +
"index ab5eed5d4a2c33aeef67e0188ee79bed666bde6f..0adddcde4fd38042c354518351820eb06c417c82 100644\n" +
"--- a/onechunk.txt\n" +
"+++ b/onechunk.txt" + color.Reset + "\n" +
color.Cyan + "@@ -1,2 +1 @@" + color.Reset + "\n" +
color.Red + "-A" + color.Reset + "\n" +
" B\n" +
color.Cyan + "@@ -7,3 +6,2 @@" + color.Reset + " " + color.Reverse + "F" + color.Reset + "\n" +
" G\n" +
color.Red + "-H" + color.Reset + "\n" +
" I\n" +
color.Cyan + "@@ -14,3 +12,2 @@" + color.Reset + " " + color.Reverse + "M" + color.Reset + "\n" +
" N\n" +
color.Red + "-Ñ" + color.Reset + "\n" +
" O\n" +
color.Cyan + "@@ -21,3 +18,2 @@" + color.Reset + " " + color.Reverse + "S" + color.Reset + "\n" +
" T\n" +
color.Red + "-U" + color.Reset + "\n" +
" V\n",
}}
type testPatch struct {
message string
filePatches []testFilePatch
}
func (t testPatch) FilePatches() []FilePatch {
var result []FilePatch
for _, f := range t.filePatches {
result = append(result, f)
}
return result
}
func (t testPatch) Message() string {
return t.message
}
type testFilePatch struct {
from, to *testFile
chunks []testChunk
}
func (t testFilePatch) IsBinary() bool {
return len(t.chunks) == 0
}
func (t testFilePatch) Files() (File, File) {
// Go is amazing
switch {
case t.from == nil && t.to == nil:
return nil, nil
case t.from == nil:
return nil, t.to
case t.to == nil:
return t.from, nil
}
return t.from, t.to
}
func (t testFilePatch) Chunks() []Chunk {
var result []Chunk
for _, c := range t.chunks {
result = append(result, c)
}
return result
}
type testFile struct {
path string
mode filemode.FileMode
seed string
}
func (t testFile) Hash() plumbing.Hash {
return plumbing.ComputeHash(plumbing.BlobObject, []byte(t.seed))
}
func (t testFile) Mode() filemode.FileMode {
return t.mode
}
func (t testFile) Path() string {
return t.path
}
type testChunk struct {
content string
op Operation
}
func (t testChunk) Content() string {
return t.content
}
func (t testChunk) Type() Operation {
return t.op
}
type fixture struct {
desc string
context int
color ColorConfig
diff string
patch Patch
}
go-git-5.13.2/plumbing/format/gitattributes/ 0000775 0000000 0000000 00000000000 14744245500 0020774 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/format/gitattributes/attributes.go 0000664 0000000 0000000 00000010174 14744245500 0023514 0 ustar 00root root 0000000 0000000 package gitattributes
import (
"bufio"
"errors"
"io"
"strings"
)
const (
commentPrefix = "#"
eol = "\n"
macroPrefix = "[attr]"
)
var (
ErrMacroNotAllowed = errors.New("macro not allowed")
ErrInvalidAttributeName = errors.New("invalid attribute name")
)
type MatchAttribute struct {
Name string
Pattern Pattern
Attributes []Attribute
}
type attributeState byte
const (
attributeUnknown attributeState = 0
attributeSet attributeState = 1
attributeUnspecified attributeState = '!'
attributeUnset attributeState = '-'
attributeSetValue attributeState = '='
)
type Attribute interface {
Name() string
IsSet() bool
IsUnset() bool
IsUnspecified() bool
IsValueSet() bool
Value() string
String() string
}
type attribute struct {
name string
state attributeState
value string
}
func (a attribute) Name() string {
return a.name
}
func (a attribute) IsSet() bool {
return a.state == attributeSet
}
func (a attribute) IsUnset() bool {
return a.state == attributeUnset
}
func (a attribute) IsUnspecified() bool {
return a.state == attributeUnspecified
}
func (a attribute) IsValueSet() bool {
return a.state == attributeSetValue
}
func (a attribute) Value() string {
return a.value
}
func (a attribute) String() string {
switch a.state {
case attributeSet:
return a.name + ": set"
case attributeUnset:
return a.name + ": unset"
case attributeUnspecified:
return a.name + ": unspecified"
default:
return a.name + ": " + a.value
}
}
// ReadAttributes reads patterns and attributes from the gitattributes format.
func ReadAttributes(r io.Reader, domain []string, allowMacro bool) (attributes []MatchAttribute, err error) {
scanner := bufio.NewScanner(r)
for scanner.Scan() {
attribute, err := ParseAttributesLine(scanner.Text(), domain, allowMacro)
if err != nil {
return attributes, err
}
if len(attribute.Name) == 0 {
continue
}
attributes = append(attributes, attribute)
}
if err := scanner.Err(); err != nil {
return attributes, err
}
return attributes, nil
}
// ParseAttributesLine parses a gitattribute line, extracting path pattern and
// attributes.
func ParseAttributesLine(line string, domain []string, allowMacro bool) (m MatchAttribute, err error) {
line = strings.TrimSpace(line)
if strings.HasPrefix(line, commentPrefix) || len(line) == 0 {
return
}
name, unquoted := unquote(line)
attrs := strings.Fields(unquoted)
if len(name) == 0 {
name = attrs[0]
attrs = attrs[1:]
}
var macro bool
macro, name, err = checkMacro(name, allowMacro)
if err != nil {
return
}
m.Name = name
m.Attributes = make([]Attribute, 0, len(attrs))
for _, attrName := range attrs {
attr := attribute{
name: attrName,
state: attributeSet,
}
// ! and - prefixes
state := attributeState(attr.name[0])
if state == attributeUnspecified || state == attributeUnset {
attr.state = state
attr.name = attr.name[1:]
}
kv := strings.SplitN(attrName, "=", 2)
if len(kv) == 2 {
attr.name = kv[0]
attr.value = kv[1]
attr.state = attributeSetValue
}
if !validAttributeName(attr.name) {
return m, ErrInvalidAttributeName
}
m.Attributes = append(m.Attributes, attr)
}
if !macro {
m.Pattern = ParsePattern(name, domain)
}
return
}
func checkMacro(name string, allowMacro bool) (macro bool, macroName string, err error) {
if !strings.HasPrefix(name, macroPrefix) {
return false, name, nil
}
if !allowMacro {
return true, name, ErrMacroNotAllowed
}
macroName = name[len(macroPrefix):]
if !validAttributeName(macroName) {
return true, name, ErrInvalidAttributeName
}
return true, macroName, nil
}
func validAttributeName(name string) bool {
if len(name) == 0 || name[0] == '-' {
return false
}
for _, ch := range name {
if !(ch == '-' || ch == '.' || ch == '_' ||
('0' <= ch && ch <= '9') ||
('a' <= ch && ch <= 'z') ||
('A' <= ch && ch <= 'Z')) {
return false
}
}
return true
}
func unquote(str string) (string, string) {
if str[0] != '"' {
return "", str
}
for i := 1; i < len(str); i++ {
switch str[i] {
case '\\':
i++
case '"':
return str[1:i], str[i+1:]
}
}
return "", str
}
go-git-5.13.2/plumbing/format/gitattributes/attributes_test.go 0000664 0000000 0000000 00000003620 14744245500 0024551 0 ustar 00root root 0000000 0000000 package gitattributes
import (
"strings"
. "gopkg.in/check.v1"
)
type AttributesSuite struct{}
var _ = Suite(&AttributesSuite{})
func (s *AttributesSuite) TestAttributes_ReadAttributes(c *C) {
lines := []string{
"[attr]sub -a",
"[attr]add a",
"* sub a",
"* !a foo=bar -b c",
}
mas, err := ReadAttributes(strings.NewReader(strings.Join(lines, "\n")), nil, true)
c.Assert(err, IsNil)
c.Assert(len(mas), Equals, 4)
c.Assert(mas[0].Name, Equals, "sub")
c.Assert(mas[0].Pattern, IsNil)
c.Assert(mas[0].Attributes[0].IsUnset(), Equals, true)
c.Assert(mas[1].Name, Equals, "add")
c.Assert(mas[1].Pattern, IsNil)
c.Assert(mas[1].Attributes[0].IsSet(), Equals, true)
c.Assert(mas[2].Name, Equals, "*")
c.Assert(mas[2].Pattern, NotNil)
c.Assert(mas[2].Attributes[0].IsSet(), Equals, true)
c.Assert(mas[3].Name, Equals, "*")
c.Assert(mas[3].Pattern, NotNil)
c.Assert(mas[3].Attributes[0].IsUnspecified(), Equals, true)
c.Assert(mas[3].Attributes[1].IsValueSet(), Equals, true)
c.Assert(mas[3].Attributes[1].Value(), Equals, "bar")
c.Assert(mas[3].Attributes[2].IsUnset(), Equals, true)
c.Assert(mas[3].Attributes[3].IsSet(), Equals, true)
c.Assert(mas[3].Attributes[0].String(), Equals, "a: unspecified")
c.Assert(mas[3].Attributes[1].String(), Equals, "foo: bar")
c.Assert(mas[3].Attributes[2].String(), Equals, "b: unset")
c.Assert(mas[3].Attributes[3].String(), Equals, "c: set")
}
func (s *AttributesSuite) TestAttributes_ReadAttributesDisallowMacro(c *C) {
lines := []string{
"[attr]sub -a",
"* a add",
}
_, err := ReadAttributes(strings.NewReader(strings.Join(lines, "\n")), nil, false)
c.Assert(err, Equals, ErrMacroNotAllowed)
}
func (s *AttributesSuite) TestAttributes_ReadAttributesInvalidName(c *C) {
lines := []string{
"[attr]foo!bar -a",
}
_, err := ReadAttributes(strings.NewReader(strings.Join(lines, "\n")), nil, true)
c.Assert(err, Equals, ErrInvalidAttributeName)
}
go-git-5.13.2/plumbing/format/gitattributes/dir.go 0000664 0000000 0000000 00000007732 14744245500 0022112 0 ustar 00root root 0000000 0000000 package gitattributes
import (
"os"
"path/filepath"
"strings"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-git/v5/plumbing/format/config"
gioutil "github.com/go-git/go-git/v5/utils/ioutil"
)
const (
coreSection = "core"
attributesfile = "attributesfile"
gitDir = ".git"
gitattributesFile = ".gitattributes"
gitconfigFile = ".gitconfig"
systemFile = "/etc/gitconfig"
)
func ReadAttributesFile(fs billy.Filesystem, path []string, attributesFile string, allowMacro bool) ([]MatchAttribute, error) {
f, err := fs.Open(fs.Join(append(path, attributesFile)...))
if os.IsNotExist(err) {
return nil, nil
}
if err != nil {
return nil, err
}
defer gioutil.CheckClose(f, &err)
return ReadAttributes(f, path, allowMacro)
}
// ReadPatterns reads gitattributes patterns recursively through the directory
// structure. The result is in ascending order of priority (last higher).
//
// The .gitattribute file in the root directory will allow custom macro
// definitions. Custom macro definitions in other directories .gitattributes
// will return an error.
func ReadPatterns(fs billy.Filesystem, path []string) (attributes []MatchAttribute, err error) {
attributes, err = ReadAttributesFile(fs, path, gitattributesFile, true)
if err != nil {
return
}
attrs, err := walkDirectory(fs, path)
return append(attributes, attrs...), err
}
func walkDirectory(fs billy.Filesystem, root []string) (attributes []MatchAttribute, err error) {
fis, err := fs.ReadDir(fs.Join(root...))
if err != nil {
return attributes, err
}
for _, fi := range fis {
if !fi.IsDir() || fi.Name() == ".git" {
continue
}
p := fi.Name()
// Handles the case whereby just the volume name ("C:") is appended,
// to root. Change it to "C:\", which is better handled by fs.Join().
if filepath.VolumeName(p) != "" && !strings.HasSuffix(p, string(filepath.Separator)) {
p = p + string(filepath.Separator)
}
path := append(root, p)
dirAttributes, err := ReadAttributesFile(fs, path, gitattributesFile, false)
if err != nil {
return attributes, err
}
subAttributes, err := walkDirectory(fs, path)
if err != nil {
return attributes, err
}
attributes = append(attributes, append(dirAttributes, subAttributes...)...)
}
return
}
func loadPatterns(fs billy.Filesystem, path string) ([]MatchAttribute, error) {
f, err := fs.Open(path)
if os.IsNotExist(err) {
return nil, nil
}
if err != nil {
return nil, err
}
defer gioutil.CheckClose(f, &err)
raw := config.New()
if err = config.NewDecoder(f).Decode(raw); err != nil {
return nil, nil
}
path = raw.Section(coreSection).Options.Get(attributesfile)
if path == "" {
return nil, nil
}
return ReadAttributesFile(fs, nil, path, true)
}
// LoadGlobalPatterns loads gitattributes patterns and attributes from the
// gitattributes file declared in a user's ~/.gitconfig file. If the
// ~/.gitconfig file does not exist the function will return nil. If the
// core.attributesFile property is not declared, the function will return nil.
// If the file pointed to by the core.attributesfile property does not exist,
// the function will return nil. The function assumes fs is rooted at the root
// filesystem.
func LoadGlobalPatterns(fs billy.Filesystem) (attributes []MatchAttribute, err error) {
home, err := os.UserHomeDir()
if err != nil {
return
}
return loadPatterns(fs, fs.Join(home, gitconfigFile))
}
// LoadSystemPatterns loads gitattributes patterns and attributes from the
// gitattributes file declared in a system's /etc/gitconfig file. If the
// /etc/gitconfig file does not exist the function will return nil. If the
// core.attributesfile property is not declared, the function will return nil.
// If the file pointed to by the core.attributesfile property does not exist,
// the function will return nil. The function assumes fs is rooted at the root
// filesystem.
func LoadSystemPatterns(fs billy.Filesystem) (attributes []MatchAttribute, err error) {
return loadPatterns(fs, systemFile)
}
go-git-5.13.2/plumbing/format/gitattributes/dir_test.go 0000664 0000000 0000000 00000012364 14744245500 0023146 0 ustar 00root root 0000000 0000000 package gitattributes
import (
"os"
"strconv"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/memfs"
. "gopkg.in/check.v1"
)
type MatcherSuite struct {
GFS billy.Filesystem // git repository root
RFS billy.Filesystem // root that contains user home
MCFS billy.Filesystem // root that contains user home, but missing ~/.gitattributes
MEFS billy.Filesystem // root that contains user home, but missing attributesfile entry
MIFS billy.Filesystem // root that contains user home, but missing .gitattributes
SFS billy.Filesystem // root that contains /etc/gitattributes
}
var _ = Suite(&MatcherSuite{})
func (s *MatcherSuite) SetUpTest(c *C) {
home, err := os.UserHomeDir()
c.Assert(err, IsNil)
gitAttributesGlobal := func(fs billy.Filesystem, filename string) {
f, err := fs.Create(filename)
c.Assert(err, IsNil)
_, err = f.Write([]byte("# IntelliJ\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(".idea/** text\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("*.iml -text\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
}
// setup generic git repository root
fs := memfs.New()
f, err := fs.Create(".gitattributes")
c.Assert(err, IsNil)
_, err = f.Write([]byte("vendor/g*/** foo=bar\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
err = fs.MkdirAll("vendor", os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create("vendor/.gitattributes")
c.Assert(err, IsNil)
_, err = f.Write([]byte("github.com/** -foo\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
fs.MkdirAll("another", os.ModePerm)
fs.MkdirAll("vendor/github.com", os.ModePerm)
fs.MkdirAll("vendor/gopkg.in", os.ModePerm)
gitAttributesGlobal(fs, fs.Join(home, ".gitattributes_global"))
s.GFS = fs
fs = memfs.New()
err = fs.MkdirAll(home, os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create(fs.Join(home, gitconfigFile))
c.Assert(err, IsNil)
_, err = f.Write([]byte("[core]\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(" attributesfile = " + strconv.Quote(fs.Join(home, ".gitattributes_global")) + "\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
gitAttributesGlobal(fs, fs.Join(home, ".gitattributes_global"))
s.RFS = fs
// root that contains user home, but missing ~/.gitconfig
fs = memfs.New()
gitAttributesGlobal(fs, fs.Join(home, ".gitattributes_global"))
s.MCFS = fs
// setup root that contains user home, but missing attributesfile entry
fs = memfs.New()
err = fs.MkdirAll(home, os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create(fs.Join(home, gitconfigFile))
c.Assert(err, IsNil)
_, err = f.Write([]byte("[core]\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
gitAttributesGlobal(fs, fs.Join(home, ".gitattributes_global"))
s.MEFS = fs
// setup root that contains user home, but missing .gitattributes
fs = memfs.New()
err = fs.MkdirAll(home, os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create(fs.Join(home, gitconfigFile))
c.Assert(err, IsNil)
_, err = f.Write([]byte("[core]\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(" attributesfile = " + strconv.Quote(fs.Join(home, ".gitattributes_global")) + "\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
s.MIFS = fs
// setup root that contains user home
fs = memfs.New()
err = fs.MkdirAll("etc", os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create(systemFile)
c.Assert(err, IsNil)
_, err = f.Write([]byte("[core]\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(" attributesfile = /etc/gitattributes_global\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
gitAttributesGlobal(fs, "/etc/gitattributes_global")
s.SFS = fs
}
func (s *MatcherSuite) TestDir_ReadPatterns(c *C) {
ps, err := ReadPatterns(s.GFS, nil)
c.Assert(err, IsNil)
c.Assert(ps, HasLen, 2)
m := NewMatcher(ps)
results, _ := m.Match([]string{"vendor", "gopkg.in", "file"}, nil)
c.Assert(results["foo"].Value(), Equals, "bar")
results, _ = m.Match([]string{"vendor", "github.com", "file"}, nil)
c.Assert(results["foo"].IsUnset(), Equals, false)
}
func (s *MatcherSuite) TestDir_LoadGlobalPatterns(c *C) {
ps, err := LoadGlobalPatterns(s.RFS)
c.Assert(err, IsNil)
c.Assert(ps, HasLen, 2)
m := NewMatcher(ps)
results, _ := m.Match([]string{"go-git.v4.iml"}, nil)
c.Assert(results["text"].IsUnset(), Equals, true)
results, _ = m.Match([]string{".idea", "file"}, nil)
c.Assert(results["text"].IsSet(), Equals, true)
}
func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingGitconfig(c *C) {
ps, err := LoadGlobalPatterns(s.MCFS)
c.Assert(err, IsNil)
c.Assert(ps, HasLen, 0)
}
func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingAttributesfile(c *C) {
ps, err := LoadGlobalPatterns(s.MEFS)
c.Assert(err, IsNil)
c.Assert(ps, HasLen, 0)
}
func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingGitattributes(c *C) {
ps, err := LoadGlobalPatterns(s.MIFS)
c.Assert(err, IsNil)
c.Assert(ps, HasLen, 0)
}
func (s *MatcherSuite) TestDir_LoadSystemPatterns(c *C) {
ps, err := LoadSystemPatterns(s.SFS)
c.Assert(err, IsNil)
c.Assert(ps, HasLen, 2)
m := NewMatcher(ps)
results, _ := m.Match([]string{"go-git.v4.iml"}, nil)
c.Assert(results["text"].IsUnset(), Equals, true)
results, _ = m.Match([]string{".idea", "file"}, nil)
c.Assert(results["text"].IsSet(), Equals, true)
}
go-git-5.13.2/plumbing/format/gitattributes/matcher.go 0000664 0000000 0000000 00000003714 14744245500 0022753 0 ustar 00root root 0000000 0000000 package gitattributes
// Matcher defines a global multi-pattern matcher for gitattributes patterns
type Matcher interface {
// Match matches patterns in the order of priorities.
Match(path []string, attributes []string) (map[string]Attribute, bool)
}
type MatcherOptions struct{}
// NewMatcher constructs a new matcher. Patterns must be given in the order of
// increasing priority. That is the most generic settings files first, then the
// content of the repo .gitattributes, then content of .gitattributes down the
// path.
func NewMatcher(stack []MatchAttribute) Matcher {
m := &matcher{stack: stack}
m.init()
return m
}
type matcher struct {
stack []MatchAttribute
macros map[string]MatchAttribute
}
func (m *matcher) init() {
m.macros = make(map[string]MatchAttribute)
for _, attr := range m.stack {
if attr.Pattern == nil {
m.macros[attr.Name] = attr
}
}
}
// Match matches path against the patterns in gitattributes files and returns
// the attributes associated with the path.
//
// Specific attributes can be specified otherwise all attributes are returned.
//
// Matched is true if any path was matched to a rule, even if the results map
// is empty.
func (m *matcher) Match(path []string, attributes []string) (results map[string]Attribute, matched bool) {
results = make(map[string]Attribute, len(attributes))
n := len(m.stack)
for i := n - 1; i >= 0; i-- {
if len(attributes) > 0 && len(attributes) == len(results) {
return
}
pattern := m.stack[i].Pattern
if pattern == nil {
continue
}
if match := pattern.Match(path); match {
matched = true
for _, attr := range m.stack[i].Attributes {
if attr.IsSet() {
m.expandMacro(attr.Name(), results)
}
results[attr.Name()] = attr
}
}
}
return
}
func (m *matcher) expandMacro(name string, results map[string]Attribute) bool {
if macro, ok := m.macros[name]; ok {
for _, attr := range macro.Attributes {
results[attr.Name()] = attr
}
}
return false
}
go-git-5.13.2/plumbing/format/gitattributes/matcher_test.go 0000664 0000000 0000000 00000001412 14744245500 0024003 0 ustar 00root root 0000000 0000000 package gitattributes
import (
"strings"
. "gopkg.in/check.v1"
)
func (s *MatcherSuite) TestMatcher_Match(c *C) {
lines := []string{
"[attr]binary -diff -merge -text",
"**/middle/v[uo]l?ano binary text eol=crlf",
"volcano -eol",
"foobar diff merge text eol=lf foo=bar",
}
ma, err := ReadAttributes(strings.NewReader(strings.Join(lines, "\n")), nil, true)
c.Assert(err, IsNil)
m := NewMatcher(ma)
results, matched := m.Match([]string{"head", "middle", "vulkano"}, nil)
c.Assert(matched, Equals, true)
c.Assert(results["binary"].IsSet(), Equals, true)
c.Assert(results["diff"].IsUnset(), Equals, true)
c.Assert(results["merge"].IsUnset(), Equals, true)
c.Assert(results["text"].IsSet(), Equals, true)
c.Assert(results["eol"].Value(), Equals, "crlf")
}
go-git-5.13.2/plumbing/format/gitattributes/pattern.go 0000664 0000000 0000000 00000003532 14744245500 0023003 0 ustar 00root root 0000000 0000000 package gitattributes
import (
"path/filepath"
"strings"
)
const (
patternDirSep = "/"
zeroToManyDirs = "**"
)
// Pattern defines a gitattributes pattern.
type Pattern interface {
// Match matches the given path to the pattern.
Match(path []string) bool
}
type pattern struct {
domain []string
pattern []string
}
// ParsePattern parses a gitattributes pattern string into the Pattern
// structure.
func ParsePattern(p string, domain []string) Pattern {
return &pattern{
domain: domain,
pattern: strings.Split(p, patternDirSep),
}
}
func (p *pattern) Match(path []string) bool {
if len(path) <= len(p.domain) {
return false
}
for i, e := range p.domain {
if path[i] != e {
return false
}
}
if len(p.pattern) == 1 {
// for a simple rule, .gitattribute matching rules differs from
// .gitignore and only the last part of the path is considered.
path = path[len(path)-1:]
} else {
path = path[len(p.domain):]
}
pattern := p.pattern
var match, doublestar bool
var err error
for _, part := range path {
// path is deeper than pattern
if len(pattern) == 0 {
return false
}
// skip empty
if pattern[0] == "" {
pattern = pattern[1:]
}
// eat doublestar
if pattern[0] == zeroToManyDirs {
pattern = pattern[1:]
if len(pattern) == 0 {
return true
}
doublestar = true
}
switch {
case strings.Contains(pattern[0], "**"):
return false
// keep going down the path until we hit a match
case doublestar:
match, err = filepath.Match(pattern[0], part)
if err != nil {
return false
}
if match {
doublestar = false
pattern = pattern[1:]
}
default:
match, err = filepath.Match(pattern[0], part)
if err != nil {
return false
}
if !match {
return false
}
pattern = pattern[1:]
}
}
if len(pattern) > 0 {
return false
}
return match
}
go-git-5.13.2/plumbing/format/gitattributes/pattern_test.go 0000664 0000000 0000000 00000016264 14744245500 0024050 0 ustar 00root root 0000000 0000000 package gitattributes
import (
"testing"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type PatternSuite struct{}
var _ = Suite(&PatternSuite{})
func (s *PatternSuite) TestMatch_domainLonger_mismatch(c *C) {
p := ParsePattern("value", []string{"head", "middle", "tail"})
r := p.Match([]string{"head", "middle"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestMatch_domainSameLength_mismatch(c *C) {
p := ParsePattern("value", []string{"head", "middle", "tail"})
r := p.Match([]string{"head", "middle", "tail"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestMatch_domainMismatch_mismatch(c *C) {
p := ParsePattern("value", []string{"head", "middle", "tail"})
r := p.Match([]string{"head", "middle", "_tail_", "value"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestSimpleMatch_match(c *C) {
p := ParsePattern("vul?ano", nil)
r := p.Match([]string{"value", "vulkano"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestSimpleMatch_withDomain(c *C) {
p := ParsePattern("middle/tail", []string{"value", "volcano"})
r := p.Match([]string{"value", "volcano", "middle", "tail"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestSimpleMatch_onlyMatchInDomain_mismatch(c *C) {
p := ParsePattern("value/volcano", []string{"value", "volcano"})
r := p.Match([]string{"value", "volcano", "tail"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestSimpleMatch_atStart(c *C) {
p := ParsePattern("value", nil)
r := p.Match([]string{"value", "tail"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestSimpleMatch_inTheMiddle(c *C) {
p := ParsePattern("value", nil)
r := p.Match([]string{"head", "value", "tail"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestSimpleMatch_atEnd(c *C) {
p := ParsePattern("value", nil)
r := p.Match([]string{"head", "value"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestSimpleMatch_mismatch(c *C) {
p := ParsePattern("value", nil)
r := p.Match([]string{"head", "val", "tail"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestSimpleMatch_valueLonger_mismatch(c *C) {
p := ParsePattern("tai", nil)
r := p.Match([]string{"head", "value", "tail"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestSimpleMatch_withAsterisk(c *C) {
p := ParsePattern("t*l", nil)
r := p.Match([]string{"value", "vulkano", "tail"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestSimpleMatch_withQuestionMark(c *C) {
p := ParsePattern("ta?l", nil)
r := p.Match([]string{"value", "vulkano", "tail"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestSimpleMatch_magicChars(c *C) {
p := ParsePattern("v[ou]l[kc]ano", nil)
r := p.Match([]string{"value", "volcano"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestSimpleMatch_wrongPattern_mismatch(c *C) {
p := ParsePattern("v[ou]l[", nil)
r := p.Match([]string{"value", "vol["})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestGlobMatch_fromRootWithSlash(c *C) {
p := ParsePattern("/value/vul?ano/tail", nil)
r := p.Match([]string{"value", "vulkano", "tail"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestGlobMatch_withDomain(c *C) {
p := ParsePattern("middle/tail", []string{"value", "volcano"})
r := p.Match([]string{"value", "volcano", "middle", "tail"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestGlobMatch_onlyMatchInDomain_mismatch(c *C) {
p := ParsePattern("volcano/tail", []string{"value", "volcano"})
r := p.Match([]string{"value", "volcano", "tail"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestGlobMatch_fromRootWithoutSlash(c *C) {
p := ParsePattern("value/vul?ano/tail", nil)
r := p.Match([]string{"value", "vulkano", "tail"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestGlobMatch_fromRoot_mismatch(c *C) {
p := ParsePattern("value/vulkano", nil)
r := p.Match([]string{"value", "volcano"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestGlobMatch_fromRoot_tooShort_mismatch(c *C) {
p := ParsePattern("value/vul?ano", nil)
r := p.Match([]string{"value"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestGlobMatch_fromRoot_notAtRoot_mismatch(c *C) {
p := ParsePattern("/value/volcano", nil)
r := p.Match([]string{"value", "value", "volcano"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestGlobMatch_leadingAsterisks_atStart(c *C) {
p := ParsePattern("**/*lue/vol?ano/ta?l", nil)
r := p.Match([]string{"value", "volcano", "tail"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestGlobMatch_leadingAsterisks_notAtStart(c *C) {
p := ParsePattern("**/*lue/vol?ano/tail", nil)
r := p.Match([]string{"head", "value", "volcano", "tail"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestGlobMatch_leadingAsterisks_mismatch(c *C) {
p := ParsePattern("**/*lue/vol?ano/tail", nil)
r := p.Match([]string{"head", "value", "Volcano", "tail"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestGlobMatch_tailingAsterisks(c *C) {
p := ParsePattern("/*lue/vol?ano/**", nil)
r := p.Match([]string{"value", "volcano", "tail", "moretail"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestGlobMatch_tailingAsterisks_single(c *C) {
p := ParsePattern("/*lue/**", nil)
r := p.Match([]string{"value", "volcano"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestGlobMatch_tailingAsterisk_single(c *C) {
p := ParsePattern("/*lue/*", nil)
r := p.Match([]string{"value", "volcano", "tail"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestGlobMatch_tailingAsterisks_exactMatch(c *C) {
p := ParsePattern("/*lue/vol?ano/**", nil)
r := p.Match([]string{"value", "volcano"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestGlobMatch_middleAsterisks_emptyMatch(c *C) {
p := ParsePattern("/*lue/**/vol?ano", nil)
r := p.Match([]string{"value", "volcano"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestGlobMatch_middleAsterisks_oneMatch(c *C) {
p := ParsePattern("/*lue/**/vol?ano", nil)
r := p.Match([]string{"value", "middle", "volcano"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestGlobMatch_middleAsterisks_multiMatch(c *C) {
p := ParsePattern("/*lue/**/vol?ano", nil)
r := p.Match([]string{"value", "middle1", "middle2", "volcano"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestGlobMatch_wrongDoubleAsterisk_mismatch(c *C) {
p := ParsePattern("/*lue/**foo/vol?ano/tail", nil)
r := p.Match([]string{"value", "foo", "volcano", "tail"})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestGlobMatch_magicChars(c *C) {
p := ParsePattern("**/head/v[ou]l[kc]ano", nil)
r := p.Match([]string{"value", "head", "volcano"})
c.Assert(r, Equals, true)
}
func (s *PatternSuite) TestGlobMatch_wrongPattern_noTraversal_mismatch(c *C) {
p := ParsePattern("**/head/v[ou]l[", nil)
r := p.Match([]string{"value", "head", "vol["})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestGlobMatch_wrongPattern_onTraversal_mismatch(c *C) {
p := ParsePattern("/value/**/v[ou]l[", nil)
r := p.Match([]string{"value", "head", "vol["})
c.Assert(r, Equals, false)
}
func (s *PatternSuite) TestGlobMatch_issue_923(c *C) {
p := ParsePattern("**/android/**/GeneratedPluginRegistrant.java", nil)
r := p.Match([]string{"packages", "flutter_tools", "lib", "src", "android", "gradle.dart"})
c.Assert(r, Equals, false)
}
go-git-5.13.2/plumbing/format/gitignore/ 0000775 0000000 0000000 00000000000 14744245500 0020071 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/format/gitignore/dir.go 0000664 0000000 0000000 00000007264 14744245500 0021207 0 ustar 00root root 0000000 0000000 package gitignore
import (
"bufio"
"bytes"
"io"
"os"
"strings"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-git/v5/internal/path_util"
"github.com/go-git/go-git/v5/plumbing/format/config"
gioutil "github.com/go-git/go-git/v5/utils/ioutil"
)
const (
commentPrefix = "#"
coreSection = "core"
excludesfile = "excludesfile"
gitDir = ".git"
gitignoreFile = ".gitignore"
gitconfigFile = ".gitconfig"
systemFile = "/etc/gitconfig"
infoExcludeFile = gitDir + "/info/exclude"
)
// readIgnoreFile reads a specific git ignore file.
func readIgnoreFile(fs billy.Filesystem, path []string, ignoreFile string) (ps []Pattern, err error) {
ignoreFile, _ = path_util.ReplaceTildeWithHome(ignoreFile)
f, err := fs.Open(fs.Join(append(path, ignoreFile)...))
if err == nil {
defer f.Close()
scanner := bufio.NewScanner(f)
for scanner.Scan() {
s := scanner.Text()
if !strings.HasPrefix(s, commentPrefix) && len(strings.TrimSpace(s)) > 0 {
ps = append(ps, ParsePattern(s, path))
}
}
} else if !os.IsNotExist(err) {
return nil, err
}
return
}
// ReadPatterns reads the .git/info/exclude and then the gitignore patterns
// recursively traversing through the directory structure. The result is in
// the ascending order of priority (last higher).
func ReadPatterns(fs billy.Filesystem, path []string) (ps []Pattern, err error) {
ps, _ = readIgnoreFile(fs, path, infoExcludeFile)
subps, _ := readIgnoreFile(fs, path, gitignoreFile)
ps = append(ps, subps...)
var fis []os.FileInfo
fis, err = fs.ReadDir(fs.Join(path...))
if err != nil {
return
}
for _, fi := range fis {
if fi.IsDir() && fi.Name() != gitDir {
if NewMatcher(ps).Match(append(path, fi.Name()), true) {
continue
}
var subps []Pattern
subps, err = ReadPatterns(fs, append(path, fi.Name()))
if err != nil {
return
}
if len(subps) > 0 {
ps = append(ps, subps...)
}
}
}
return
}
func loadPatterns(fs billy.Filesystem, path string) (ps []Pattern, err error) {
f, err := fs.Open(path)
if err != nil {
if os.IsNotExist(err) {
return nil, nil
}
return nil, err
}
defer gioutil.CheckClose(f, &err)
b, err := io.ReadAll(f)
if err != nil {
return
}
d := config.NewDecoder(bytes.NewBuffer(b))
raw := config.New()
if err = d.Decode(raw); err != nil {
return
}
s := raw.Section(coreSection)
efo := s.Options.Get(excludesfile)
if efo == "" {
return nil, nil
}
ps, err = readIgnoreFile(fs, nil, efo)
if os.IsNotExist(err) {
return nil, nil
}
return
}
// LoadGlobalPatterns loads gitignore patterns from the gitignore file
// declared in a user's ~/.gitconfig file. If the ~/.gitconfig file does not
// exist the function will return nil. If the core.excludesfile property
// is not declared, the function will return nil. If the file pointed to by
// the core.excludesfile property does not exist, the function will return nil.
//
// The function assumes fs is rooted at the root filesystem.
func LoadGlobalPatterns(fs billy.Filesystem) (ps []Pattern, err error) {
home, err := os.UserHomeDir()
if err != nil {
return
}
return loadPatterns(fs, fs.Join(home, gitconfigFile))
}
// LoadSystemPatterns loads gitignore patterns from the gitignore file
// declared in a system's /etc/gitconfig file. If the /etc/gitconfig file does
// not exist the function will return nil. If the core.excludesfile property
// is not declared, the function will return nil. If the file pointed to by
// the core.excludesfile property does not exist, the function will return nil.
//
// The function assumes fs is rooted at the root filesystem.
func LoadSystemPatterns(fs billy.Filesystem) (ps []Pattern, err error) {
return loadPatterns(fs, systemFile)
}
go-git-5.13.2/plumbing/format/gitignore/dir_test.go 0000664 0000000 0000000 00000023764 14744245500 0022251 0 ustar 00root root 0000000 0000000 package gitignore
import (
"os"
"os/user"
"strconv"
"strings"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/memfs"
. "gopkg.in/check.v1"
)
type MatcherSuite struct {
GFS billy.Filesystem // git repository root
RFS billy.Filesystem // root that contains user home
RFSR billy.Filesystem // root that contains user home, but with relative ~/.gitignore_global
RFSU billy.Filesystem // root that contains user home, but with relative ~user/.gitignore_global
MCFS billy.Filesystem // root that contains user home, but missing ~/.gitconfig
MEFS billy.Filesystem // root that contains user home, but missing excludesfile entry
MIFS billy.Filesystem // root that contains user home, but missing .gitignore
SFS billy.Filesystem // root that contains /etc/gitconfig
}
var _ = Suite(&MatcherSuite{})
func (s *MatcherSuite) SetUpTest(c *C) {
// setup generic git repository root
fs := memfs.New()
err := fs.MkdirAll(".git/info", os.ModePerm)
c.Assert(err, IsNil)
f, err := fs.Create(".git/info/exclude")
c.Assert(err, IsNil)
_, err = f.Write([]byte("exclude.crlf\r\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
f, err = fs.Create(".gitignore")
c.Assert(err, IsNil)
_, err = f.Write([]byte("vendor/g*/\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("ignore.crlf\r\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("ignore_dir\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
err = fs.MkdirAll("vendor", os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create("vendor/.gitignore")
c.Assert(err, IsNil)
_, err = f.Write([]byte("!github.com/\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
err = fs.MkdirAll("ignore_dir", os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create("ignore_dir/.gitignore")
c.Assert(err, IsNil)
_, err = f.Write([]byte("!file\n"))
c.Assert(err, IsNil)
_, err = fs.Create("ignore_dir/file")
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
err = fs.MkdirAll("another", os.ModePerm)
c.Assert(err, IsNil)
err = fs.MkdirAll("exclude.crlf", os.ModePerm)
c.Assert(err, IsNil)
err = fs.MkdirAll("ignore.crlf", os.ModePerm)
c.Assert(err, IsNil)
err = fs.MkdirAll("vendor/github.com", os.ModePerm)
c.Assert(err, IsNil)
err = fs.MkdirAll("vendor/gopkg.in", os.ModePerm)
c.Assert(err, IsNil)
err = fs.MkdirAll("multiple/sub/ignores/first", os.ModePerm)
c.Assert(err, IsNil)
err = fs.MkdirAll("multiple/sub/ignores/second", os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create("multiple/sub/ignores/first/.gitignore")
c.Assert(err, IsNil)
_, err = f.Write([]byte("ignore_dir\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
f, err = fs.Create("multiple/sub/ignores/second/.gitignore")
c.Assert(err, IsNil)
_, err = f.Write([]byte("ignore_dir\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
err = fs.MkdirAll("multiple/sub/ignores/first/ignore_dir", os.ModePerm)
c.Assert(err, IsNil)
err = fs.MkdirAll("multiple/sub/ignores/second/ignore_dir", os.ModePerm)
c.Assert(err, IsNil)
s.GFS = fs
// setup root that contains user home
home, err := os.UserHomeDir()
c.Assert(err, IsNil)
fs = memfs.New()
err = fs.MkdirAll(home, os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create(fs.Join(home, gitconfigFile))
c.Assert(err, IsNil)
_, err = f.Write([]byte("[core]\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(" excludesfile = " + strconv.Quote(fs.Join(home, ".gitignore_global")) + "\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
f, err = fs.Create(fs.Join(home, ".gitignore_global"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("# IntelliJ\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(".idea/\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("*.iml\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
s.RFS = fs
// root that contains user home, but with relative ~/.gitignore_global
fs = memfs.New()
err = fs.MkdirAll(home, os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create(fs.Join(home, gitconfigFile))
c.Assert(err, IsNil)
_, err = f.Write([]byte("[core]\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(" excludesfile = ~/.gitignore_global" + "\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
f, err = fs.Create(fs.Join(home, ".gitignore_global"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("# IntelliJ\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(".idea/\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("*.iml\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
s.RFSR = fs
// root that contains user home, but with relative ~user/.gitignore_global
fs = memfs.New()
err = fs.MkdirAll(home, os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create(fs.Join(home, gitconfigFile))
c.Assert(err, IsNil)
_, err = f.Write([]byte("[core]\n"))
c.Assert(err, IsNil)
currentUser, err := user.Current()
c.Assert(err, IsNil)
// remove domain for windows
username := currentUser.Username[strings.Index(currentUser.Username, "\\")+1:]
_, err = f.Write([]byte(" excludesfile = ~" + username + "/.gitignore_global" + "\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
f, err = fs.Create(fs.Join(home, ".gitignore_global"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("# IntelliJ\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(".idea/\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("*.iml\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
s.RFSU = fs
// root that contains user home, but missing ~/.gitconfig
fs = memfs.New()
err = fs.MkdirAll(home, os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create(fs.Join(home, ".gitignore_global"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("# IntelliJ\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(".idea/\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("*.iml\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
s.MCFS = fs
// setup root that contains user home, but missing excludesfile entry
fs = memfs.New()
err = fs.MkdirAll(home, os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create(fs.Join(home, gitconfigFile))
c.Assert(err, IsNil)
_, err = f.Write([]byte("[core]\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
f, err = fs.Create(fs.Join(home, ".gitignore_global"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("# IntelliJ\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(".idea/\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("*.iml\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
s.MEFS = fs
// setup root that contains user home, but missing .gitnignore
fs = memfs.New()
err = fs.MkdirAll(home, os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create(fs.Join(home, gitconfigFile))
c.Assert(err, IsNil)
_, err = f.Write([]byte("[core]\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(" excludesfile = " + strconv.Quote(fs.Join(home, ".gitignore_global")) + "\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
s.MIFS = fs
// setup root that contains user home
fs = memfs.New()
err = fs.MkdirAll("etc", os.ModePerm)
c.Assert(err, IsNil)
f, err = fs.Create(systemFile)
c.Assert(err, IsNil)
_, err = f.Write([]byte("[core]\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(" excludesfile = /etc/gitignore_global\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
f, err = fs.Create("/etc/gitignore_global")
c.Assert(err, IsNil)
_, err = f.Write([]byte("# IntelliJ\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte(".idea/\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("*.iml\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
s.SFS = fs
}
func (s *MatcherSuite) TestDir_ReadPatterns(c *C) {
checkPatterns := func(ps []Pattern) {
c.Assert(ps, HasLen, 7)
m := NewMatcher(ps)
c.Assert(m.Match([]string{"exclude.crlf"}, true), Equals, true)
c.Assert(m.Match([]string{"ignore.crlf"}, true), Equals, true)
c.Assert(m.Match([]string{"vendor", "gopkg.in"}, true), Equals, true)
c.Assert(m.Match([]string{"ignore_dir", "file"}, false), Equals, true)
c.Assert(m.Match([]string{"vendor", "github.com"}, true), Equals, false)
c.Assert(m.Match([]string{"multiple", "sub", "ignores", "first", "ignore_dir"}, true), Equals, true)
c.Assert(m.Match([]string{"multiple", "sub", "ignores", "second", "ignore_dir"}, true), Equals, true)
}
ps, err := ReadPatterns(s.GFS, nil)
c.Assert(err, IsNil)
checkPatterns(ps)
// passing an empty slice with capacity to check we don't hit a bug where the extra capacity is reused incorrectly
ps, err = ReadPatterns(s.GFS, make([]string, 0, 6))
c.Assert(err, IsNil)
checkPatterns(ps)
}
func (s *MatcherSuite) TestDir_ReadRelativeGlobalGitIgnore(c *C) {
for _, fs := range []billy.Filesystem{s.RFSR, s.RFSU} {
ps, err := LoadGlobalPatterns(fs)
c.Assert(err, IsNil)
c.Assert(ps, HasLen, 2)
m := NewMatcher(ps)
c.Assert(m.Match([]string{".idea/"}, true), Equals, false)
c.Assert(m.Match([]string{"*.iml"}, true), Equals, true)
c.Assert(m.Match([]string{"IntelliJ"}, true), Equals, false)
}
}
func (s *MatcherSuite) TestDir_LoadGlobalPatterns(c *C) {
ps, err := LoadGlobalPatterns(s.RFS)
c.Assert(err, IsNil)
c.Assert(ps, HasLen, 2)
m := NewMatcher(ps)
c.Assert(m.Match([]string{"go-git.v4.iml"}, true), Equals, true)
c.Assert(m.Match([]string{".idea"}, true), Equals, true)
}
func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingGitconfig(c *C) {
ps, err := LoadGlobalPatterns(s.MCFS)
c.Assert(err, IsNil)
c.Assert(ps, HasLen, 0)
}
func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingExcludesfile(c *C) {
ps, err := LoadGlobalPatterns(s.MEFS)
c.Assert(err, IsNil)
c.Assert(ps, HasLen, 0)
}
func (s *MatcherSuite) TestDir_LoadGlobalPatternsMissingGitignore(c *C) {
ps, err := LoadGlobalPatterns(s.MIFS)
c.Assert(err, IsNil)
c.Assert(ps, HasLen, 0)
}
func (s *MatcherSuite) TestDir_LoadSystemPatterns(c *C) {
ps, err := LoadSystemPatterns(s.SFS)
c.Assert(err, IsNil)
c.Assert(ps, HasLen, 2)
m := NewMatcher(ps)
c.Assert(m.Match([]string{"go-git.v4.iml"}, true), Equals, true)
c.Assert(m.Match([]string{".idea"}, true), Equals, true)
}
go-git-5.13.2/plumbing/format/gitignore/doc.go 0000664 0000000 0000000 00000006663 14744245500 0021200 0 ustar 00root root 0000000 0000000 // Package gitignore implements matching file system paths to gitignore patterns that
// can be automatically read from a git repository tree in the order of definition
// priorities. It support all pattern formats as specified in the original gitignore
// documentation, copied below:
//
// Pattern format
// ==============
//
// - A blank line matches no files, so it can serve as a separator for readability.
//
// - A line starting with # serves as a comment. Put a backslash ("\") in front of
// the first hash for patterns that begin with a hash.
//
// - Trailing spaces are ignored unless they are quoted with backslash ("\").
//
// - An optional prefix "!" which negates the pattern; any matching file excluded
// by a previous pattern will become included again. It is not possible to
// re-include a file if a parent directory of that file is excluded.
// Git doesn’t list excluded directories for performance reasons, so
// any patterns on contained files have no effect, no matter where they are
// defined. Put a backslash ("\") in front of the first "!" for patterns
// that begin with a literal "!", for example, "\!important!.txt".
//
// - If the pattern ends with a slash, it is removed for the purpose of the
// following description, but it would only find a match with a directory.
// In other words, foo/ will match a directory foo and paths underneath it,
// but will not match a regular file or a symbolic link foo (this is consistent
// with the way how pathspec works in general in Git).
//
// - If the pattern does not contain a slash /, Git treats it as a shell glob
// pattern and checks for a match against the pathname relative to the location
// of the .gitignore file (relative to the toplevel of the work tree if not
// from a .gitignore file).
//
// - Otherwise, Git treats the pattern as a shell glob suitable for consumption
// by fnmatch(3) with the FNM_PATHNAME flag: wildcards in the pattern will
// not match a / in the pathname. For example, "Documentation/*.html" matches
// "Documentation/git.html" but not "Documentation/ppc/ppc.html" or
// "tools/perf/Documentation/perf.html".
//
// - A leading slash matches the beginning of the pathname. For example,
// "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
//
// Two consecutive asterisks ("**") in patterns matched against full pathname
// may have special meaning:
//
// - A leading "**" followed by a slash means match in all directories.
// For example, "**/foo" matches file or directory "foo" anywhere, the same as
// pattern "foo". "**/foo/bar" matches file or directory "bar"
// anywhere that is directly under directory "foo".
//
// - A trailing "/**" matches everything inside. For example, "abc/**" matches
// all files inside directory "abc", relative to the location of the
// .gitignore file, with infinite depth.
//
// - A slash followed by two consecutive asterisks then a slash matches
// zero or more directories. For example, "a/**/b" matches "a/b", "a/x/b",
// "a/x/y/b" and so on.
//
// - Other consecutive asterisks are considered invalid.
//
// Copyright and license
// =====================
//
// Copyright (c) Oleg Sklyar, Silvertern and source{d}
//
// The package code was donated to source{d} to include, modify and develop
// further as a part of the `go-git` project, release it on the license of
// the whole project or delete it from the project.
package gitignore
go-git-5.13.2/plumbing/format/gitignore/matcher.go 0000664 0000000 0000000 00000001646 14744245500 0022052 0 ustar 00root root 0000000 0000000 package gitignore
// Matcher defines a global multi-pattern matcher for gitignore patterns
type Matcher interface {
// Match matches patterns in the order of priorities. As soon as an inclusion or
// exclusion is found, not further matching is performed.
Match(path []string, isDir bool) bool
}
// NewMatcher constructs a new global matcher. Patterns must be given in the order of
// increasing priority. That is most generic settings files first, then the content of
// the repo .gitignore, then content of .gitignore down the path or the repo and then
// the content command line arguments.
func NewMatcher(ps []Pattern) Matcher {
return &matcher{ps}
}
type matcher struct {
patterns []Pattern
}
func (m *matcher) Match(path []string, isDir bool) bool {
n := len(m.patterns)
for i := n - 1; i >= 0; i-- {
if match := m.patterns[i].Match(path, isDir); match > NoMatch {
return match == Exclude
}
}
return false
}
go-git-5.13.2/plumbing/format/gitignore/matcher_test.go 0000664 0000000 0000000 00000000601 14744245500 0023077 0 ustar 00root root 0000000 0000000 package gitignore
import (
. "gopkg.in/check.v1"
)
func (s *MatcherSuite) TestMatcher_Match(c *C) {
ps := []Pattern{
ParsePattern("**/middle/v[uo]l?ano", nil),
ParsePattern("!volcano", nil),
}
m := NewMatcher(ps)
c.Assert(m.Match([]string{"head", "middle", "vulkano"}, false), Equals, true)
c.Assert(m.Match([]string{"head", "middle", "volcano"}, false), Equals, false)
}
go-git-5.13.2/plumbing/format/gitignore/pattern.go 0000664 0000000 0000000 00000006166 14744245500 0022106 0 ustar 00root root 0000000 0000000 package gitignore
import (
"path/filepath"
"strings"
)
// MatchResult defines outcomes of a match, no match, exclusion or inclusion.
type MatchResult int
const (
// NoMatch defines the no match outcome of a match check
NoMatch MatchResult = iota
// Exclude defines an exclusion of a file as a result of a match check
Exclude
// Include defines an explicit inclusion of a file as a result of a match check
Include
)
const (
inclusionPrefix = "!"
zeroToManyDirs = "**"
patternDirSep = "/"
)
// Pattern defines a single gitignore pattern.
type Pattern interface {
// Match matches the given path to the pattern.
Match(path []string, isDir bool) MatchResult
}
type pattern struct {
domain []string
pattern []string
inclusion bool
dirOnly bool
isGlob bool
}
// ParsePattern parses a gitignore pattern string into the Pattern structure.
func ParsePattern(p string, domain []string) Pattern {
// storing domain, copy it to ensure it isn't changed externally
domain = append([]string(nil), domain...)
res := pattern{domain: domain}
if strings.HasPrefix(p, inclusionPrefix) {
res.inclusion = true
p = p[1:]
}
if !strings.HasSuffix(p, "\\ ") {
p = strings.TrimRight(p, " ")
}
if strings.HasSuffix(p, patternDirSep) {
res.dirOnly = true
p = p[:len(p)-1]
}
if strings.Contains(p, patternDirSep) {
res.isGlob = true
}
res.pattern = strings.Split(p, patternDirSep)
return &res
}
func (p *pattern) Match(path []string, isDir bool) MatchResult {
if len(path) <= len(p.domain) {
return NoMatch
}
for i, e := range p.domain {
if path[i] != e {
return NoMatch
}
}
path = path[len(p.domain):]
if p.isGlob && !p.globMatch(path, isDir) {
return NoMatch
} else if !p.isGlob && !p.simpleNameMatch(path, isDir) {
return NoMatch
}
if p.inclusion {
return Include
} else {
return Exclude
}
}
func (p *pattern) simpleNameMatch(path []string, isDir bool) bool {
for i, name := range path {
if match, err := filepath.Match(p.pattern[0], name); err != nil {
return false
} else if !match {
continue
}
if p.dirOnly && !isDir && i == len(path)-1 {
return false
}
return true
}
return false
}
func (p *pattern) globMatch(path []string, isDir bool) bool {
matched := false
canTraverse := false
for i, pattern := range p.pattern {
if pattern == "" {
canTraverse = false
continue
}
if pattern == zeroToManyDirs {
if i == len(p.pattern)-1 {
break
}
canTraverse = true
continue
}
if strings.Contains(pattern, zeroToManyDirs) {
return false
}
if len(path) == 0 {
return false
}
if canTraverse {
canTraverse = false
for len(path) > 0 {
e := path[0]
path = path[1:]
if match, err := filepath.Match(pattern, e); err != nil {
return false
} else if match {
matched = true
break
} else if len(path) == 0 {
// if nothing left then fail
matched = false
}
}
} else {
if match, err := filepath.Match(pattern, path[0]); err != nil || !match {
return false
}
matched = true
path = path[1:]
}
}
if matched && p.dirOnly && !isDir && len(path) == 0 {
matched = false
}
return matched
}
go-git-5.13.2/plumbing/format/gitignore/pattern_test.go 0000664 0000000 0000000 00000022545 14744245500 0023144 0 ustar 00root root 0000000 0000000 package gitignore
import (
"testing"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type PatternSuite struct{}
var _ = Suite(&PatternSuite{})
func (s *PatternSuite) TestSimpleMatch_inclusion(c *C) {
p := ParsePattern("!vul?ano", nil)
r := p.Match([]string{"value", "vulkano", "tail"}, false)
c.Assert(r, Equals, Include)
}
func (s *PatternSuite) TestMatch_domainLonger_mismatch(c *C) {
p := ParsePattern("value", []string{"head", "middle", "tail"})
r := p.Match([]string{"head", "middle"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestMatch_domainSameLength_mismatch(c *C) {
p := ParsePattern("value", []string{"head", "middle", "tail"})
r := p.Match([]string{"head", "middle", "tail"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestMatch_domainMismatch_mismatch(c *C) {
p := ParsePattern("value", []string{"head", "middle", "tail"})
r := p.Match([]string{"head", "middle", "_tail_", "value"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestSimpleMatch_withDomain(c *C) {
p := ParsePattern("middle/", []string{"value", "volcano"})
r := p.Match([]string{"value", "volcano", "middle", "tail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestSimpleMatch_onlyMatchInDomain_mismatch(c *C) {
p := ParsePattern("volcano/", []string{"value", "volcano"})
r := p.Match([]string{"value", "volcano", "tail"}, true)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestSimpleMatch_atStart(c *C) {
p := ParsePattern("value", nil)
r := p.Match([]string{"value", "tail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestSimpleMatch_inTheMiddle(c *C) {
p := ParsePattern("value", nil)
r := p.Match([]string{"head", "value", "tail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestSimpleMatch_atEnd(c *C) {
p := ParsePattern("value", nil)
r := p.Match([]string{"head", "value"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestSimpleMatch_atStart_dirWanted(c *C) {
p := ParsePattern("value/", nil)
r := p.Match([]string{"value", "tail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestSimpleMatch_inTheMiddle_dirWanted(c *C) {
p := ParsePattern("value/", nil)
r := p.Match([]string{"head", "value", "tail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestSimpleMatch_atEnd_dirWanted(c *C) {
p := ParsePattern("value/", nil)
r := p.Match([]string{"head", "value"}, true)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestSimpleMatch_atEnd_dirWanted_notADir_mismatch(c *C) {
p := ParsePattern("value/", nil)
r := p.Match([]string{"head", "value"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestSimpleMatch_mismatch(c *C) {
p := ParsePattern("value", nil)
r := p.Match([]string{"head", "val", "tail"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestSimpleMatch_valueLonger_mismatch(c *C) {
p := ParsePattern("val", nil)
r := p.Match([]string{"head", "value", "tail"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestSimpleMatch_withAsterisk(c *C) {
p := ParsePattern("v*o", nil)
r := p.Match([]string{"value", "vulkano", "tail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestSimpleMatch_withQuestionMark(c *C) {
p := ParsePattern("vul?ano", nil)
r := p.Match([]string{"value", "vulkano", "tail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestSimpleMatch_magicChars(c *C) {
p := ParsePattern("v[ou]l[kc]ano", nil)
r := p.Match([]string{"value", "volcano"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestSimpleMatch_wrongPattern_mismatch(c *C) {
p := ParsePattern("v[ou]l[", nil)
r := p.Match([]string{"value", "vol["}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestGlobMatch_fromRootWithSlash(c *C) {
p := ParsePattern("/value/vul?ano", nil)
r := p.Match([]string{"value", "vulkano", "tail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_withDomain(c *C) {
p := ParsePattern("middle/tail/", []string{"value", "volcano"})
r := p.Match([]string{"value", "volcano", "middle", "tail"}, true)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_onlyMatchInDomain_mismatch(c *C) {
p := ParsePattern("volcano/tail", []string{"value", "volcano"})
r := p.Match([]string{"value", "volcano", "tail"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestGlobMatch_fromRootWithoutSlash(c *C) {
p := ParsePattern("value/vul?ano", nil)
r := p.Match([]string{"value", "vulkano", "tail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_fromRoot_mismatch(c *C) {
p := ParsePattern("value/vulkano", nil)
r := p.Match([]string{"value", "volcano"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestGlobMatch_fromRoot_tooShort_mismatch(c *C) {
p := ParsePattern("value/vul?ano", nil)
r := p.Match([]string{"value"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestGlobMatch_fromRoot_notAtRoot_mismatch(c *C) {
p := ParsePattern("/value/volcano", nil)
r := p.Match([]string{"value", "value", "volcano"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestGlobMatch_leadingAsterisks_atStart(c *C) {
p := ParsePattern("**/*lue/vol?ano", nil)
r := p.Match([]string{"value", "volcano", "tail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_leadingAsterisks_notAtStart(c *C) {
p := ParsePattern("**/*lue/vol?ano", nil)
r := p.Match([]string{"head", "value", "volcano", "tail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_leadingAsterisks_mismatch(c *C) {
p := ParsePattern("**/*lue/vol?ano", nil)
r := p.Match([]string{"head", "value", "Volcano", "tail"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestGlobMatch_leadingAsterisks_isDir(c *C) {
p := ParsePattern("**/*lue/vol?ano/", nil)
r := p.Match([]string{"head", "value", "volcano", "tail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_leadingAsterisks_isDirAtEnd(c *C) {
p := ParsePattern("**/*lue/vol?ano/", nil)
r := p.Match([]string{"head", "value", "volcano"}, true)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_leadingAsterisks_isDir_mismatch(c *C) {
p := ParsePattern("**/*lue/vol?ano/", nil)
r := p.Match([]string{"head", "value", "Colcano"}, true)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestGlobMatch_leadingAsterisks_isDirNoDirAtEnd_mismatch(c *C) {
p := ParsePattern("**/*lue/vol?ano/", nil)
r := p.Match([]string{"head", "value", "volcano"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestGlobMatch_tailingAsterisks(c *C) {
p := ParsePattern("/*lue/vol?ano/**", nil)
r := p.Match([]string{"value", "volcano", "tail", "moretail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_tailingAsterisks_exactMatch(c *C) {
p := ParsePattern("/*lue/vol?ano/**", nil)
r := p.Match([]string{"value", "volcano"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_middleAsterisks_emptyMatch(c *C) {
p := ParsePattern("/*lue/**/vol?ano", nil)
r := p.Match([]string{"value", "volcano"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_middleAsterisks_oneMatch(c *C) {
p := ParsePattern("/*lue/**/vol?ano", nil)
r := p.Match([]string{"value", "middle", "volcano"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_middleAsterisks_multiMatch(c *C) {
p := ParsePattern("/*lue/**/vol?ano", nil)
r := p.Match([]string{"value", "middle1", "middle2", "volcano"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_middleAsterisks_isDir_trailing(c *C) {
p := ParsePattern("/*lue/**/vol?ano/", nil)
r := p.Match([]string{"value", "middle1", "middle2", "volcano"}, true)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_middleAsterisks_isDir_trailing_mismatch(c *C) {
p := ParsePattern("/*lue/**/vol?ano/", nil)
r := p.Match([]string{"value", "middle1", "middle2", "volcano"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestGlobMatch_middleAsterisks_isDir(c *C) {
p := ParsePattern("/*lue/**/vol?ano/", nil)
r := p.Match([]string{"value", "middle1", "middle2", "volcano", "tail"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_wrongDoubleAsterisk_mismatch(c *C) {
p := ParsePattern("/*lue/**foo/vol?ano", nil)
r := p.Match([]string{"value", "foo", "volcano", "tail"}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestGlobMatch_magicChars(c *C) {
p := ParsePattern("**/head/v[ou]l[kc]ano", nil)
r := p.Match([]string{"value", "head", "volcano"}, false)
c.Assert(r, Equals, Exclude)
}
func (s *PatternSuite) TestGlobMatch_wrongPattern_noTraversal_mismatch(c *C) {
p := ParsePattern("**/head/v[ou]l[", nil)
r := p.Match([]string{"value", "head", "vol["}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestGlobMatch_wrongPattern_onTraversal_mismatch(c *C) {
p := ParsePattern("/value/**/v[ou]l[", nil)
r := p.Match([]string{"value", "head", "vol["}, false)
c.Assert(r, Equals, NoMatch)
}
func (s *PatternSuite) TestGlobMatch_issue_923(c *C) {
p := ParsePattern("**/android/**/GeneratedPluginRegistrant.java", nil)
r := p.Match([]string{"packages", "flutter_tools", "lib", "src", "android", "gradle.dart"}, false)
c.Assert(r, Equals, NoMatch)
}
go-git-5.13.2/plumbing/format/idxfile/ 0000775 0000000 0000000 00000000000 14744245500 0017526 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/format/idxfile/decoder.go 0000664 0000000 0000000 00000006614 14744245500 0021471 0 ustar 00root root 0000000 0000000 package idxfile
import (
"bufio"
"bytes"
"errors"
"io"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/utils/binary"
)
var (
// ErrUnsupportedVersion is returned by Decode when the idx file version
// is not supported.
ErrUnsupportedVersion = errors.New("unsupported version")
// ErrMalformedIdxFile is returned by Decode when the idx file is corrupted.
ErrMalformedIdxFile = errors.New("malformed IDX file")
)
const (
fanout = 256
objectIDLength = hash.Size
)
// Decoder reads and decodes idx files from an input stream.
type Decoder struct {
*bufio.Reader
}
// NewDecoder builds a new idx stream decoder, that reads from r.
func NewDecoder(r io.Reader) *Decoder {
return &Decoder{bufio.NewReader(r)}
}
// Decode reads from the stream and decode the content into the MemoryIndex struct.
func (d *Decoder) Decode(idx *MemoryIndex) error {
if err := validateHeader(d); err != nil {
return err
}
flow := []func(*MemoryIndex, io.Reader) error{
readVersion,
readFanout,
readObjectNames,
readCRC32,
readOffsets,
readChecksums,
}
for _, f := range flow {
if err := f(idx, d); err != nil {
return err
}
}
return nil
}
func validateHeader(r io.Reader) error {
var h = make([]byte, 4)
if _, err := io.ReadFull(r, h); err != nil {
return err
}
if !bytes.Equal(h, idxHeader) {
return ErrMalformedIdxFile
}
return nil
}
func readVersion(idx *MemoryIndex, r io.Reader) error {
v, err := binary.ReadUint32(r)
if err != nil {
return err
}
if v > VersionSupported {
return ErrUnsupportedVersion
}
idx.Version = v
return nil
}
func readFanout(idx *MemoryIndex, r io.Reader) error {
for k := 0; k < fanout; k++ {
n, err := binary.ReadUint32(r)
if err != nil {
return err
}
idx.Fanout[k] = n
idx.FanoutMapping[k] = noMapping
}
return nil
}
func readObjectNames(idx *MemoryIndex, r io.Reader) error {
for k := 0; k < fanout; k++ {
var buckets uint32
if k == 0 {
buckets = idx.Fanout[k]
} else {
buckets = idx.Fanout[k] - idx.Fanout[k-1]
}
if buckets == 0 {
continue
}
idx.FanoutMapping[k] = len(idx.Names)
nameLen := int(buckets * objectIDLength)
bin := make([]byte, nameLen)
if _, err := io.ReadFull(r, bin); err != nil {
return err
}
idx.Names = append(idx.Names, bin)
idx.Offset32 = append(idx.Offset32, make([]byte, buckets*4))
idx.CRC32 = append(idx.CRC32, make([]byte, buckets*4))
}
return nil
}
func readCRC32(idx *MemoryIndex, r io.Reader) error {
for k := 0; k < fanout; k++ {
if pos := idx.FanoutMapping[k]; pos != noMapping {
if _, err := io.ReadFull(r, idx.CRC32[pos]); err != nil {
return err
}
}
}
return nil
}
func readOffsets(idx *MemoryIndex, r io.Reader) error {
var o64cnt int
for k := 0; k < fanout; k++ {
if pos := idx.FanoutMapping[k]; pos != noMapping {
if _, err := io.ReadFull(r, idx.Offset32[pos]); err != nil {
return err
}
for p := 0; p < len(idx.Offset32[pos]); p += 4 {
if idx.Offset32[pos][p]&(byte(1)<<7) > 0 {
o64cnt++
}
}
}
}
if o64cnt > 0 {
idx.Offset64 = make([]byte, o64cnt*8)
if _, err := io.ReadFull(r, idx.Offset64); err != nil {
return err
}
}
return nil
}
func readChecksums(idx *MemoryIndex, r io.Reader) error {
if _, err := io.ReadFull(r, idx.PackfileChecksum[:]); err != nil {
return err
}
if _, err := io.ReadFull(r, idx.IdxChecksum[:]); err != nil {
return err
}
return nil
}
go-git-5.13.2/plumbing/format/idxfile/decoder_test.go 0000664 0000000 0000000 00000010600 14744245500 0022516 0 ustar 00root root 0000000 0000000 package idxfile_test
import (
"bytes"
"encoding/base64"
"fmt"
"io"
"testing"
"github.com/go-git/go-git/v5/plumbing"
. "github.com/go-git/go-git/v5/plumbing/format/idxfile"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type IdxfileSuite struct {
fixtures.Suite
}
var _ = Suite(&IdxfileSuite{})
func (s *IdxfileSuite) TestDecode(c *C) {
f := fixtures.Basic().One()
d := NewDecoder(f.Idx())
idx := new(MemoryIndex)
err := d.Decode(idx)
c.Assert(err, IsNil)
count, _ := idx.Count()
c.Assert(count, Equals, int64(31))
hash := plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea")
ok, err := idx.Contains(hash)
c.Assert(err, IsNil)
c.Assert(ok, Equals, true)
offset, err := idx.FindOffset(hash)
c.Assert(err, IsNil)
c.Assert(offset, Equals, int64(615))
crc32, err := idx.FindCRC32(hash)
c.Assert(err, IsNil)
c.Assert(crc32, Equals, uint32(3645019190))
c.Assert(fmt.Sprintf("%x", idx.IdxChecksum), Equals, "fb794f1ec720b9bc8e43257451bd99c4be6fa1c9")
c.Assert(fmt.Sprintf("%x", idx.PackfileChecksum), Equals, f.PackfileHash)
}
func (s *IdxfileSuite) TestDecode64bitsOffsets(c *C) {
f := bytes.NewBufferString(fixtureLarge4GB)
idx := new(MemoryIndex)
d := NewDecoder(base64.NewDecoder(base64.StdEncoding, f))
err := d.Decode(idx)
c.Assert(err, IsNil)
expected := map[string]uint64{
"303953e5aa461c203a324821bc1717f9b4fff895": 12,
"5296768e3d9f661387ccbff18c4dea6c997fd78c": 142,
"03fc8d58d44267274edef4585eaeeb445879d33f": 1601322837,
"8f3ceb4ea4cb9e4a0f751795eb41c9a4f07be772": 2646996529,
"e0d1d625010087f79c9e01ad9d8f95e1628dda02": 3452385606,
"90eba326cdc4d1d61c5ad25224ccbf08731dd041": 3707047470,
"bab53055add7bc35882758a922c54a874d6b1272": 5323223332,
"1b8995f51987d8a449ca5ea4356595102dc2fbd4": 5894072943,
"35858be9c6f5914cbe6768489c41eb6809a2bceb": 5924278919,
}
iter, err := idx.Entries()
c.Assert(err, IsNil)
var entries int
for {
e, err := iter.Next()
if err == io.EOF {
break
}
c.Assert(err, IsNil)
entries++
c.Assert(expected[e.Hash.String()], Equals, e.Offset)
}
c.Assert(entries, Equals, len(expected))
}
const fixtureLarge4GB = `/3RPYwAAAAIAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEA
AAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAA
AAEAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAA
AgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAADAAAAAwAAAAMAAAADAAAAAwAAAAQAAAAE
AAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQA
AAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABQAA
AAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAA
BQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAF
AAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUA
AAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAA
AAUAAAAFAAAABQAAAAYAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAA
BwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAH
AAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcA
AAAHAAAABwAAAAcAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAA
AAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAA
CAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAkAAAAJ
AAAACQAAAAkAAAAJAAAACQAAAAkAAAAJAAAACQAAAAkAAAAJAAAACQAAAAkAAAAJAAAACQAAAAkA
AAAJAAAACQAAAAkAAAAJAAAACQAAAAkAAAAJAAAACQAAAAkAAAAJAAAACQAAAAkAAAAJAAAACQAA
AAkAAAAJA/yNWNRCZydO3vRYXq7rRFh50z8biZX1GYfYpEnKXqQ1ZZUQLcL71DA5U+WqRhwgOjJI
IbwXF/m0//iVNYWL6cb1kUy+Z2hInEHraAmivOtSlnaOPZ9mE4fMv/GMTepsmX/XjI88606ky55K
D3UXletByaTwe+dykOujJs3E0dYcWtJSJMy/CHMd0EG6tTBVrde8NYgnWKkixUqHTWsScuDR1iUB
AIf3nJ4BrZ2PleFijdoCkp36qiGHwFa8NHxMnInZ0s3CKEKmHe+KcZPzuqwmm44GvqGAX3I/VYAA
AAAAAAAMgAAAAQAAAI6AAAACgAAAA4AAAASAAAAFAAAAAV9Qam8AAAABYR1ShwAAAACdxfYxAAAA
ANz1Di4AAAABPUnxJAAAAADNxzlGr6vCJpIFz4XaG/fi/f9C9zgQ8ptKSQpfQ1NMJBGTDTxxYGGp
ch2xUA==
`
func BenchmarkDecode(b *testing.B) {
f := fixtures.Basic().One()
fixture, err := io.ReadAll(f.Idx())
if err != nil {
b.Errorf("unexpected error reading idx file: %s", err)
}
defer fixtures.Clean()
for i := 0; i < b.N; i++ {
f := bytes.NewBuffer(fixture)
idx := new(MemoryIndex)
d := NewDecoder(f)
if err := d.Decode(idx); err != nil {
b.Errorf("unexpected error decoding: %s", err)
}
}
}
go-git-5.13.2/plumbing/format/idxfile/doc.go 0000664 0000000 0000000 00000012203 14744245500 0020620 0 ustar 00root root 0000000 0000000 // Package idxfile implements encoding and decoding of packfile idx files.
//
// == Original (version 1) pack-*.idx files have the following format:
//
// - The header consists of 256 4-byte network byte order
// integers. N-th entry of this table records the number of
// objects in the corresponding pack, the first byte of whose
// object name is less than or equal to N. This is called the
// 'first-level fan-out' table.
//
// - The header is followed by sorted 24-byte entries, one entry
// per object in the pack. Each entry is:
//
// 4-byte network byte order integer, recording where the
// object is stored in the packfile as the offset from the
// beginning.
//
// 20-byte object name.
//
// - The file is concluded with a trailer:
//
// A copy of the 20-byte SHA1 checksum at the end of
// corresponding packfile.
//
// 20-byte SHA1-checksum of all of the above.
//
// Pack Idx file:
//
// -- +--------------------------------+
// fanout | fanout[0] = 2 (for example) |-.
// table +--------------------------------+ |
// | fanout[1] | |
// +--------------------------------+ |
// | fanout[2] | |
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
// | fanout[255] = total objects |---.
// -- +--------------------------------+ | |
// main | offset | | |
// index | object name 00XXXXXXXXXXXXXXXX | | |
// tab +--------------------------------+ | |
// | offset | | |
// | object name 00XXXXXXXXXXXXXXXX | | |
// +--------------------------------+<+ |
// .-| offset | |
// | | object name 01XXXXXXXXXXXXXXXX | |
// | +--------------------------------+ |
// | | offset | |
// | | object name 01XXXXXXXXXXXXXXXX | |
// | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
// | | offset | |
// | | object name FFXXXXXXXXXXXXXXXX | |
// --| +--------------------------------+<--+
// trailer | | packfile checksum |
// | +--------------------------------+
// | | idxfile checksum |
// | +--------------------------------+
// .---------.
// |
// Pack file entry: <+
//
// packed object header:
// 1-byte size extension bit (MSB)
// type (next 3 bit)
// size0 (lower 4-bit)
// n-byte sizeN (as long as MSB is set, each 7-bit)
// size0..sizeN form 4+7+7+..+7 bit integer, size0
// is the least significant part, and sizeN is the
// most significant part.
// packed object data:
// If it is not DELTA, then deflated bytes (the size above
// is the size before compression).
// If it is REF_DELTA, then
// 20-byte base object name SHA1 (the size above is the
// size of the delta data that follows).
// delta data, deflated.
// If it is OFS_DELTA, then
// n-byte offset (see below) interpreted as a negative
// offset from the type-byte of the header of the
// ofs-delta entry (the size above is the size of
// the delta data that follows).
// delta data, deflated.
//
// offset encoding:
// n bytes with MSB set in all but the last one.
// The offset is then the number constructed by
// concatenating the lower 7 bit of each byte, and
// for n >= 2 adding 2^7 + 2^14 + ... + 2^(7*(n-1))
// to the result.
//
// == Version 2 pack-*.idx files support packs larger than 4 GiB, and
// have some other reorganizations. They have the format:
//
// - A 4-byte magic number '\377tOc' which is an unreasonable
// fanout[0] value.
//
// - A 4-byte version number (= 2)
//
// - A 256-entry fan-out table just like v1.
//
// - A table of sorted 20-byte SHA1 object names. These are
// packed together without offset values to reduce the cache
// footprint of the binary search for a specific object name.
//
// - A table of 4-byte CRC32 values of the packed object data.
// This is new in v2 so compressed data can be copied directly
// from pack to pack during repacking without undetected
// data corruption.
//
// - A table of 4-byte offset values (in network byte order).
// These are usually 31-bit pack file offsets, but large
// offsets are encoded as an index into the next table with
// the msbit set.
//
// - A table of 8-byte offset entries (empty for pack files less
// than 2 GiB). Pack files are organized with heavily used
// objects toward the front, so most object references should
// not need to refer to this table.
//
// - The same trailer as a v1 pack file:
//
// A copy of the 20-byte SHA1 checksum at the end of
// corresponding packfile.
//
// 20-byte SHA1-checksum of all of the above.
//
// Source:
// https://www.kernel.org/pub/software/scm/git/docs/v1.7.5/technical/pack-format.txt
package idxfile
go-git-5.13.2/plumbing/format/idxfile/encoder.go 0000664 0000000 0000000 00000004735 14744245500 0021505 0 ustar 00root root 0000000 0000000 package idxfile
import (
"io"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/utils/binary"
)
// Encoder writes MemoryIndex structs to an output stream.
type Encoder struct {
io.Writer
hash hash.Hash
}
// NewEncoder returns a new stream encoder that writes to w.
func NewEncoder(w io.Writer) *Encoder {
h := hash.New(hash.CryptoType)
mw := io.MultiWriter(w, h)
return &Encoder{mw, h}
}
// Encode encodes an MemoryIndex to the encoder writer.
func (e *Encoder) Encode(idx *MemoryIndex) (int, error) {
flow := []func(*MemoryIndex) (int, error){
e.encodeHeader,
e.encodeFanout,
e.encodeHashes,
e.encodeCRC32,
e.encodeOffsets,
e.encodeChecksums,
}
sz := 0
for _, f := range flow {
i, err := f(idx)
sz += i
if err != nil {
return sz, err
}
}
return sz, nil
}
func (e *Encoder) encodeHeader(idx *MemoryIndex) (int, error) {
c, err := e.Write(idxHeader)
if err != nil {
return c, err
}
return c + 4, binary.WriteUint32(e, idx.Version)
}
func (e *Encoder) encodeFanout(idx *MemoryIndex) (int, error) {
for _, c := range idx.Fanout {
if err := binary.WriteUint32(e, c); err != nil {
return 0, err
}
}
return fanout * 4, nil
}
func (e *Encoder) encodeHashes(idx *MemoryIndex) (int, error) {
var size int
for k := 0; k < fanout; k++ {
pos := idx.FanoutMapping[k]
if pos == noMapping {
continue
}
n, err := e.Write(idx.Names[pos])
if err != nil {
return size, err
}
size += n
}
return size, nil
}
func (e *Encoder) encodeCRC32(idx *MemoryIndex) (int, error) {
var size int
for k := 0; k < fanout; k++ {
pos := idx.FanoutMapping[k]
if pos == noMapping {
continue
}
n, err := e.Write(idx.CRC32[pos])
if err != nil {
return size, err
}
size += n
}
return size, nil
}
func (e *Encoder) encodeOffsets(idx *MemoryIndex) (int, error) {
var size int
for k := 0; k < fanout; k++ {
pos := idx.FanoutMapping[k]
if pos == noMapping {
continue
}
n, err := e.Write(idx.Offset32[pos])
if err != nil {
return size, err
}
size += n
}
if len(idx.Offset64) > 0 {
n, err := e.Write(idx.Offset64)
if err != nil {
return size, err
}
size += n
}
return size, nil
}
func (e *Encoder) encodeChecksums(idx *MemoryIndex) (int, error) {
if _, err := e.Write(idx.PackfileChecksum[:]); err != nil {
return 0, err
}
copy(idx.IdxChecksum[:], e.hash.Sum(nil)[:hash.Size])
if _, err := e.Write(idx.IdxChecksum[:]); err != nil {
return 0, err
}
return hash.HexSize, nil
}
go-git-5.13.2/plumbing/format/idxfile/encoder_test.go 0000664 0000000 0000000 00000001247 14744245500 0022537 0 ustar 00root root 0000000 0000000 package idxfile_test
import (
"bytes"
"io"
. "github.com/go-git/go-git/v5/plumbing/format/idxfile"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func (s *IdxfileSuite) TestDecodeEncode(c *C) {
fixtures.ByTag("packfile").Test(c, func(f *fixtures.Fixture) {
expected, err := io.ReadAll(f.Idx())
c.Assert(err, IsNil)
idx := new(MemoryIndex)
d := NewDecoder(bytes.NewBuffer(expected))
err = d.Decode(idx)
c.Assert(err, IsNil)
result := bytes.NewBuffer(nil)
e := NewEncoder(result)
size, err := e.Encode(idx)
c.Assert(err, IsNil)
c.Assert(size, Equals, len(expected))
c.Assert(result.Bytes(), DeepEquals, expected)
})
}
go-git-5.13.2/plumbing/format/idxfile/idxfile.go 0000664 0000000 0000000 00000017313 14744245500 0021506 0 ustar 00root root 0000000 0000000 package idxfile
import (
"bytes"
"io"
"sort"
encbin "encoding/binary"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/hash"
)
const (
// VersionSupported is the only idx version supported.
VersionSupported = 2
noMapping = -1
)
var (
idxHeader = []byte{255, 't', 'O', 'c'}
)
// Index represents an index of a packfile.
type Index interface {
// Contains checks whether the given hash is in the index.
Contains(h plumbing.Hash) (bool, error)
// FindOffset finds the offset in the packfile for the object with
// the given hash.
FindOffset(h plumbing.Hash) (int64, error)
// FindCRC32 finds the CRC32 of the object with the given hash.
FindCRC32(h plumbing.Hash) (uint32, error)
// FindHash finds the hash for the object with the given offset.
FindHash(o int64) (plumbing.Hash, error)
// Count returns the number of entries in the index.
Count() (int64, error)
// Entries returns an iterator to retrieve all index entries.
Entries() (EntryIter, error)
// EntriesByOffset returns an iterator to retrieve all index entries ordered
// by offset.
EntriesByOffset() (EntryIter, error)
}
// MemoryIndex is the in memory representation of an idx file.
type MemoryIndex struct {
Version uint32
Fanout [256]uint32
// FanoutMapping maps the position in the fanout table to the position
// in the Names, Offset32 and CRC32 slices. This improves the memory
// usage by not needing an array with unnecessary empty slots.
FanoutMapping [256]int
Names [][]byte
Offset32 [][]byte
CRC32 [][]byte
Offset64 []byte
PackfileChecksum [hash.Size]byte
IdxChecksum [hash.Size]byte
offsetHash map[int64]plumbing.Hash
offsetHashIsFull bool
}
var _ Index = (*MemoryIndex)(nil)
// NewMemoryIndex returns an instance of a new MemoryIndex.
func NewMemoryIndex() *MemoryIndex {
return &MemoryIndex{}
}
func (idx *MemoryIndex) findHashIndex(h plumbing.Hash) (int, bool) {
k := idx.FanoutMapping[h[0]]
if k == noMapping {
return 0, false
}
if len(idx.Names) <= k {
return 0, false
}
data := idx.Names[k]
high := uint64(len(idx.Offset32[k])) >> 2
if high == 0 {
return 0, false
}
low := uint64(0)
for {
mid := (low + high) >> 1
offset := mid * objectIDLength
cmp := bytes.Compare(h[:], data[offset:offset+objectIDLength])
if cmp < 0 {
high = mid
} else if cmp == 0 {
return int(mid), true
} else {
low = mid + 1
}
if low >= high {
break
}
}
return 0, false
}
// Contains implements the Index interface.
func (idx *MemoryIndex) Contains(h plumbing.Hash) (bool, error) {
_, ok := idx.findHashIndex(h)
return ok, nil
}
// FindOffset implements the Index interface.
func (idx *MemoryIndex) FindOffset(h plumbing.Hash) (int64, error) {
if len(idx.FanoutMapping) <= int(h[0]) {
return 0, plumbing.ErrObjectNotFound
}
k := idx.FanoutMapping[h[0]]
i, ok := idx.findHashIndex(h)
if !ok {
return 0, plumbing.ErrObjectNotFound
}
offset := idx.getOffset(k, i)
if !idx.offsetHashIsFull {
// Save the offset for reverse lookup
if idx.offsetHash == nil {
idx.offsetHash = make(map[int64]plumbing.Hash)
}
idx.offsetHash[int64(offset)] = h
}
return int64(offset), nil
}
const isO64Mask = uint64(1) << 31
func (idx *MemoryIndex) getOffset(firstLevel, secondLevel int) uint64 {
offset := secondLevel << 2
ofs := encbin.BigEndian.Uint32(idx.Offset32[firstLevel][offset : offset+4])
if (uint64(ofs) & isO64Mask) != 0 {
offset := 8 * (uint64(ofs) & ^isO64Mask)
n := encbin.BigEndian.Uint64(idx.Offset64[offset : offset+8])
return n
}
return uint64(ofs)
}
// FindCRC32 implements the Index interface.
func (idx *MemoryIndex) FindCRC32(h plumbing.Hash) (uint32, error) {
k := idx.FanoutMapping[h[0]]
i, ok := idx.findHashIndex(h)
if !ok {
return 0, plumbing.ErrObjectNotFound
}
return idx.getCRC32(k, i), nil
}
func (idx *MemoryIndex) getCRC32(firstLevel, secondLevel int) uint32 {
offset := secondLevel << 2
return encbin.BigEndian.Uint32(idx.CRC32[firstLevel][offset : offset+4])
}
// FindHash implements the Index interface.
func (idx *MemoryIndex) FindHash(o int64) (plumbing.Hash, error) {
var hash plumbing.Hash
var ok bool
if idx.offsetHash != nil {
if hash, ok = idx.offsetHash[o]; ok {
return hash, nil
}
}
// Lazily generate the reverse offset/hash map if required.
if !idx.offsetHashIsFull || idx.offsetHash == nil {
if err := idx.genOffsetHash(); err != nil {
return plumbing.ZeroHash, err
}
hash, ok = idx.offsetHash[o]
}
if !ok {
return plumbing.ZeroHash, plumbing.ErrObjectNotFound
}
return hash, nil
}
// genOffsetHash generates the offset/hash mapping for reverse search.
func (idx *MemoryIndex) genOffsetHash() error {
count, err := idx.Count()
if err != nil {
return err
}
idx.offsetHash = make(map[int64]plumbing.Hash, count)
idx.offsetHashIsFull = true
var hash plumbing.Hash
i := uint32(0)
for firstLevel, fanoutValue := range idx.Fanout {
mappedFirstLevel := idx.FanoutMapping[firstLevel]
for secondLevel := uint32(0); i < fanoutValue; i++ {
copy(hash[:], idx.Names[mappedFirstLevel][secondLevel*objectIDLength:])
offset := int64(idx.getOffset(mappedFirstLevel, int(secondLevel)))
idx.offsetHash[offset] = hash
secondLevel++
}
}
return nil
}
// Count implements the Index interface.
func (idx *MemoryIndex) Count() (int64, error) {
return int64(idx.Fanout[fanout-1]), nil
}
// Entries implements the Index interface.
func (idx *MemoryIndex) Entries() (EntryIter, error) {
return &idxfileEntryIter{idx, 0, 0, 0}, nil
}
// EntriesByOffset implements the Index interface.
func (idx *MemoryIndex) EntriesByOffset() (EntryIter, error) {
count, err := idx.Count()
if err != nil {
return nil, err
}
iter := &idxfileEntryOffsetIter{
entries: make(entriesByOffset, count),
}
entries, err := idx.Entries()
if err != nil {
return nil, err
}
for pos := 0; int64(pos) < count; pos++ {
entry, err := entries.Next()
if err != nil {
return nil, err
}
iter.entries[pos] = entry
}
sort.Sort(iter.entries)
return iter, nil
}
// EntryIter is an iterator that will return the entries in a packfile index.
type EntryIter interface {
// Next returns the next entry in the packfile index.
Next() (*Entry, error)
// Close closes the iterator.
Close() error
}
type idxfileEntryIter struct {
idx *MemoryIndex
total int
firstLevel, secondLevel int
}
func (i *idxfileEntryIter) Next() (*Entry, error) {
for {
if i.firstLevel >= fanout {
return nil, io.EOF
}
if i.total >= int(i.idx.Fanout[i.firstLevel]) {
i.firstLevel++
i.secondLevel = 0
continue
}
mappedFirstLevel := i.idx.FanoutMapping[i.firstLevel]
entry := new(Entry)
copy(entry.Hash[:], i.idx.Names[mappedFirstLevel][i.secondLevel*objectIDLength:])
entry.Offset = i.idx.getOffset(mappedFirstLevel, i.secondLevel)
entry.CRC32 = i.idx.getCRC32(mappedFirstLevel, i.secondLevel)
i.secondLevel++
i.total++
return entry, nil
}
}
func (i *idxfileEntryIter) Close() error {
i.firstLevel = fanout
return nil
}
// Entry is the in memory representation of an object entry in the idx file.
type Entry struct {
Hash plumbing.Hash
CRC32 uint32
Offset uint64
}
type idxfileEntryOffsetIter struct {
entries entriesByOffset
pos int
}
func (i *idxfileEntryOffsetIter) Next() (*Entry, error) {
if i.pos >= len(i.entries) {
return nil, io.EOF
}
entry := i.entries[i.pos]
i.pos++
return entry, nil
}
func (i *idxfileEntryOffsetIter) Close() error {
i.pos = len(i.entries) + 1
return nil
}
type entriesByOffset []*Entry
func (o entriesByOffset) Len() int {
return len(o)
}
func (o entriesByOffset) Less(i int, j int) bool {
return o[i].Offset < o[j].Offset
}
func (o entriesByOffset) Swap(i int, j int) {
o[i], o[j] = o[j], o[i]
}
go-git-5.13.2/plumbing/format/idxfile/idxfile_test.go 0000664 0000000 0000000 00000006556 14744245500 0022554 0 ustar 00root root 0000000 0000000 package idxfile_test
import (
"bytes"
"encoding/base64"
"fmt"
"io"
"testing"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/idxfile"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func BenchmarkFindOffset(b *testing.B) {
idx, err := fixtureIndex()
if err != nil {
b.Fatalf(err.Error())
}
for i := 0; i < b.N; i++ {
for _, h := range fixtureHashes {
_, err := idx.FindOffset(h)
if err != nil {
b.Fatalf("error getting offset: %s", err)
}
}
}
}
func BenchmarkFindCRC32(b *testing.B) {
idx, err := fixtureIndex()
if err != nil {
b.Fatalf(err.Error())
}
for i := 0; i < b.N; i++ {
for _, h := range fixtureHashes {
_, err := idx.FindCRC32(h)
if err != nil {
b.Fatalf("error getting crc32: %s", err)
}
}
}
}
func BenchmarkContains(b *testing.B) {
idx, err := fixtureIndex()
if err != nil {
b.Fatalf(err.Error())
}
for i := 0; i < b.N; i++ {
for _, h := range fixtureHashes {
ok, err := idx.Contains(h)
if err != nil {
b.Fatalf("error checking if hash is in index: %s", err)
}
if !ok {
b.Error("expected hash to be in index")
}
}
}
}
func BenchmarkEntries(b *testing.B) {
idx, err := fixtureIndex()
if err != nil {
b.Fatalf(err.Error())
}
for i := 0; i < b.N; i++ {
iter, err := idx.Entries()
if err != nil {
b.Fatalf("unexpected error getting entries: %s", err)
}
var entries int
for {
_, err := iter.Next()
if err != nil {
if err == io.EOF {
break
}
b.Errorf("unexpected error getting entry: %s", err)
}
entries++
}
if entries != len(fixtureHashes) {
b.Errorf("expecting entries to be %d, got %d", len(fixtureHashes), entries)
}
}
}
type IndexSuite struct {
fixtures.Suite
}
var _ = Suite(&IndexSuite{})
func (s *IndexSuite) TestFindHash(c *C) {
idx, err := fixtureIndex()
c.Assert(err, IsNil)
for i, pos := range fixtureOffsets {
hash, err := idx.FindHash(pos)
c.Assert(err, IsNil)
c.Assert(hash, Equals, fixtureHashes[i])
}
}
func (s *IndexSuite) TestEntriesByOffset(c *C) {
idx, err := fixtureIndex()
c.Assert(err, IsNil)
entries, err := idx.EntriesByOffset()
c.Assert(err, IsNil)
for _, pos := range fixtureOffsets {
e, err := entries.Next()
c.Assert(err, IsNil)
c.Assert(e.Offset, Equals, uint64(pos))
}
}
var fixtureHashes = []plumbing.Hash{
plumbing.NewHash("303953e5aa461c203a324821bc1717f9b4fff895"),
plumbing.NewHash("5296768e3d9f661387ccbff18c4dea6c997fd78c"),
plumbing.NewHash("03fc8d58d44267274edef4585eaeeb445879d33f"),
plumbing.NewHash("8f3ceb4ea4cb9e4a0f751795eb41c9a4f07be772"),
plumbing.NewHash("e0d1d625010087f79c9e01ad9d8f95e1628dda02"),
plumbing.NewHash("90eba326cdc4d1d61c5ad25224ccbf08731dd041"),
plumbing.NewHash("bab53055add7bc35882758a922c54a874d6b1272"),
plumbing.NewHash("1b8995f51987d8a449ca5ea4356595102dc2fbd4"),
plumbing.NewHash("35858be9c6f5914cbe6768489c41eb6809a2bceb"),
}
var fixtureOffsets = []int64{
12,
142,
1601322837,
2646996529,
3452385606,
3707047470,
5323223332,
5894072943,
5924278919,
}
func fixtureIndex() (*idxfile.MemoryIndex, error) {
f := bytes.NewBufferString(fixtureLarge4GB)
idx := new(idxfile.MemoryIndex)
d := idxfile.NewDecoder(base64.NewDecoder(base64.StdEncoding, f))
err := d.Decode(idx)
if err != nil {
return nil, fmt.Errorf("unexpected error decoding index: %s", err)
}
return idx, nil
}
go-git-5.13.2/plumbing/format/idxfile/writer.go 0000664 0000000 0000000 00000010115 14744245500 0021367 0 ustar 00root root 0000000 0000000 package idxfile
import (
"bytes"
"fmt"
"math"
"sort"
"sync"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/utils/binary"
)
// objects implements sort.Interface and uses hash as sorting key.
type objects []Entry
// Writer implements a packfile Observer interface and is used to generate
// indexes.
type Writer struct {
m sync.Mutex
count uint32
checksum plumbing.Hash
objects objects
offset64 uint32
finished bool
index *MemoryIndex
added map[plumbing.Hash]struct{}
}
// Index returns a previously created MemoryIndex or creates a new one if
// needed.
func (w *Writer) Index() (*MemoryIndex, error) {
w.m.Lock()
defer w.m.Unlock()
if w.index == nil {
return w.createIndex()
}
return w.index, nil
}
// Add appends new object data.
func (w *Writer) Add(h plumbing.Hash, pos uint64, crc uint32) {
w.m.Lock()
defer w.m.Unlock()
if w.added == nil {
w.added = make(map[plumbing.Hash]struct{})
}
if _, ok := w.added[h]; !ok {
w.added[h] = struct{}{}
w.objects = append(w.objects, Entry{h, crc, pos})
}
}
func (w *Writer) Finished() bool {
return w.finished
}
// OnHeader implements packfile.Observer interface.
func (w *Writer) OnHeader(count uint32) error {
w.count = count
w.objects = make(objects, 0, count)
return nil
}
// OnInflatedObjectHeader implements packfile.Observer interface.
func (w *Writer) OnInflatedObjectHeader(t plumbing.ObjectType, objSize int64, pos int64) error {
return nil
}
// OnInflatedObjectContent implements packfile.Observer interface.
func (w *Writer) OnInflatedObjectContent(h plumbing.Hash, pos int64, crc uint32, _ []byte) error {
w.Add(h, uint64(pos), crc)
return nil
}
// OnFooter implements packfile.Observer interface.
func (w *Writer) OnFooter(h plumbing.Hash) error {
w.checksum = h
w.finished = true
_, err := w.createIndex()
return err
}
// creatIndex returns a filled MemoryIndex with the information filled by
// the observer callbacks.
func (w *Writer) createIndex() (*MemoryIndex, error) {
if !w.finished {
return nil, fmt.Errorf("the index still hasn't finished building")
}
idx := new(MemoryIndex)
w.index = idx
sort.Sort(w.objects)
// unmap all fans by default
for i := range idx.FanoutMapping {
idx.FanoutMapping[i] = noMapping
}
buf := new(bytes.Buffer)
last := -1
bucket := -1
for i, o := range w.objects {
fan := o.Hash[0]
// fill the gaps between fans
for j := last + 1; j < int(fan); j++ {
idx.Fanout[j] = uint32(i)
}
// update the number of objects for this position
idx.Fanout[fan] = uint32(i + 1)
// we move from one bucket to another, update counters and allocate
// memory
if last != int(fan) {
bucket++
idx.FanoutMapping[fan] = bucket
last = int(fan)
idx.Names = append(idx.Names, make([]byte, 0))
idx.Offset32 = append(idx.Offset32, make([]byte, 0))
idx.CRC32 = append(idx.CRC32, make([]byte, 0))
}
idx.Names[bucket] = append(idx.Names[bucket], o.Hash[:]...)
offset := o.Offset
if offset > math.MaxInt32 {
var err error
offset, err = w.addOffset64(offset)
if err != nil {
return nil, err
}
}
buf.Truncate(0)
if err := binary.WriteUint32(buf, uint32(offset)); err != nil {
return nil, err
}
idx.Offset32[bucket] = append(idx.Offset32[bucket], buf.Bytes()...)
buf.Truncate(0)
if err := binary.WriteUint32(buf, o.CRC32); err != nil {
return nil, err
}
idx.CRC32[bucket] = append(idx.CRC32[bucket], buf.Bytes()...)
}
for j := last + 1; j < 256; j++ {
idx.Fanout[j] = uint32(len(w.objects))
}
idx.Version = VersionSupported
idx.PackfileChecksum = w.checksum
return idx, nil
}
func (w *Writer) addOffset64(pos uint64) (uint64, error) {
buf := new(bytes.Buffer)
if err := binary.WriteUint64(buf, pos); err != nil {
return 0, err
}
w.index.Offset64 = append(w.index.Offset64, buf.Bytes()...)
index := uint64(w.offset64 | (1 << 31))
w.offset64++
return index, nil
}
func (o objects) Len() int {
return len(o)
}
func (o objects) Less(i int, j int) bool {
cmp := bytes.Compare(o[i].Hash[:], o[j].Hash[:])
return cmp < 0
}
func (o objects) Swap(i int, j int) {
o[i], o[j] = o[j], o[i]
}
go-git-5.13.2/plumbing/format/idxfile/writer_test.go 0000664 0000000 0000000 00000005023 14744245500 0022430 0 ustar 00root root 0000000 0000000 package idxfile_test
import (
"bytes"
"encoding/base64"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/idxfile"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type WriterSuite struct {
fixtures.Suite
}
var _ = Suite(&WriterSuite{})
func (s *WriterSuite) TestWriter(c *C) {
f := fixtures.Basic().One()
scanner := packfile.NewScanner(f.Packfile())
obs := new(idxfile.Writer)
parser, err := packfile.NewParser(scanner, obs)
c.Assert(err, IsNil)
_, err = parser.Parse()
c.Assert(err, IsNil)
idx, err := obs.Index()
c.Assert(err, IsNil)
idxFile := f.Idx()
expected, err := io.ReadAll(idxFile)
c.Assert(err, IsNil)
idxFile.Close()
buf := new(bytes.Buffer)
encoder := idxfile.NewEncoder(buf)
n, err := encoder.Encode(idx)
c.Assert(err, IsNil)
c.Assert(n, Equals, len(expected))
c.Assert(buf.Bytes(), DeepEquals, expected)
}
func (s *WriterSuite) TestWriterLarge(c *C) {
writer := new(idxfile.Writer)
err := writer.OnHeader(uint32(len(fixture4GbEntries)))
c.Assert(err, IsNil)
for _, o := range fixture4GbEntries {
err = writer.OnInflatedObjectContent(plumbing.NewHash(o.hash), o.offset, o.crc, nil)
c.Assert(err, IsNil)
}
err = writer.OnFooter(fixture4GbChecksum)
c.Assert(err, IsNil)
idx, err := writer.Index()
c.Assert(err, IsNil)
// load fixture index
f := bytes.NewBufferString(fixtureLarge4GB)
expected, err := io.ReadAll(base64.NewDecoder(base64.StdEncoding, f))
c.Assert(err, IsNil)
buf := new(bytes.Buffer)
encoder := idxfile.NewEncoder(buf)
n, err := encoder.Encode(idx)
c.Assert(err, IsNil)
c.Assert(n, Equals, len(expected))
c.Assert(buf.Bytes(), DeepEquals, expected)
}
var (
fixture4GbChecksum = plumbing.NewHash("afabc2269205cf85da1bf7e2fdff42f73810f29b")
fixture4GbEntries = []struct {
offset int64
hash string
crc uint32
}{
{12, "303953e5aa461c203a324821bc1717f9b4fff895", 0xbc347c4c},
{142, "5296768e3d9f661387ccbff18c4dea6c997fd78c", 0xcdc22842},
{1601322837, "03fc8d58d44267274edef4585eaeeb445879d33f", 0x929dfaaa},
{2646996529, "8f3ceb4ea4cb9e4a0f751795eb41c9a4f07be772", 0xa61def8a},
{3452385606, "e0d1d625010087f79c9e01ad9d8f95e1628dda02", 0x06bea180},
{3707047470, "90eba326cdc4d1d61c5ad25224ccbf08731dd041", 0x7193f3ba},
{5323223332, "bab53055add7bc35882758a922c54a874d6b1272", 0xac269b8e},
{5894072943, "1b8995f51987d8a449ca5ea4356595102dc2fbd4", 0x2187c056},
{5924278919, "35858be9c6f5914cbe6768489c41eb6809a2bceb", 0x9c89d9d2},
}
)
go-git-5.13.2/plumbing/format/index/ 0000775 0000000 0000000 00000000000 14744245500 0017211 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/format/index/decoder.go 0000664 0000000 0000000 00000023077 14744245500 0021156 0 ustar 00root root 0000000 0000000 package index
import (
"bufio"
"bytes"
"errors"
"io"
"strconv"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/utils/binary"
)
var (
// DecodeVersionSupported is the range of supported index versions
DecodeVersionSupported = struct{ Min, Max uint32 }{Min: 2, Max: 4}
// ErrMalformedSignature is returned by Decode when the index header file is
// malformed
ErrMalformedSignature = errors.New("malformed index signature file")
// ErrInvalidChecksum is returned by Decode if the SHA1 hash mismatch with
// the read content
ErrInvalidChecksum = errors.New("invalid checksum")
// ErrUnknownExtension is returned when an index extension is encountered that is considered mandatory
ErrUnknownExtension = errors.New("unknown extension")
)
const (
entryHeaderLength = 62
entryExtended = 0x4000
entryValid = 0x8000
nameMask = 0xfff
intentToAddMask = 1 << 13
skipWorkTreeMask = 1 << 14
)
// A Decoder reads and decodes index files from an input stream.
type Decoder struct {
buf *bufio.Reader
r io.Reader
hash hash.Hash
lastEntry *Entry
extReader *bufio.Reader
}
// NewDecoder returns a new decoder that reads from r.
func NewDecoder(r io.Reader) *Decoder {
h := hash.New(hash.CryptoType)
buf := bufio.NewReader(r)
return &Decoder{
buf: buf,
r: io.TeeReader(buf, h),
hash: h,
extReader: bufio.NewReader(nil),
}
}
// Decode reads the whole index object from its input and stores it in the
// value pointed to by idx.
func (d *Decoder) Decode(idx *Index) error {
var err error
idx.Version, err = validateHeader(d.r)
if err != nil {
return err
}
entryCount, err := binary.ReadUint32(d.r)
if err != nil {
return err
}
if err := d.readEntries(idx, int(entryCount)); err != nil {
return err
}
return d.readExtensions(idx)
}
func (d *Decoder) readEntries(idx *Index, count int) error {
for i := 0; i < count; i++ {
e, err := d.readEntry(idx)
if err != nil {
return err
}
d.lastEntry = e
idx.Entries = append(idx.Entries, e)
}
return nil
}
func (d *Decoder) readEntry(idx *Index) (*Entry, error) {
e := &Entry{}
var msec, mnsec, sec, nsec uint32
var flags uint16
flow := []interface{}{
&sec, &nsec,
&msec, &mnsec,
&e.Dev,
&e.Inode,
&e.Mode,
&e.UID,
&e.GID,
&e.Size,
&e.Hash,
&flags,
}
if err := binary.Read(d.r, flow...); err != nil {
return nil, err
}
read := entryHeaderLength
if sec != 0 || nsec != 0 {
e.CreatedAt = time.Unix(int64(sec), int64(nsec))
}
if msec != 0 || mnsec != 0 {
e.ModifiedAt = time.Unix(int64(msec), int64(mnsec))
}
e.Stage = Stage(flags>>12) & 0x3
if flags&entryExtended != 0 {
extended, err := binary.ReadUint16(d.r)
if err != nil {
return nil, err
}
read += 2
e.IntentToAdd = extended&intentToAddMask != 0
e.SkipWorktree = extended&skipWorkTreeMask != 0
}
if err := d.readEntryName(idx, e, flags); err != nil {
return nil, err
}
return e, d.padEntry(idx, e, read)
}
func (d *Decoder) readEntryName(idx *Index, e *Entry, flags uint16) error {
var name string
var err error
switch idx.Version {
case 2, 3:
len := flags & nameMask
name, err = d.doReadEntryName(len)
case 4:
name, err = d.doReadEntryNameV4()
default:
return ErrUnsupportedVersion
}
if err != nil {
return err
}
e.Name = name
return nil
}
func (d *Decoder) doReadEntryNameV4() (string, error) {
l, err := binary.ReadVariableWidthInt(d.r)
if err != nil {
return "", err
}
var base string
if d.lastEntry != nil {
base = d.lastEntry.Name[:len(d.lastEntry.Name)-int(l)]
}
name, err := binary.ReadUntil(d.r, '\x00')
if err != nil {
return "", err
}
return base + string(name), nil
}
func (d *Decoder) doReadEntryName(len uint16) (string, error) {
name := make([]byte, len)
_, err := io.ReadFull(d.r, name)
return string(name), err
}
// Index entries are padded out to the next 8 byte alignment
// for historical reasons related to how C Git read the files.
func (d *Decoder) padEntry(idx *Index, e *Entry, read int) error {
if idx.Version == 4 {
return nil
}
entrySize := read + len(e.Name)
padLen := 8 - entrySize%8
_, err := io.CopyN(io.Discard, d.r, int64(padLen))
return err
}
func (d *Decoder) readExtensions(idx *Index) error {
// TODO: support 'Split index' and 'Untracked cache' extensions, take in
// count that they are not supported by jgit or libgit
var expected []byte
var peeked []byte
var err error
// we should always be able to peek for 4 bytes (header) + 4 bytes (extlen) + final hash
// if this fails, we know that we're at the end of the index
peekLen := 4 + 4 + d.hash.Size()
for {
expected = d.hash.Sum(nil)
peeked, err = d.buf.Peek(peekLen)
if len(peeked) < peekLen {
// there can't be an extension at this point, so let's bail out
break
}
if err != nil {
return err
}
err = d.readExtension(idx)
if err != nil {
return err
}
}
return d.readChecksum(expected)
}
func (d *Decoder) readExtension(idx *Index) error {
var header [4]byte
if _, err := io.ReadFull(d.r, header[:]); err != nil {
return err
}
r, err := d.getExtensionReader()
if err != nil {
return err
}
switch {
case bytes.Equal(header[:], treeExtSignature):
idx.Cache = &Tree{}
d := &treeExtensionDecoder{r}
if err := d.Decode(idx.Cache); err != nil {
return err
}
case bytes.Equal(header[:], resolveUndoExtSignature):
idx.ResolveUndo = &ResolveUndo{}
d := &resolveUndoDecoder{r}
if err := d.Decode(idx.ResolveUndo); err != nil {
return err
}
case bytes.Equal(header[:], endOfIndexEntryExtSignature):
idx.EndOfIndexEntry = &EndOfIndexEntry{}
d := &endOfIndexEntryDecoder{r}
if err := d.Decode(idx.EndOfIndexEntry); err != nil {
return err
}
default:
// See https://git-scm.com/docs/index-format, which says:
// If the first byte is 'A'..'Z' the extension is optional and can be ignored.
if header[0] < 'A' || header[0] > 'Z' {
return ErrUnknownExtension
}
d := &unknownExtensionDecoder{r}
if err := d.Decode(); err != nil {
return err
}
}
return nil
}
func (d *Decoder) getExtensionReader() (*bufio.Reader, error) {
len, err := binary.ReadUint32(d.r)
if err != nil {
return nil, err
}
d.extReader.Reset(&io.LimitedReader{R: d.r, N: int64(len)})
return d.extReader, nil
}
func (d *Decoder) readChecksum(expected []byte) error {
var h plumbing.Hash
if _, err := io.ReadFull(d.r, h[:]); err != nil {
return err
}
if !bytes.Equal(h[:], expected) {
return ErrInvalidChecksum
}
return nil
}
func validateHeader(r io.Reader) (version uint32, err error) {
var s = make([]byte, 4)
if _, err := io.ReadFull(r, s); err != nil {
return 0, err
}
if !bytes.Equal(s, indexSignature) {
return 0, ErrMalformedSignature
}
version, err = binary.ReadUint32(r)
if err != nil {
return 0, err
}
if version < DecodeVersionSupported.Min || version > DecodeVersionSupported.Max {
return 0, ErrUnsupportedVersion
}
return
}
type treeExtensionDecoder struct {
r *bufio.Reader
}
func (d *treeExtensionDecoder) Decode(t *Tree) error {
for {
e, err := d.readEntry()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
if e == nil {
continue
}
t.Entries = append(t.Entries, *e)
}
}
func (d *treeExtensionDecoder) readEntry() (*TreeEntry, error) {
e := &TreeEntry{}
path, err := binary.ReadUntil(d.r, '\x00')
if err != nil {
return nil, err
}
e.Path = string(path)
count, err := binary.ReadUntil(d.r, ' ')
if err != nil {
return nil, err
}
i, err := strconv.Atoi(string(count))
if err != nil {
return nil, err
}
// An entry can be in an invalidated state and is represented by having a
// negative number in the entry_count field.
if i == -1 {
return nil, nil
}
e.Entries = i
trees, err := binary.ReadUntil(d.r, '\n')
if err != nil {
return nil, err
}
i, err = strconv.Atoi(string(trees))
if err != nil {
return nil, err
}
e.Trees = i
_, err = io.ReadFull(d.r, e.Hash[:])
if err != nil {
return nil, err
}
return e, nil
}
type resolveUndoDecoder struct {
r *bufio.Reader
}
func (d *resolveUndoDecoder) Decode(ru *ResolveUndo) error {
for {
e, err := d.readEntry()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
ru.Entries = append(ru.Entries, *e)
}
}
func (d *resolveUndoDecoder) readEntry() (*ResolveUndoEntry, error) {
e := &ResolveUndoEntry{
Stages: make(map[Stage]plumbing.Hash),
}
path, err := binary.ReadUntil(d.r, '\x00')
if err != nil {
return nil, err
}
e.Path = string(path)
for i := 0; i < 3; i++ {
if err := d.readStage(e, Stage(i+1)); err != nil {
return nil, err
}
}
for s := range e.Stages {
var hash plumbing.Hash
if _, err := io.ReadFull(d.r, hash[:]); err != nil {
return nil, err
}
e.Stages[s] = hash
}
return e, nil
}
func (d *resolveUndoDecoder) readStage(e *ResolveUndoEntry, s Stage) error {
ascii, err := binary.ReadUntil(d.r, '\x00')
if err != nil {
return err
}
stage, err := strconv.ParseInt(string(ascii), 8, 64)
if err != nil {
return err
}
if stage != 0 {
e.Stages[s] = plumbing.ZeroHash
}
return nil
}
type endOfIndexEntryDecoder struct {
r *bufio.Reader
}
func (d *endOfIndexEntryDecoder) Decode(e *EndOfIndexEntry) error {
var err error
e.Offset, err = binary.ReadUint32(d.r)
if err != nil {
return err
}
_, err = io.ReadFull(d.r, e.Hash[:])
return err
}
type unknownExtensionDecoder struct {
r *bufio.Reader
}
func (d *unknownExtensionDecoder) Decode() error {
var buf [1024]byte
for {
_, err := d.r.Read(buf[:])
if err == io.EOF {
break
}
if err != nil {
return err
}
}
return nil
}
go-git-5.13.2/plumbing/format/index/decoder_test.go 0000664 0000000 0000000 00000021424 14744245500 0022207 0 ustar 00root root 0000000 0000000 package index
import (
"bytes"
"crypto"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/utils/binary"
"io"
"testing"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type IndexSuite struct {
fixtures.Suite
}
var _ = Suite(&IndexSuite{})
func (s *IndexSuite) TestDecode(c *C) {
f, err := fixtures.Basic().One().DotGit().Open("index")
c.Assert(err, IsNil)
defer func() { c.Assert(f.Close(), IsNil) }()
idx := &Index{}
d := NewDecoder(f)
err = d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Version, Equals, uint32(2))
c.Assert(idx.Entries, HasLen, 9)
}
func (s *IndexSuite) TestDecodeEntries(c *C) {
f, err := fixtures.Basic().One().DotGit().Open("index")
c.Assert(err, IsNil)
defer func() { c.Assert(f.Close(), IsNil) }()
idx := &Index{}
d := NewDecoder(f)
err = d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
e := idx.Entries[0]
c.Assert(e.CreatedAt.Unix(), Equals, int64(1480626693))
c.Assert(e.CreatedAt.Nanosecond(), Equals, 498593596)
c.Assert(e.ModifiedAt.Unix(), Equals, int64(1480626693))
c.Assert(e.ModifiedAt.Nanosecond(), Equals, 498593596)
c.Assert(e.Dev, Equals, uint32(39))
c.Assert(e.Inode, Equals, uint32(140626))
c.Assert(e.UID, Equals, uint32(1000))
c.Assert(e.GID, Equals, uint32(100))
c.Assert(e.Size, Equals, uint32(189))
c.Assert(e.Hash.String(), Equals, "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88")
c.Assert(e.Name, Equals, ".gitignore")
c.Assert(e.Mode, Equals, filemode.Regular)
e = idx.Entries[1]
c.Assert(e.Name, Equals, "CHANGELOG")
}
func (s *IndexSuite) TestDecodeCacheTree(c *C) {
f, err := fixtures.Basic().One().DotGit().Open("index")
c.Assert(err, IsNil)
defer func() { c.Assert(f.Close(), IsNil) }()
idx := &Index{}
d := NewDecoder(f)
err = d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
c.Assert(idx.Cache.Entries, HasLen, 5)
for i, expected := range expectedEntries {
c.Assert(idx.Cache.Entries[i].Path, Equals, expected.Path)
c.Assert(idx.Cache.Entries[i].Entries, Equals, expected.Entries)
c.Assert(idx.Cache.Entries[i].Trees, Equals, expected.Trees)
c.Assert(idx.Cache.Entries[i].Hash.String(), Equals, expected.Hash.String())
}
}
var expectedEntries = []TreeEntry{
{Path: "", Entries: 9, Trees: 4, Hash: plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")},
{Path: "go", Entries: 1, Trees: 0, Hash: plumbing.NewHash("a39771a7651f97faf5c72e08224d857fc35133db")},
{Path: "php", Entries: 1, Trees: 0, Hash: plumbing.NewHash("586af567d0bb5e771e49bdd9434f5e0fb76d25fa")},
{Path: "json", Entries: 2, Trees: 0, Hash: plumbing.NewHash("5a877e6a906a2743ad6e45d99c1793642aaf8eda")},
{Path: "vendor", Entries: 1, Trees: 0, Hash: plumbing.NewHash("cf4aa3b38974fb7d81f367c0830f7d78d65ab86b")},
}
func (s *IndexSuite) TestDecodeMergeConflict(c *C) {
f, err := fixtures.Basic().ByTag("merge-conflict").One().DotGit().Open("index")
c.Assert(err, IsNil)
defer func() { c.Assert(f.Close(), IsNil) }()
idx := &Index{}
d := NewDecoder(f)
err = d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Version, Equals, uint32(2))
c.Assert(idx.Entries, HasLen, 13)
expected := []struct {
Stage Stage
Hash string
}{
{AncestorMode, "880cd14280f4b9b6ed3986d6671f907d7cc2a198"},
{OurMode, "d499a1a0b79b7d87a35155afd0c1cce78b37a91c"},
{TheirMode, "14f8e368114f561c38e134f6e68ea6fea12d77ed"},
}
// staged files
for i, e := range idx.Entries[4:7] {
c.Assert(e.Stage, Equals, expected[i].Stage)
c.Assert(e.CreatedAt.IsZero(), Equals, true)
c.Assert(e.ModifiedAt.IsZero(), Equals, true)
c.Assert(e.Dev, Equals, uint32(0))
c.Assert(e.Inode, Equals, uint32(0))
c.Assert(e.UID, Equals, uint32(0))
c.Assert(e.GID, Equals, uint32(0))
c.Assert(e.Size, Equals, uint32(0))
c.Assert(e.Hash.String(), Equals, expected[i].Hash)
c.Assert(e.Name, Equals, "go/example.go")
}
}
func (s *IndexSuite) TestDecodeExtendedV3(c *C) {
f, err := fixtures.Basic().ByTag("intent-to-add").One().DotGit().Open("index")
c.Assert(err, IsNil)
defer func() { c.Assert(f.Close(), IsNil) }()
idx := &Index{}
d := NewDecoder(f)
err = d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Version, Equals, uint32(3))
c.Assert(idx.Entries, HasLen, 11)
c.Assert(idx.Entries[6].Name, Equals, "intent-to-add")
c.Assert(idx.Entries[6].IntentToAdd, Equals, true)
c.Assert(idx.Entries[6].SkipWorktree, Equals, false)
}
func (s *IndexSuite) TestDecodeResolveUndo(c *C) {
f, err := fixtures.Basic().ByTag("resolve-undo").One().DotGit().Open("index")
c.Assert(err, IsNil)
defer func() { c.Assert(f.Close(), IsNil) }()
idx := &Index{}
d := NewDecoder(f)
err = d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Version, Equals, uint32(2))
c.Assert(idx.Entries, HasLen, 8)
ru := idx.ResolveUndo
c.Assert(ru.Entries, HasLen, 2)
c.Assert(ru.Entries[0].Path, Equals, "go/example.go")
c.Assert(ru.Entries[0].Stages, HasLen, 3)
c.Assert(ru.Entries[0].Stages[AncestorMode], Not(Equals), plumbing.ZeroHash)
c.Assert(ru.Entries[0].Stages[OurMode], Not(Equals), plumbing.ZeroHash)
c.Assert(ru.Entries[0].Stages[TheirMode], Not(Equals), plumbing.ZeroHash)
c.Assert(ru.Entries[1].Path, Equals, "haskal/haskal.hs")
c.Assert(ru.Entries[1].Stages, HasLen, 2)
c.Assert(ru.Entries[1].Stages[OurMode], Not(Equals), plumbing.ZeroHash)
c.Assert(ru.Entries[1].Stages[TheirMode], Not(Equals), plumbing.ZeroHash)
}
func (s *IndexSuite) TestDecodeV4(c *C) {
f, err := fixtures.Basic().ByTag("index-v4").One().DotGit().Open("index")
c.Assert(err, IsNil)
defer func() { c.Assert(f.Close(), IsNil) }()
idx := &Index{}
d := NewDecoder(f)
err = d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Version, Equals, uint32(4))
c.Assert(idx.Entries, HasLen, 11)
names := []string{
".gitignore", "CHANGELOG", "LICENSE", "binary.jpg", "go/example.go",
"haskal/haskal.hs", "intent-to-add", "json/long.json",
"json/short.json", "php/crappy.php", "vendor/foo.go",
}
for i, e := range idx.Entries {
c.Assert(e.Name, Equals, names[i])
}
c.Assert(idx.Entries[6].Name, Equals, "intent-to-add")
c.Assert(idx.Entries[6].IntentToAdd, Equals, true)
c.Assert(idx.Entries[6].SkipWorktree, Equals, false)
}
func (s *IndexSuite) TestDecodeEndOfIndexEntry(c *C) {
f, err := fixtures.Basic().ByTag("end-of-index-entry").One().DotGit().Open("index")
c.Assert(err, IsNil)
defer func() { c.Assert(f.Close(), IsNil) }()
idx := &Index{}
d := NewDecoder(f)
err = d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Version, Equals, uint32(2))
c.Assert(idx.EndOfIndexEntry, NotNil)
c.Assert(idx.EndOfIndexEntry.Offset, Equals, uint32(716))
c.Assert(idx.EndOfIndexEntry.Hash.String(), Equals, "922e89d9ffd7cefce93a211615b2053c0f42bd78")
}
func (s *IndexSuite) readSimpleIndex(c *C) *Index {
f, err := fixtures.Basic().One().DotGit().Open("index")
c.Assert(err, IsNil)
defer func() { c.Assert(f.Close(), IsNil) }()
idx := &Index{}
d := NewDecoder(f)
err = d.Decode(idx)
c.Assert(err, IsNil)
return idx
}
func (s *IndexSuite) buildIndexWithExtension(c *C, signature string, data string) []byte {
idx := s.readSimpleIndex(c)
buf := bytes.NewBuffer(nil)
e := NewEncoder(buf)
err := e.encode(idx, false)
c.Assert(err, IsNil)
err = e.encodeRawExtension(signature, []byte(data))
c.Assert(err, IsNil)
err = e.encodeFooter()
c.Assert(err, IsNil)
return buf.Bytes()
}
func (s *IndexSuite) TestDecodeUnknownOptionalExt(c *C) {
f := bytes.NewReader(s.buildIndexWithExtension(c, "TEST", "testdata"))
idx := &Index{}
d := NewDecoder(f)
err := d.Decode(idx)
c.Assert(err, IsNil)
}
func (s *IndexSuite) TestDecodeUnknownMandatoryExt(c *C) {
f := bytes.NewReader(s.buildIndexWithExtension(c, "test", "testdata"))
idx := &Index{}
d := NewDecoder(f)
err := d.Decode(idx)
c.Assert(err, ErrorMatches, ErrUnknownExtension.Error())
}
func (s *IndexSuite) TestDecodeTruncatedExt(c *C) {
idx := s.readSimpleIndex(c)
buf := bytes.NewBuffer(nil)
e := NewEncoder(buf)
err := e.encode(idx, false)
c.Assert(err, IsNil)
_, err = e.w.Write([]byte("TEST"))
c.Assert(err, IsNil)
err = binary.WriteUint32(e.w, uint32(100))
c.Assert(err, IsNil)
_, err = e.w.Write([]byte("truncated"))
c.Assert(err, IsNil)
err = e.encodeFooter()
c.Assert(err, IsNil)
idx = &Index{}
d := NewDecoder(buf)
err = d.Decode(idx)
c.Assert(err, ErrorMatches, io.EOF.Error())
}
func (s *IndexSuite) TestDecodeInvalidHash(c *C) {
idx := s.readSimpleIndex(c)
buf := bytes.NewBuffer(nil)
e := NewEncoder(buf)
err := e.encode(idx, false)
c.Assert(err, IsNil)
err = e.encodeRawExtension("TEST", []byte("testdata"))
c.Assert(err, IsNil)
h := hash.New(crypto.SHA1)
err = binary.Write(e.w, h.Sum(nil))
c.Assert(err, IsNil)
idx = &Index{}
d := NewDecoder(buf)
err = d.Decode(idx)
c.Assert(err, ErrorMatches, ErrInvalidChecksum.Error())
}
go-git-5.13.2/plumbing/format/index/doc.go 0000664 0000000 0000000 00000033032 14744245500 0020306 0 ustar 00root root 0000000 0000000 // Package index implements encoding and decoding of index format files.
//
// Git index format
// ================
//
// == The Git index file has the following format
//
// All binary numbers are in network byte order. Version 2 is described
// here unless stated otherwise.
//
// - A 12-byte header consisting of
//
// 4-byte signature:
// The signature is { 'D', 'I', 'R', 'C' } (stands for "dircache")
//
// 4-byte version number:
// The current supported versions are 2, 3 and 4.
//
// 32-bit number of index entries.
//
// - A number of sorted index entries (see below).
//
// - Extensions
//
// Extensions are identified by signature. Optional extensions can
// be ignored if Git does not understand them.
//
// Git currently supports cached tree and resolve undo extensions.
//
// 4-byte extension signature. If the first byte is 'A'..'Z' the
// extension is optional and can be ignored.
//
// 32-bit size of the extension
//
// Extension data
//
// - 160-bit SHA-1 over the content of the index file before this
// checksum.
//
// == Index entry
//
// Index entries are sorted in ascending order on the name field,
// interpreted as a string of unsigned bytes (i.e. memcmp() order, no
// localization, no special casing of directory separator '/'). Entries
// with the same name are sorted by their stage field.
//
// 32-bit ctime seconds, the last time a file's metadata changed
// this is stat(2) data
//
// 32-bit ctime nanosecond fractions
// this is stat(2) data
//
// 32-bit mtime seconds, the last time a file's data changed
// this is stat(2) data
//
// 32-bit mtime nanosecond fractions
// this is stat(2) data
//
// 32-bit dev
// this is stat(2) data
//
// 32-bit ino
// this is stat(2) data
//
// 32-bit mode, split into (high to low bits)
//
// 4-bit object type
// valid values in binary are 1000 (regular file), 1010 (symbolic link)
// and 1110 (gitlink)
//
// 3-bit unused
//
// 9-bit unix permission. Only 0755 and 0644 are valid for regular files.
// Symbolic links and gitlinks have value 0 in this field.
//
// 32-bit uid
// this is stat(2) data
//
// 32-bit gid
// this is stat(2) data
//
// 32-bit file size
// This is the on-disk size from stat(2), truncated to 32-bit.
//
// 160-bit SHA-1 for the represented object
//
// A 16-bit 'flags' field split into (high to low bits)
//
// 1-bit assume-valid flag
//
// 1-bit extended flag (must be zero in version 2)
//
// 2-bit stage (during merge)
//
// 12-bit name length if the length is less than 0xFFF; otherwise 0xFFF
// is stored in this field.
//
// (Version 3 or later) A 16-bit field, only applicable if the
// "extended flag" above is 1, split into (high to low bits).
//
// 1-bit reserved for future
//
// 1-bit skip-worktree flag (used by sparse checkout)
//
// 1-bit intent-to-add flag (used by "git add -N")
//
// 13-bit unused, must be zero
//
// Entry path name (variable length) relative to top level directory
// (without leading slash). '/' is used as path separator. The special
// path components ".", ".." and ".git" (without quotes) are disallowed.
// Trailing slash is also disallowed.
//
// The exact encoding is undefined, but the '.' and '/' characters
// are encoded in 7-bit ASCII and the encoding cannot contain a NUL
// byte (iow, this is a UNIX pathname).
//
// (Version 4) In version 4, the entry path name is prefix-compressed
// relative to the path name for the previous entry (the very first
// entry is encoded as if the path name for the previous entry is an
// empty string). At the beginning of an entry, an integer N in the
// variable width encoding (the same encoding as the offset is encoded
// for OFS_DELTA pack entries; see pack-format.txt) is stored, followed
// by a NUL-terminated string S. Removing N bytes from the end of the
// path name for the previous entry, and replacing it with the string S
// yields the path name for this entry.
//
// 1-8 nul bytes as necessary to pad the entry to a multiple of eight bytes
// while keeping the name NUL-terminated.
//
// (Version 4) In version 4, the padding after the pathname does not
// exist.
//
// Interpretation of index entries in split index mode is completely
// different. See below for details.
//
// == Extensions
//
// === Cached tree
//
// Cached tree extension contains pre-computed hashes for trees that can
// be derived from the index. It helps speed up tree object generation
// from index for a new commit.
//
// When a path is updated in index, the path must be invalidated and
// removed from tree cache.
//
// The signature for this extension is { 'T', 'R', 'E', 'E' }.
//
// A series of entries fill the entire extension; each of which
// consists of:
//
// - NUL-terminated path component (relative to its parent directory);
//
// - ASCII decimal number of entries in the index that is covered by the
// tree this entry represents (entry_count);
//
// - A space (ASCII 32);
//
// - ASCII decimal number that represents the number of subtrees this
// tree has;
//
// - A newline (ASCII 10); and
//
// - 160-bit object name for the object that would result from writing
// this span of index as a tree.
//
// An entry can be in an invalidated state and is represented by having
// a negative number in the entry_count field. In this case, there is no
// object name and the next entry starts immediately after the newline.
// When writing an invalid entry, -1 should always be used as entry_count.
//
// The entries are written out in the top-down, depth-first order. The
// first entry represents the root level of the repository, followed by the
// first subtree--let's call this A--of the root level (with its name
// relative to the root level), followed by the first subtree of A (with
// its name relative to A), ...
//
// === Resolve undo
//
// A conflict is represented in the index as a set of higher stage entries.
// When a conflict is resolved (e.g. with "git add path"), these higher
// stage entries will be removed and a stage-0 entry with proper resolution
// is added.
//
// When these higher stage entries are removed, they are saved in the
// resolve undo extension, so that conflicts can be recreated (e.g. with
// "git checkout -m"), in case users want to redo a conflict resolution
// from scratch.
//
// The signature for this extension is { 'R', 'E', 'U', 'C' }.
//
// A series of entries fill the entire extension; each of which
// consists of:
//
// - NUL-terminated pathname the entry describes (relative to the root of
// the repository, i.e. full pathname);
//
// - Three NUL-terminated ASCII octal numbers, entry mode of entries in
// stage 1 to 3 (a missing stage is represented by "0" in this field);
// and
//
// - At most three 160-bit object names of the entry in stages from 1 to 3
// (nothing is written for a missing stage).
//
// === Split index
//
// In split index mode, the majority of index entries could be stored
// in a separate file. This extension records the changes to be made on
// top of that to produce the final index.
//
// The signature for this extension is { 'l', 'i', 'n', 'k' }.
//
// The extension consists of:
//
// - 160-bit SHA-1 of the shared index file. The shared index file path
// is $GIT_DIR/sharedindex.. If all 160 bits are zero, the
// index does not require a shared index file.
//
// - An ewah-encoded delete bitmap, each bit represents an entry in the
// shared index. If a bit is set, its corresponding entry in the
// shared index will be removed from the final index. Note, because
// a delete operation changes index entry positions, but we do need
// original positions in replace phase, it's best to just mark
// entries for removal, then do a mass deletion after replacement.
//
// - An ewah-encoded replace bitmap, each bit represents an entry in
// the shared index. If a bit is set, its corresponding entry in the
// shared index will be replaced with an entry in this index
// file. All replaced entries are stored in sorted order in this
// index. The first "1" bit in the replace bitmap corresponds to the
// first index entry, the second "1" bit to the second entry and so
// on. Replaced entries may have empty path names to save space.
//
// The remaining index entries after replaced ones will be added to the
// final index. These added entries are also sorted by entry name then
// stage.
//
// == Untracked cache
//
// Untracked cache saves the untracked file list and necessary data to
// verify the cache. The signature for this extension is { 'U', 'N',
// 'T', 'R' }.
//
// The extension starts with
//
// - A sequence of NUL-terminated strings, preceded by the size of the
// sequence in variable width encoding. Each string describes the
// environment where the cache can be used.
//
// - Stat data of $GIT_DIR/info/exclude. See "Index entry" section from
// ctime field until "file size".
//
// - Stat data of plumbing.excludesfile
//
// - 32-bit dir_flags (see struct dir_struct)
//
// - 160-bit SHA-1 of $GIT_DIR/info/exclude. Null SHA-1 means the file
// does not exist.
//
// - 160-bit SHA-1 of plumbing.excludesfile. Null SHA-1 means the file does
// not exist.
//
// - NUL-terminated string of per-dir exclude file name. This usually
// is ".gitignore".
//
// - The number of following directory blocks, variable width
// encoding. If this number is zero, the extension ends here with a
// following NUL.
//
// - A number of directory blocks in depth-first-search order, each
// consists of
//
// - The number of untracked entries, variable width encoding.
//
// - The number of sub-directory blocks, variable width encoding.
//
// - The directory name terminated by NUL.
//
// - A number of untracked file/dir names terminated by NUL.
//
// The remaining data of each directory block is grouped by type:
//
// - An ewah bitmap, the n-th bit marks whether the n-th directory has
// valid untracked cache entries.
//
// - An ewah bitmap, the n-th bit records "check-only" bit of
// read_directory_recursive() for the n-th directory.
//
// - An ewah bitmap, the n-th bit indicates whether SHA-1 and stat data
// is valid for the n-th directory and exists in the next data.
//
// - An array of stat data. The n-th data corresponds with the n-th
// "one" bit in the previous ewah bitmap.
//
// - An array of SHA-1. The n-th SHA-1 corresponds with the n-th "one" bit
// in the previous ewah bitmap.
//
// - One NUL.
//
// == File System Monitor cache
//
// The file system monitor cache tracks files for which the core.fsmonitor
// hook has told us about changes. The signature for this extension is
// { 'F', 'S', 'M', 'N' }.
//
// The extension starts with
//
// - 32-bit version number: the current supported version is 1.
//
// - 64-bit time: the extension data reflects all changes through the given
// time which is stored as the nanoseconds elapsed since midnight,
// January 1, 1970.
//
// - 32-bit bitmap size: the size of the CE_FSMONITOR_VALID bitmap.
//
// - An ewah bitmap, the n-th bit indicates whether the n-th index entry
// is not CE_FSMONITOR_VALID.
//
// == End of Index Entry
//
// The End of Index Entry (EOIE) is used to locate the end of the variable
// length index entries and the beginning of the extensions. Code can take
// advantage of this to quickly locate the index extensions without having
// to parse through all of the index entries.
//
// Because it must be able to be loaded before the variable length cache
// entries and other index extensions, this extension must be written last.
// The signature for this extension is { 'E', 'O', 'I', 'E' }.
//
// The extension consists of:
//
// - 32-bit offset to the end of the index entries
//
// - 160-bit SHA-1 over the extension types and their sizes (but not
// their contents). E.g. if we have "TREE" extension that is N-bytes
// long, "REUC" extension that is M-bytes long, followed by "EOIE",
// then the hash would be:
//
// SHA-1("TREE" + +
// "REUC" + )
//
// == Index Entry Offset Table
//
// The Index Entry Offset Table (IEOT) is used to help address the CPU
// cost of loading the index by enabling multi-threading the process of
// converting cache entries from the on-disk format to the in-memory format.
// The signature for this extension is { 'I', 'E', 'O', 'T' }.
//
// The extension consists of:
//
// - 32-bit version (currently 1)
//
// - A number of index offset entries each consisting of:
//
// - 32-bit offset from the beginning of the file to the first cache entry
// in this block of entries.
//
// - 32-bit count of cache entries in this blockpackage index
package index
go-git-5.13.2/plumbing/format/index/encoder.go 0000664 0000000 0000000 00000011123 14744245500 0021155 0 ustar 00root root 0000000 0000000 package index
import (
"bytes"
"errors"
"fmt"
"io"
"path"
"sort"
"strings"
"time"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/utils/binary"
)
var (
// EncodeVersionSupported is the range of supported index versions
EncodeVersionSupported uint32 = 4
// ErrInvalidTimestamp is returned by Encode if a Index with a Entry with
// negative timestamp values
ErrInvalidTimestamp = errors.New("negative timestamps are not allowed")
)
// An Encoder writes an Index to an output stream.
type Encoder struct {
w io.Writer
hash hash.Hash
lastEntry *Entry
}
// NewEncoder returns a new encoder that writes to w.
func NewEncoder(w io.Writer) *Encoder {
h := hash.New(hash.CryptoType)
mw := io.MultiWriter(w, h)
return &Encoder{mw, h, nil}
}
// Encode writes the Index to the stream of the encoder.
func (e *Encoder) Encode(idx *Index) error {
return e.encode(idx, true)
}
func (e *Encoder) encode(idx *Index, footer bool) error {
// TODO: support extensions
if idx.Version > EncodeVersionSupported {
return ErrUnsupportedVersion
}
if err := e.encodeHeader(idx); err != nil {
return err
}
if err := e.encodeEntries(idx); err != nil {
return err
}
if footer {
return e.encodeFooter()
}
return nil
}
func (e *Encoder) encodeHeader(idx *Index) error {
return binary.Write(e.w,
indexSignature,
idx.Version,
uint32(len(idx.Entries)),
)
}
func (e *Encoder) encodeEntries(idx *Index) error {
sort.Sort(byName(idx.Entries))
for _, entry := range idx.Entries {
if err := e.encodeEntry(idx, entry); err != nil {
return err
}
entryLength := entryHeaderLength
if entry.IntentToAdd || entry.SkipWorktree {
entryLength += 2
}
wrote := entryLength + len(entry.Name)
if err := e.padEntry(idx, wrote); err != nil {
return err
}
}
return nil
}
func (e *Encoder) encodeEntry(idx *Index, entry *Entry) error {
sec, nsec, err := e.timeToUint32(&entry.CreatedAt)
if err != nil {
return err
}
msec, mnsec, err := e.timeToUint32(&entry.ModifiedAt)
if err != nil {
return err
}
flags := uint16(entry.Stage&0x3) << 12
if l := len(entry.Name); l < nameMask {
flags |= uint16(l)
} else {
flags |= nameMask
}
flow := []interface{}{
sec, nsec,
msec, mnsec,
entry.Dev,
entry.Inode,
entry.Mode,
entry.UID,
entry.GID,
entry.Size,
entry.Hash[:],
}
flagsFlow := []interface{}{flags}
if entry.IntentToAdd || entry.SkipWorktree {
var extendedFlags uint16
if entry.IntentToAdd {
extendedFlags |= intentToAddMask
}
if entry.SkipWorktree {
extendedFlags |= skipWorkTreeMask
}
flagsFlow = []interface{}{flags | entryExtended, extendedFlags}
}
flow = append(flow, flagsFlow...)
if err := binary.Write(e.w, flow...); err != nil {
return err
}
switch idx.Version {
case 2, 3:
err = e.encodeEntryName(entry)
case 4:
err = e.encodeEntryNameV4(entry)
default:
err = ErrUnsupportedVersion
}
return err
}
func (e *Encoder) encodeEntryName(entry *Entry) error {
return binary.Write(e.w, []byte(entry.Name))
}
func (e *Encoder) encodeEntryNameV4(entry *Entry) error {
name := entry.Name
l := 0
if e.lastEntry != nil {
dir := path.Dir(e.lastEntry.Name) + "/"
if strings.HasPrefix(entry.Name, dir) {
l = len(e.lastEntry.Name) - len(dir)
name = strings.TrimPrefix(entry.Name, dir)
} else {
l = len(e.lastEntry.Name)
}
}
e.lastEntry = entry
err := binary.WriteVariableWidthInt(e.w, int64(l))
if err != nil {
return err
}
return binary.Write(e.w, []byte(name+string('\x00')))
}
func (e *Encoder) encodeRawExtension(signature string, data []byte) error {
if len(signature) != 4 {
return fmt.Errorf("invalid signature length")
}
_, err := e.w.Write([]byte(signature))
if err != nil {
return err
}
err = binary.WriteUint32(e.w, uint32(len(data)))
if err != nil {
return err
}
_, err = e.w.Write(data)
if err != nil {
return err
}
return nil
}
func (e *Encoder) timeToUint32(t *time.Time) (uint32, uint32, error) {
if t.IsZero() {
return 0, 0, nil
}
if t.Unix() < 0 || t.UnixNano() < 0 {
return 0, 0, ErrInvalidTimestamp
}
return uint32(t.Unix()), uint32(t.Nanosecond()), nil
}
func (e *Encoder) padEntry(idx *Index, wrote int) error {
if idx.Version == 4 {
return nil
}
padLen := 8 - wrote%8
_, err := e.w.Write(bytes.Repeat([]byte{'\x00'}, padLen))
return err
}
func (e *Encoder) encodeFooter() error {
return binary.Write(e.w, e.hash.Sum(nil))
}
type byName []*Entry
func (l byName) Len() int { return len(l) }
func (l byName) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
func (l byName) Less(i, j int) bool { return l[i].Name < l[j].Name }
go-git-5.13.2/plumbing/format/index/encoder_test.go 0000664 0000000 0000000 00000007003 14744245500 0022216 0 ustar 00root root 0000000 0000000 package index
import (
"bytes"
"strings"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/google/go-cmp/cmp"
. "gopkg.in/check.v1"
)
func (s *IndexSuite) TestEncode(c *C) {
idx := &Index{
Version: 2,
Entries: []*Entry{{
CreatedAt: time.Now(),
ModifiedAt: time.Now(),
Dev: 4242,
Inode: 424242,
UID: 84,
GID: 8484,
Size: 42,
Stage: TheirMode,
Hash: plumbing.NewHash("e25b29c8946e0e192fae2edc1dabf7be71e8ecf3"),
Name: "foo",
}, {
CreatedAt: time.Now(),
ModifiedAt: time.Now(),
Name: "bar",
Size: 82,
}, {
CreatedAt: time.Now(),
ModifiedAt: time.Now(),
Name: strings.Repeat(" ", 20),
Size: 82,
}},
}
buf := bytes.NewBuffer(nil)
e := NewEncoder(buf)
err := e.Encode(idx)
c.Assert(err, IsNil)
output := &Index{}
d := NewDecoder(buf)
err = d.Decode(output)
c.Assert(err, IsNil)
c.Assert(cmp.Equal(idx, output), Equals, true)
c.Assert(output.Entries[0].Name, Equals, strings.Repeat(" ", 20))
c.Assert(output.Entries[1].Name, Equals, "bar")
c.Assert(output.Entries[2].Name, Equals, "foo")
}
func (s *IndexSuite) TestEncodeV4(c *C) {
idx := &Index{
Version: 4,
Entries: []*Entry{{
CreatedAt: time.Now(),
ModifiedAt: time.Now(),
Dev: 4242,
Inode: 424242,
UID: 84,
GID: 8484,
Size: 42,
Stage: TheirMode,
Hash: plumbing.NewHash("e25b29c8946e0e192fae2edc1dabf7be71e8ecf3"),
Name: "foo",
}, {
CreatedAt: time.Now(),
ModifiedAt: time.Now(),
Name: "bar",
Size: 82,
}, {
CreatedAt: time.Now(),
ModifiedAt: time.Now(),
Name: strings.Repeat(" ", 20),
Size: 82,
}, {
CreatedAt: time.Now(),
ModifiedAt: time.Now(),
Name: "baz/bar",
Size: 82,
}, {
CreatedAt: time.Now(),
ModifiedAt: time.Now(),
Name: "baz/bar/bar",
Size: 82,
}},
}
buf := bytes.NewBuffer(nil)
e := NewEncoder(buf)
err := e.Encode(idx)
c.Assert(err, IsNil)
output := &Index{}
d := NewDecoder(buf)
err = d.Decode(output)
c.Assert(err, IsNil)
c.Assert(cmp.Equal(idx, output), Equals, true)
c.Assert(output.Entries[0].Name, Equals, strings.Repeat(" ", 20))
c.Assert(output.Entries[1].Name, Equals, "bar")
c.Assert(output.Entries[2].Name, Equals, "baz/bar")
c.Assert(output.Entries[3].Name, Equals, "baz/bar/bar")
c.Assert(output.Entries[4].Name, Equals, "foo")
}
func (s *IndexSuite) TestEncodeUnsupportedVersion(c *C) {
idx := &Index{Version: 5}
buf := bytes.NewBuffer(nil)
e := NewEncoder(buf)
err := e.Encode(idx)
c.Assert(err, Equals, ErrUnsupportedVersion)
}
func (s *IndexSuite) TestEncodeWithIntentToAddUnsupportedVersion(c *C) {
idx := &Index{
Version: 3,
Entries: []*Entry{{IntentToAdd: true}},
}
buf := bytes.NewBuffer(nil)
e := NewEncoder(buf)
err := e.Encode(idx)
c.Assert(err, IsNil)
output := &Index{}
d := NewDecoder(buf)
err = d.Decode(output)
c.Assert(err, IsNil)
c.Assert(cmp.Equal(idx, output), Equals, true)
c.Assert(output.Entries[0].IntentToAdd, Equals, true)
}
func (s *IndexSuite) TestEncodeWithSkipWorktreeUnsupportedVersion(c *C) {
idx := &Index{
Version: 3,
Entries: []*Entry{{SkipWorktree: true}},
}
buf := bytes.NewBuffer(nil)
e := NewEncoder(buf)
err := e.Encode(idx)
c.Assert(err, IsNil)
output := &Index{}
d := NewDecoder(buf)
err = d.Decode(output)
c.Assert(err, IsNil)
c.Assert(cmp.Equal(idx, output), Equals, true)
c.Assert(output.Entries[0].SkipWorktree, Equals, true)
}
go-git-5.13.2/plumbing/format/index/index.go 0000664 0000000 0000000 00000015574 14744245500 0020663 0 ustar 00root root 0000000 0000000 package index
import (
"bytes"
"errors"
"fmt"
"path/filepath"
"strings"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
)
var (
// ErrUnsupportedVersion is returned by Decode when the index file version
// is not supported.
ErrUnsupportedVersion = errors.New("unsupported version")
// ErrEntryNotFound is returned by Index.Entry, if an entry is not found.
ErrEntryNotFound = errors.New("entry not found")
indexSignature = []byte{'D', 'I', 'R', 'C'}
treeExtSignature = []byte{'T', 'R', 'E', 'E'}
resolveUndoExtSignature = []byte{'R', 'E', 'U', 'C'}
endOfIndexEntryExtSignature = []byte{'E', 'O', 'I', 'E'}
)
// Stage during merge
type Stage int
const (
// Merged is the default stage, fully merged
Merged Stage = 1
// AncestorMode is the base revision
AncestorMode Stage = 1
// OurMode is the first tree revision, ours
OurMode Stage = 2
// TheirMode is the second tree revision, theirs
TheirMode Stage = 3
)
// Index contains the information about which objects are currently checked out
// in the worktree, having information about the working files. Changes in
// worktree are detected using this Index. The Index is also used during merges
type Index struct {
// Version is index version
Version uint32
// Entries collection of entries represented by this Index. The order of
// this collection is not guaranteed
Entries []*Entry
// Cache represents the 'Cached tree' extension
Cache *Tree
// ResolveUndo represents the 'Resolve undo' extension
ResolveUndo *ResolveUndo
// EndOfIndexEntry represents the 'End of Index Entry' extension
EndOfIndexEntry *EndOfIndexEntry
}
// Add creates a new Entry and returns it. The caller should first check that
// another entry with the same path does not exist.
func (i *Index) Add(path string) *Entry {
e := &Entry{
Name: filepath.ToSlash(path),
}
i.Entries = append(i.Entries, e)
return e
}
// Entry returns the entry that match the given path, if any.
func (i *Index) Entry(path string) (*Entry, error) {
path = filepath.ToSlash(path)
for _, e := range i.Entries {
if e.Name == path {
return e, nil
}
}
return nil, ErrEntryNotFound
}
// Remove remove the entry that match the give path and returns deleted entry.
func (i *Index) Remove(path string) (*Entry, error) {
path = filepath.ToSlash(path)
for index, e := range i.Entries {
if e.Name == path {
i.Entries = append(i.Entries[:index], i.Entries[index+1:]...)
return e, nil
}
}
return nil, ErrEntryNotFound
}
// Glob returns the all entries matching pattern or nil if there is no matching
// entry. The syntax of patterns is the same as in filepath.Glob.
func (i *Index) Glob(pattern string) (matches []*Entry, err error) {
pattern = filepath.ToSlash(pattern)
for _, e := range i.Entries {
m, err := match(pattern, e.Name)
if err != nil {
return nil, err
}
if m {
matches = append(matches, e)
}
}
return
}
// String is equivalent to `git ls-files --stage --debug`
func (i *Index) String() string {
buf := bytes.NewBuffer(nil)
for _, e := range i.Entries {
buf.WriteString(e.String())
}
return buf.String()
}
// Entry represents a single file (or stage of a file) in the cache. An entry
// represents exactly one stage of a file. If a file path is unmerged then
// multiple Entry instances may appear for the same path name.
type Entry struct {
// Hash is the SHA1 of the represented file
Hash plumbing.Hash
// Name is the Entry path name relative to top level directory
Name string
// CreatedAt time when the tracked path was created
CreatedAt time.Time
// ModifiedAt time when the tracked path was changed
ModifiedAt time.Time
// Dev and Inode of the tracked path
Dev, Inode uint32
// Mode of the path
Mode filemode.FileMode
// UID and GID, userid and group id of the owner
UID, GID uint32
// Size is the length in bytes for regular files
Size uint32
// Stage on a merge is defines what stage is representing this entry
// https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging
Stage Stage
// SkipWorktree used in sparse checkouts
// https://git-scm.com/docs/git-read-tree#_sparse_checkout
SkipWorktree bool
// IntentToAdd record only the fact that the path will be added later
// https://git-scm.com/docs/git-add ("git add -N")
IntentToAdd bool
}
func (e Entry) String() string {
buf := bytes.NewBuffer(nil)
fmt.Fprintf(buf, "%06o %s %d\t%s\n", e.Mode, e.Hash, e.Stage, e.Name)
fmt.Fprintf(buf, " ctime: %d:%d\n", e.CreatedAt.Unix(), e.CreatedAt.Nanosecond())
fmt.Fprintf(buf, " mtime: %d:%d\n", e.ModifiedAt.Unix(), e.ModifiedAt.Nanosecond())
fmt.Fprintf(buf, " dev: %d\tino: %d\n", e.Dev, e.Inode)
fmt.Fprintf(buf, " uid: %d\tgid: %d\n", e.UID, e.GID)
fmt.Fprintf(buf, " size: %d\tflags: %x\n", e.Size, 0)
return buf.String()
}
// Tree contains pre-computed hashes for trees that can be derived from the
// index. It helps speed up tree object generation from index for a new commit.
type Tree struct {
Entries []TreeEntry
}
// TreeEntry entry of a cached Tree
type TreeEntry struct {
// Path component (relative to its parent directory)
Path string
// Entries is the number of entries in the index that is covered by the tree
// this entry represents.
Entries int
// Trees is the number that represents the number of subtrees this tree has
Trees int
// Hash object name for the object that would result from writing this span
// of index as a tree.
Hash plumbing.Hash
}
// ResolveUndo is used when a conflict is resolved (e.g. with "git add path"),
// these higher stage entries are removed and a stage-0 entry with proper
// resolution is added. When these higher stage entries are removed, they are
// saved in the resolve undo extension.
type ResolveUndo struct {
Entries []ResolveUndoEntry
}
// ResolveUndoEntry contains the information about a conflict when is resolved
type ResolveUndoEntry struct {
Path string
Stages map[Stage]plumbing.Hash
}
// EndOfIndexEntry is the End of Index Entry (EOIE) is used to locate the end of
// the variable length index entries and the beginning of the extensions. Code
// can take advantage of this to quickly locate the index extensions without
// having to parse through all of the index entries.
//
// Because it must be able to be loaded before the variable length cache
// entries and other index extensions, this extension must be written last.
type EndOfIndexEntry struct {
// Offset to the end of the index entries
Offset uint32
// Hash is a SHA-1 over the extension types and their sizes (but not
// their contents).
Hash plumbing.Hash
}
// SkipUnless applies patterns in the form of A, A/B, A/B/C
// to the index to prevent the files from being checked out
func (i *Index) SkipUnless(patterns []string) {
for _, e := range i.Entries {
var include bool
for _, pattern := range patterns {
if strings.HasPrefix(e.Name, pattern) {
include = true
break
}
}
if !include {
e.SkipWorktree = true
}
}
}
go-git-5.13.2/plumbing/format/index/index_test.go 0000664 0000000 0000000 00000002663 14744245500 0021715 0 ustar 00root root 0000000 0000000 package index
import (
"path/filepath"
. "gopkg.in/check.v1"
)
func (s *IndexSuite) TestIndexAdd(c *C) {
idx := &Index{}
e := idx.Add("foo")
e.Size = 42
e, err := idx.Entry("foo")
c.Assert(err, IsNil)
c.Assert(e.Name, Equals, "foo")
c.Assert(e.Size, Equals, uint32(42))
}
func (s *IndexSuite) TestIndexEntry(c *C) {
idx := &Index{
Entries: []*Entry{
{Name: "foo", Size: 42},
{Name: "bar", Size: 82},
},
}
e, err := idx.Entry("foo")
c.Assert(err, IsNil)
c.Assert(e.Name, Equals, "foo")
e, err = idx.Entry("missing")
c.Assert(e, IsNil)
c.Assert(err, Equals, ErrEntryNotFound)
}
func (s *IndexSuite) TestIndexRemove(c *C) {
idx := &Index{
Entries: []*Entry{
{Name: "foo", Size: 42},
{Name: "bar", Size: 82},
},
}
e, err := idx.Remove("foo")
c.Assert(err, IsNil)
c.Assert(e.Name, Equals, "foo")
e, err = idx.Remove("foo")
c.Assert(e, IsNil)
c.Assert(err, Equals, ErrEntryNotFound)
}
func (s *IndexSuite) TestIndexGlob(c *C) {
idx := &Index{
Entries: []*Entry{
{Name: "foo/bar/bar", Size: 42},
{Name: "foo/baz/qux", Size: 42},
{Name: "fux", Size: 82},
},
}
m, err := idx.Glob(filepath.Join("foo", "b*"))
c.Assert(err, IsNil)
c.Assert(m, HasLen, 2)
c.Assert(m[0].Name, Equals, "foo/bar/bar")
c.Assert(m[1].Name, Equals, "foo/baz/qux")
m, err = idx.Glob("f*")
c.Assert(err, IsNil)
c.Assert(m, HasLen, 3)
m, err = idx.Glob("f*/baz/q*")
c.Assert(err, IsNil)
c.Assert(m, HasLen, 1)
}
go-git-5.13.2/plumbing/format/index/match.go 0000664 0000000 0000000 00000007763 14744245500 0020651 0 ustar 00root root 0000000 0000000 package index
import (
"path/filepath"
"runtime"
"unicode/utf8"
)
// match is filepath.Match with support to match fullpath and not only filenames
// code from:
// https://github.com/golang/go/blob/39852bf4cce6927e01d0136c7843f65a801738cb/src/path/filepath/match.go#L44-L224
func match(pattern, name string) (matched bool, err error) {
Pattern:
for len(pattern) > 0 {
var star bool
var chunk string
star, chunk, pattern = scanChunk(pattern)
// Look for match at current position.
t, ok, err := matchChunk(chunk, name)
// if we're the last chunk, make sure we've exhausted the name
// otherwise we'll give a false result even if we could still match
// using the star
if ok && (len(t) == 0 || len(pattern) > 0) {
name = t
continue
}
if err != nil {
return false, err
}
if star {
// Look for match skipping i+1 bytes.
// Cannot skip /.
for i := 0; i < len(name); i++ {
t, ok, err := matchChunk(chunk, name[i+1:])
if ok {
// if we're the last chunk, make sure we exhausted the name
if len(pattern) == 0 && len(t) > 0 {
continue
}
name = t
continue Pattern
}
if err != nil {
return false, err
}
}
}
return false, nil
}
return len(name) == 0, nil
}
// scanChunk gets the next segment of pattern, which is a non-star string
// possibly preceded by a star.
func scanChunk(pattern string) (star bool, chunk, rest string) {
for len(pattern) > 0 && pattern[0] == '*' {
pattern = pattern[1:]
star = true
}
inrange := false
var i int
Scan:
for i = 0; i < len(pattern); i++ {
switch pattern[i] {
case '\\':
if runtime.GOOS != "windows" {
// error check handled in matchChunk: bad pattern.
if i+1 < len(pattern) {
i++
}
}
case '[':
inrange = true
case ']':
inrange = false
case '*':
if !inrange {
break Scan
}
}
}
return star, pattern[0:i], pattern[i:]
}
// matchChunk checks whether chunk matches the beginning of s.
// If so, it returns the remainder of s (after the match).
// Chunk is all single-character operators: literals, char classes, and ?.
func matchChunk(chunk, s string) (rest string, ok bool, err error) {
for len(chunk) > 0 {
if len(s) == 0 {
return
}
switch chunk[0] {
case '[':
// character class
r, n := utf8.DecodeRuneInString(s)
s = s[n:]
chunk = chunk[1:]
// We can't end right after '[', we're expecting at least
// a closing bracket and possibly a caret.
if len(chunk) == 0 {
err = filepath.ErrBadPattern
return
}
// possibly negated
negated := chunk[0] == '^'
if negated {
chunk = chunk[1:]
}
// parse all ranges
match := false
nrange := 0
for {
if len(chunk) > 0 && chunk[0] == ']' && nrange > 0 {
chunk = chunk[1:]
break
}
var lo, hi rune
if lo, chunk, err = getEsc(chunk); err != nil {
return
}
hi = lo
if chunk[0] == '-' {
if hi, chunk, err = getEsc(chunk[1:]); err != nil {
return
}
}
if lo <= r && r <= hi {
match = true
}
nrange++
}
if match == negated {
return
}
case '?':
_, n := utf8.DecodeRuneInString(s)
s = s[n:]
chunk = chunk[1:]
case '\\':
if runtime.GOOS != "windows" {
chunk = chunk[1:]
if len(chunk) == 0 {
err = filepath.ErrBadPattern
return
}
}
fallthrough
default:
if chunk[0] != s[0] {
return
}
s = s[1:]
chunk = chunk[1:]
}
}
return s, true, nil
}
// getEsc gets a possibly-escaped character from chunk, for a character class.
func getEsc(chunk string) (r rune, nchunk string, err error) {
if len(chunk) == 0 || chunk[0] == '-' || chunk[0] == ']' {
err = filepath.ErrBadPattern
return
}
if chunk[0] == '\\' && runtime.GOOS != "windows" {
chunk = chunk[1:]
if len(chunk) == 0 {
err = filepath.ErrBadPattern
return
}
}
r, n := utf8.DecodeRuneInString(chunk)
if r == utf8.RuneError && n == 1 {
err = filepath.ErrBadPattern
}
nchunk = chunk[n:]
if len(nchunk) == 0 {
err = filepath.ErrBadPattern
}
return
}
go-git-5.13.2/plumbing/format/objfile/ 0000775 0000000 0000000 00000000000 14744245500 0017514 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/format/objfile/common_test.go 0000664 0000000 0000000 00000007370 14744245500 0022401 0 ustar 00root root 0000000 0000000 package objfile
import (
"encoding/base64"
"testing"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
type objfileFixture struct {
hash string // hash of data
t plumbing.ObjectType // object type
content string // base64-encoded content
data string // base64-encoded objfile data
}
var objfileFixtures = []objfileFixture{
{
"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391",
plumbing.BlobObject,
base64.StdEncoding.EncodeToString([]byte("")),
"eAFLyslPUjBgAAAJsAHw",
},
{
"a8a940627d132695a9769df883f85992f0ff4a43",
plumbing.BlobObject,
base64.StdEncoding.EncodeToString([]byte("this is a test")),
"eAFLyslPUjA0YSjJyCxWAKJEhZLU4hIAUDYHOg==",
},
{
"4dc2174801ac4a3d36886210fd086fbe134cf7b2",
plumbing.BlobObject,
base64.StdEncoding.EncodeToString([]byte("this\nis\n\n\na\nmultiline\n\ntest.\n")),
"eAFLyslPUjCyZCjJyCzmAiIurkSu3NKcksyczLxULq6S1OISPS4A1I8LMQ==",
},
{
"13e6f47dd57798bfdc728d91f5c6d7f40c5bb5fc",
plumbing.BlobObject,
base64.StdEncoding.EncodeToString([]byte("this tests\r\nCRLF\r\nencoded files.\r\n")),
"eAFLyslPUjA2YSjJyCxWKEktLinm5XIO8nHj5UrNS85PSU1RSMvMSS3W4+UCABp3DNE=",
},
{
"72a7bc4667ab068e954172437b993d9fbaa137cb",
plumbing.BlobObject,
base64.StdEncoding.EncodeToString([]byte("test@example.com")),
"eAFLyslPUjA0YyhJLS5xSK1IzC3ISdVLzs8FAGVtCIA=",
},
{
"bb2b40e85ec0455d1de72daff71583f0dd72a33f",
plumbing.BlobObject,
base64.StdEncoding.EncodeToString([]byte("package main\r\n\r\nimport (\r\n\t\"fmt\"\r\n\t\"io\"\r\n\t\"os\"\r\n\r\n\t\"gopkg.in/src-d/go-git.v3\"\r\n)\r\n\r\nfunc main() {\r\n\tfmt.Printf(\"Retrieving %q ...\\n\", os.Args[2])\r\n\tr, err := git.NewRepository(os.Args[2], nil)\r\n\tif err != nil {\r\n\t\tpanic(err)\r\n\t}\r\n\r\n\tif err := r.Pull(\"origin\", \"refs/heads/master\"); err != nil {\r\n\t\tpanic(err)\r\n\t}\r\n\r\n\tdumpCommits(r)\r\n}\r\n\r\nfunc dumpCommits(r *git.Repository) {\r\n\titer := r.Commits()\r\n\tdefer iter.Close()\r\n\r\n\tfor {\r\n\t\tcommit, err := iter.Next()\r\n\t\tif err != nil {\r\n\t\t\tif err == io.EOF {\r\n\t\t\t\tbreak\r\n\t\t\t}\r\n\r\n\t\t\tpanic(err)\r\n\t\t}\r\n\r\n\t\tfmt.Println(commit)\r\n\t}\r\n}\r\n")),
"eAGNUU1LAzEU9JpC/0NcEFJps2ARQdmDFD3W0qt6SHez8dHdZH1JqyL+d/Oy/aDgQVh47LzJTGayatyKX99MzzpVrpXRvFVgh4PhANrOYeBiOGBZ3YaMJrg0nI+D/o3r1kaCzT2Wkyo3bmIgyO00rkfEqDe2TIJixL/jgagjFwg21CJb6oCgt2ANv3jnUsoXm4258/IejX++eo0CDMdcI/LbgpPuXH8sdec8BIdf4sgccwsN0aFO9POCgGTIOmWhFFGE9j/p1jtWFEW52DSNyByCAXLPUNc+f9Oq8nmrfNCYje7+o1lt2m7m2haCF2SVnFL6kw2/pBzHEH0rEH0oI8q9BF220nWEaSdnjfNaRDDCtcM+WZnsDgUl4lx/BuKxv6rYY0XBwcmHp8deh7EVarWmQ7uC2Glre/TweI0VvTk5xaTx+wWX66Gs",
},
{
"e94db0f9ffca44dc7bade6a3591f544183395a7c",
plumbing.TreeObject,
"MTAwNjQ0IFRlc3QgMS50eHQAqKlAYn0TJpWpdp34g/hZkvD/SkMxMDA2NDQgVGVzdCAyLnR4dABNwhdIAaxKPTaIYhD9CG++E0z3sjEwMDY0NCBUZXN0IDMudHh0ABPm9H3Vd5i/3HKNkfXG1/QMW7X8MTAwNjQ0IFRlc3QgNC50eHQAcqe8RmerBo6VQXJDe5k9n7qhN8sxMDA2NDQgVGVzdCA1LnR4dAC7K0DoXsBFXR3nLa/3FYPw3XKjPw==",
"eAErKUpNVTC0NGAwNDAwMzFRCEktLlEw1CupKGFYsdIhqVZYberKsrk/mn9ETvrw38sZWZURWJXvIXEPxjVetmYdSQJ/OfL3Cft834SsyhisSvjZl9qr5TP23ynqnfj12PUvPNFb/yCrMgGrKlq+xy19NVvfVMci5+qZtvN3LTQ/jazKFKxqt7bDi7gDrrGyz3XXfxdt/nC3aLE9AA2STmk=",
},
{
"9d7f8a56eaf92469dee8a856e716a03387ddb076",
plumbing.CommitObject,
"dHJlZSBlOTRkYjBmOWZmY2E0NGRjN2JhZGU2YTM1OTFmNTQ0MTgzMzk1YTdjCmF1dGhvciBKb3NodWEgU2pvZGluZyA8am9zaHVhLnNqb2RpbmdAc2NqYWxsaWFuY2UuY29tPiAxNDU2NTMxNTgzIC0wODAwCmNvbW1pdHRlciBKb3NodWEgU2pvZGluZyA8am9zaHVhLnNqb2RpbmdAc2NqYWxsaWFuY2UuY29tPiAxNDU2NTMxNTgzIC0wODAwCgpUZXN0IENvbW1pdAo=",
"eAGtjksOgjAUAF33FO8CktZ+aBNjTNy51Qs8Xl8FAjSh5f4SvILLmcVkKM/zUOEi3amuzMDBxE6mkBKhMZHaDiM71DaoZI1RXutgsSWBW+3zCs9c+g3hNeY4LB+4jgc35cf3QiNO04ALcUN5voEy1lmtrNdwll5Ksdt9oPIfUuLNpcLjCIov3ApFmQ==",
},
}
func Test(t *testing.T) { TestingT(t) }
go-git-5.13.2/plumbing/format/objfile/doc.go 0000664 0000000 0000000 00000000125 14744245500 0020606 0 ustar 00root root 0000000 0000000 // Package objfile implements encoding and decoding of object files.
package objfile
go-git-5.13.2/plumbing/format/objfile/reader.go 0000664 0000000 0000000 00000005555 14744245500 0021317 0 ustar 00root root 0000000 0000000 package objfile
import (
"errors"
"io"
"strconv"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/utils/sync"
)
var (
ErrClosed = errors.New("objfile: already closed")
ErrHeader = errors.New("objfile: invalid header")
ErrNegativeSize = errors.New("objfile: negative object size")
)
// Reader reads and decodes compressed objfile data from a provided io.Reader.
// Reader implements io.ReadCloser. Close should be called when finished with
// the Reader. Close will not close the underlying io.Reader.
type Reader struct {
multi io.Reader
zlib io.Reader
zlibref sync.ZLibReader
hasher plumbing.Hasher
}
// NewReader returns a new Reader reading from r.
func NewReader(r io.Reader) (*Reader, error) {
zlib, err := sync.GetZlibReader(r)
if err != nil {
return nil, packfile.ErrZLib.AddDetails(err.Error())
}
return &Reader{
zlib: zlib.Reader,
zlibref: zlib,
}, nil
}
// Header reads the type and the size of object, and prepares the reader for read
func (r *Reader) Header() (t plumbing.ObjectType, size int64, err error) {
var raw []byte
raw, err = r.readUntil(' ')
if err != nil {
return
}
t, err = plumbing.ParseObjectType(string(raw))
if err != nil {
return
}
raw, err = r.readUntil(0)
if err != nil {
return
}
size, err = strconv.ParseInt(string(raw), 10, 64)
if err != nil {
err = ErrHeader
return
}
defer r.prepareForRead(t, size)
return
}
// readSlice reads one byte at a time from r until it encounters delim or an
// error.
func (r *Reader) readUntil(delim byte) ([]byte, error) {
var buf [1]byte
value := make([]byte, 0, 16)
for {
if n, err := r.zlib.Read(buf[:]); err != nil && (err != io.EOF || n == 0) {
if err == io.EOF {
return nil, ErrHeader
}
return nil, err
}
if buf[0] == delim {
return value, nil
}
value = append(value, buf[0])
}
}
func (r *Reader) prepareForRead(t plumbing.ObjectType, size int64) {
r.hasher = plumbing.NewHasher(t, size)
r.multi = io.TeeReader(r.zlib, r.hasher)
}
// Read reads len(p) bytes into p from the object data stream. It returns
// the number of bytes read (0 <= n <= len(p)) and any error encountered. Even
// if Read returns n < len(p), it may use all of p as scratch space during the
// call.
//
// If Read encounters the end of the data stream it will return err == io.EOF,
// either in the current call if n > 0 or in a subsequent call.
func (r *Reader) Read(p []byte) (n int, err error) {
return r.multi.Read(p)
}
// Hash returns the hash of the object data stream that has been read so far.
func (r *Reader) Hash() plumbing.Hash {
return r.hasher.Sum()
}
// Close releases any resources consumed by the Reader. Calling Close does not
// close the wrapped io.Reader originally passed to NewReader.
func (r *Reader) Close() error {
sync.PutZlibReader(r.zlibref)
return nil
}
go-git-5.13.2/plumbing/format/objfile/reader_test.go 0000664 0000000 0000000 00000003256 14744245500 0022352 0 ustar 00root root 0000000 0000000 package objfile
import (
"bytes"
"encoding/base64"
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
type SuiteReader struct{}
var _ = Suite(&SuiteReader{})
func (s *SuiteReader) TestReadObjfile(c *C) {
for k, fixture := range objfileFixtures {
com := fmt.Sprintf("test %d: ", k)
hash := plumbing.NewHash(fixture.hash)
content, _ := base64.StdEncoding.DecodeString(fixture.content)
data, _ := base64.StdEncoding.DecodeString(fixture.data)
testReader(c, bytes.NewReader(data), hash, fixture.t, content, com)
}
}
func testReader(c *C, source io.Reader, hash plumbing.Hash, t plumbing.ObjectType, content []byte, com string) {
r, err := NewReader(source)
c.Assert(err, IsNil)
typ, size, err := r.Header()
c.Assert(err, IsNil)
c.Assert(typ, Equals, t)
c.Assert(content, HasLen, int(size))
rc, err := io.ReadAll(r)
c.Assert(err, IsNil)
c.Assert(rc, DeepEquals, content, Commentf("%scontent=%s, expected=%s", base64.StdEncoding.EncodeToString(rc), base64.StdEncoding.EncodeToString(content)))
c.Assert(r.Hash(), Equals, hash) // Test Hash() before close
c.Assert(r.Close(), IsNil)
}
func (s *SuiteReader) TestReadEmptyObjfile(c *C) {
source := bytes.NewReader([]byte{})
_, err := NewReader(source)
c.Assert(err, NotNil)
}
func (s *SuiteReader) TestReadGarbage(c *C) {
source := bytes.NewReader([]byte("!@#$RO!@NROSADfinq@o#irn@oirfn"))
_, err := NewReader(source)
c.Assert(err, NotNil)
}
func (s *SuiteReader) TestReadCorruptZLib(c *C) {
data, _ := base64.StdEncoding.DecodeString("eAFLysaalPUjBgAAAJsAHw")
source := bytes.NewReader(data)
r, err := NewReader(source)
c.Assert(err, IsNil)
_, _, err = r.Header()
c.Assert(err, NotNil)
}
go-git-5.13.2/plumbing/format/objfile/writer.go 0000664 0000000 0000000 00000005163 14744245500 0021364 0 ustar 00root root 0000000 0000000 package objfile
import (
"compress/zlib"
"errors"
"io"
"strconv"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/utils/sync"
)
var (
ErrOverflow = errors.New("objfile: declared data length exceeded (overflow)")
)
// Writer writes and encodes data in compressed objfile format to a provided
// io.Writer. Close should be called when finished with the Writer. Close will
// not close the underlying io.Writer.
type Writer struct {
raw io.Writer
hasher plumbing.Hasher
multi io.Writer
zlib *zlib.Writer
closed bool
pending int64 // number of unwritten bytes
}
// NewWriter returns a new Writer writing to w.
//
// The returned Writer implements io.WriteCloser. Close should be called when
// finished with the Writer. Close will not close the underlying io.Writer.
func NewWriter(w io.Writer) *Writer {
zlib := sync.GetZlibWriter(w)
return &Writer{
raw: w,
zlib: zlib,
}
}
// WriteHeader writes the type and the size and prepares to accept the object's
// contents. If an invalid t is provided, plumbing.ErrInvalidType is returned. If a
// negative size is provided, ErrNegativeSize is returned.
func (w *Writer) WriteHeader(t plumbing.ObjectType, size int64) error {
if !t.Valid() {
return plumbing.ErrInvalidType
}
if size < 0 {
return ErrNegativeSize
}
b := t.Bytes()
b = append(b, ' ')
b = append(b, []byte(strconv.FormatInt(size, 10))...)
b = append(b, 0)
defer w.prepareForWrite(t, size)
_, err := w.zlib.Write(b)
return err
}
func (w *Writer) prepareForWrite(t plumbing.ObjectType, size int64) {
w.pending = size
w.hasher = plumbing.NewHasher(t, size)
w.multi = io.MultiWriter(w.zlib, w.hasher)
}
// Write writes the object's contents. Write returns the error ErrOverflow if
// more than size bytes are written after WriteHeader.
func (w *Writer) Write(p []byte) (n int, err error) {
if w.closed {
return 0, ErrClosed
}
overwrite := false
if int64(len(p)) > w.pending {
p = p[0:w.pending]
overwrite = true
}
n, err = w.multi.Write(p)
w.pending -= int64(n)
if err == nil && overwrite {
err = ErrOverflow
return
}
return
}
// Hash returns the hash of the object data stream that has been written so far.
// It can be called before or after Close.
func (w *Writer) Hash() plumbing.Hash {
return w.hasher.Sum() // Not yet closed, return hash of data written so far
}
// Close releases any resources consumed by the Writer.
//
// Calling Close does not close the wrapped io.Writer originally passed to
// NewWriter.
func (w *Writer) Close() error {
defer sync.PutZlibWriter(w.zlib)
if err := w.zlib.Close(); err != nil {
return err
}
w.closed = true
return nil
}
go-git-5.13.2/plumbing/format/objfile/writer_test.go 0000664 0000000 0000000 00000003551 14744245500 0022422 0 ustar 00root root 0000000 0000000 package objfile
import (
"bytes"
"encoding/base64"
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
type SuiteWriter struct{}
var _ = Suite(&SuiteWriter{})
func (s *SuiteWriter) TestWriteObjfile(c *C) {
for k, fixture := range objfileFixtures {
buffer := bytes.NewBuffer(nil)
com := fmt.Sprintf("test %d: ", k)
hash := plumbing.NewHash(fixture.hash)
content, _ := base64.StdEncoding.DecodeString(fixture.content)
// Write the data out to the buffer
testWriter(c, buffer, hash, fixture.t, content)
// Read the data back in from the buffer to be sure it matches
testReader(c, buffer, hash, fixture.t, content, com)
}
}
func testWriter(c *C, dest io.Writer, hash plumbing.Hash, t plumbing.ObjectType, content []byte) {
size := int64(len(content))
w := NewWriter(dest)
err := w.WriteHeader(t, size)
c.Assert(err, IsNil)
written, err := io.Copy(w, bytes.NewReader(content))
c.Assert(err, IsNil)
c.Assert(written, Equals, size)
c.Assert(w.Hash(), Equals, hash)
c.Assert(w.Close(), IsNil)
}
func (s *SuiteWriter) TestWriteOverflow(c *C) {
buf := bytes.NewBuffer(nil)
w := NewWriter(buf)
err := w.WriteHeader(plumbing.BlobObject, 8)
c.Assert(err, IsNil)
n, err := w.Write([]byte("1234"))
c.Assert(err, IsNil)
c.Assert(n, Equals, 4)
n, err = w.Write([]byte("56789"))
c.Assert(err, Equals, ErrOverflow)
c.Assert(n, Equals, 4)
}
func (s *SuiteWriter) TestNewWriterInvalidType(c *C) {
buf := bytes.NewBuffer(nil)
w := NewWriter(buf)
err := w.WriteHeader(plumbing.InvalidObject, 8)
c.Assert(err, Equals, plumbing.ErrInvalidType)
}
func (s *SuiteWriter) TestNewWriterInvalidSize(c *C) {
buf := bytes.NewBuffer(nil)
w := NewWriter(buf)
err := w.WriteHeader(plumbing.BlobObject, -1)
c.Assert(err, Equals, ErrNegativeSize)
err = w.WriteHeader(plumbing.BlobObject, -1651860)
c.Assert(err, Equals, ErrNegativeSize)
}
go-git-5.13.2/plumbing/format/packfile/ 0000775 0000000 0000000 00000000000 14744245500 0017660 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/format/packfile/common.go 0000664 0000000 0000000 00000002626 14744245500 0021505 0 ustar 00root root 0000000 0000000 package packfile
import (
"io"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/utils/ioutil"
)
var signature = []byte{'P', 'A', 'C', 'K'}
const (
// VersionSupported is the packfile version supported by this package
VersionSupported uint32 = 2
firstLengthBits = uint8(4) // the first byte into object header has 4 bits to store the length
lengthBits = uint8(7) // subsequent bytes has 7 bits to store the length
maskFirstLength = 15 // 0000 1111
maskContinue = 0x80 // 1000 0000
maskLength = uint8(127) // 0111 1111
maskType = uint8(112) // 0111 0000
)
// UpdateObjectStorage updates the storer with the objects in the given
// packfile.
func UpdateObjectStorage(s storer.Storer, packfile io.Reader) error {
if pw, ok := s.(storer.PackfileWriter); ok {
return WritePackfileToObjectStorage(pw, packfile)
}
p, err := NewParserWithStorage(NewScanner(packfile), s)
if err != nil {
return err
}
_, err = p.Parse()
return err
}
// WritePackfileToObjectStorage writes all the packfile objects into the given
// object storage.
func WritePackfileToObjectStorage(
sw storer.PackfileWriter,
packfile io.Reader,
) (err error) {
w, err := sw.PackfileWriter()
if err != nil {
return err
}
defer ioutil.CheckClose(w, &err)
var n int64
n, err = io.Copy(w, packfile)
if err == nil && n == 0 {
return ErrEmptyPackfile
}
return err
}
go-git-5.13.2/plumbing/format/packfile/common_test.go 0000664 0000000 0000000 00000001541 14744245500 0022537 0 ustar 00root root 0000000 0000000 package packfile
import (
"bytes"
"testing"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type CommonSuite struct{}
var _ = Suite(&CommonSuite{})
func (s *CommonSuite) TestEmptyUpdateObjectStorage(c *C) {
var buf bytes.Buffer
sto := memory.NewStorage()
err := UpdateObjectStorage(sto, &buf)
c.Assert(err, Equals, ErrEmptyPackfile)
}
func newObject(t plumbing.ObjectType, cont []byte) plumbing.EncodedObject {
o := plumbing.MemoryObject{}
o.SetType(t)
o.SetSize(int64(len(cont)))
o.Write(cont)
return &o
}
type piece struct {
val string
times int
}
func genBytes(elements []piece) []byte {
var result []byte
for _, e := range elements {
for i := 0; i < e.times; i++ {
result = append(result, e.val...)
}
}
return result
}
go-git-5.13.2/plumbing/format/packfile/delta_index.go 0000664 0000000 0000000 00000023565 14744245500 0022502 0 ustar 00root root 0000000 0000000 package packfile
const blksz = 16
const maxChainLength = 64
// deltaIndex is a modified version of JGit's DeltaIndex adapted to our current
// design.
type deltaIndex struct {
table []int
entries []int
mask int
}
func (idx *deltaIndex) init(buf []byte) {
scanner := newDeltaIndexScanner(buf, len(buf))
idx.mask = scanner.mask
idx.table = scanner.table
idx.entries = make([]int, countEntries(scanner)+1)
idx.copyEntries(scanner)
}
// findMatch returns the offset of src where the block starting at tgtOffset
// is and the length of the match. A length of 0 means there was no match. A
// length of -1 means the src length is lower than the blksz and whatever
// other positive length is the length of the match in bytes.
func (idx *deltaIndex) findMatch(src, tgt []byte, tgtOffset int) (srcOffset, l int) {
if len(tgt) < tgtOffset+s {
return 0, len(tgt) - tgtOffset
}
if len(src) < blksz {
return 0, -1
}
h := hashBlock(tgt, tgtOffset)
tIdx := h & idx.mask
eIdx := idx.table[tIdx]
if eIdx == 0 {
return
}
srcOffset = idx.entries[eIdx]
l = matchLength(src, tgt, tgtOffset, srcOffset)
return
}
func matchLength(src, tgt []byte, otgt, osrc int) (l int) {
lensrc := len(src)
lentgt := len(tgt)
for (osrc < lensrc && otgt < lentgt) && src[osrc] == tgt[otgt] {
l++
osrc++
otgt++
}
return
}
func countEntries(scan *deltaIndexScanner) (cnt int) {
// Figure out exactly how many entries we need. As we do the
// enumeration truncate any delta chains longer than what we
// are willing to scan during encode. This keeps the encode
// logic linear in the size of the input rather than quadratic.
for i := 0; i < len(scan.table); i++ {
h := scan.table[i]
if h == 0 {
continue
}
size := 0
for {
size++
if size == maxChainLength {
scan.next[h] = 0
break
}
h = scan.next[h]
if h == 0 {
break
}
}
cnt += size
}
return
}
func (idx *deltaIndex) copyEntries(scanner *deltaIndexScanner) {
// Rebuild the entries list from the scanner, positioning all
// blocks in the same hash chain next to each other. We can
// then later discard the next list, along with the scanner.
//
next := 1
for i := 0; i < len(idx.table); i++ {
h := idx.table[i]
if h == 0 {
continue
}
idx.table[i] = next
for {
idx.entries[next] = scanner.entries[h]
next++
h = scanner.next[h]
if h == 0 {
break
}
}
}
}
type deltaIndexScanner struct {
table []int
entries []int
next []int
mask int
count int
}
func newDeltaIndexScanner(buf []byte, size int) *deltaIndexScanner {
size -= size % blksz
worstCaseBlockCnt := size / blksz
if worstCaseBlockCnt < 1 {
return new(deltaIndexScanner)
}
tableSize := tableSize(worstCaseBlockCnt)
scanner := &deltaIndexScanner{
table: make([]int, tableSize),
mask: tableSize - 1,
entries: make([]int, worstCaseBlockCnt+1),
next: make([]int, worstCaseBlockCnt+1),
}
scanner.scan(buf, size)
return scanner
}
// slightly modified version of JGit's DeltaIndexScanner. We store the offset on the entries
// instead of the entries and the key, so we avoid operations to retrieve the offset later, as
// we don't use the key.
// See: https://github.com/eclipse/jgit/blob/005e5feb4ecd08c4e4d141a38b9e7942accb3212/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/pack/DeltaIndexScanner.java
func (s *deltaIndexScanner) scan(buf []byte, end int) {
lastHash := 0
ptr := end - blksz
for {
key := hashBlock(buf, ptr)
tIdx := key & s.mask
head := s.table[tIdx]
if head != 0 && lastHash == key {
s.entries[head] = ptr
} else {
s.count++
eIdx := s.count
s.entries[eIdx] = ptr
s.next[eIdx] = head
s.table[tIdx] = eIdx
}
lastHash = key
ptr -= blksz
if 0 > ptr {
break
}
}
}
func tableSize(worstCaseBlockCnt int) int {
shift := 32 - leadingZeros(uint32(worstCaseBlockCnt))
sz := 1 << uint(shift-1)
if sz < worstCaseBlockCnt {
sz <<= 1
}
return sz
}
// use https://golang.org/pkg/math/bits/#LeadingZeros32 in the future
func leadingZeros(x uint32) (n int) {
if x >= 1<<16 {
x >>= 16
n = 16
}
if x >= 1<<8 {
x >>= 8
n += 8
}
n += int(len8tab[x])
return 32 - n
}
var len8tab = [256]uint8{
0x00, 0x01, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
}
func hashBlock(raw []byte, ptr int) int {
// The first 4 steps collapse out into a 4 byte big-endian decode,
// with a larger right shift as we combined shift lefts together.
//
hash := ((uint32(raw[ptr]) & 0xff) << 24) |
((uint32(raw[ptr+1]) & 0xff) << 16) |
((uint32(raw[ptr+2]) & 0xff) << 8) |
(uint32(raw[ptr+3]) & 0xff)
hash ^= T[hash>>31]
hash = ((hash << 8) | (uint32(raw[ptr+4]) & 0xff)) ^ T[hash>>23]
hash = ((hash << 8) | (uint32(raw[ptr+5]) & 0xff)) ^ T[hash>>23]
hash = ((hash << 8) | (uint32(raw[ptr+6]) & 0xff)) ^ T[hash>>23]
hash = ((hash << 8) | (uint32(raw[ptr+7]) & 0xff)) ^ T[hash>>23]
hash = ((hash << 8) | (uint32(raw[ptr+8]) & 0xff)) ^ T[hash>>23]
hash = ((hash << 8) | (uint32(raw[ptr+9]) & 0xff)) ^ T[hash>>23]
hash = ((hash << 8) | (uint32(raw[ptr+10]) & 0xff)) ^ T[hash>>23]
hash = ((hash << 8) | (uint32(raw[ptr+11]) & 0xff)) ^ T[hash>>23]
hash = ((hash << 8) | (uint32(raw[ptr+12]) & 0xff)) ^ T[hash>>23]
hash = ((hash << 8) | (uint32(raw[ptr+13]) & 0xff)) ^ T[hash>>23]
hash = ((hash << 8) | (uint32(raw[ptr+14]) & 0xff)) ^ T[hash>>23]
hash = ((hash << 8) | (uint32(raw[ptr+15]) & 0xff)) ^ T[hash>>23]
return int(hash)
}
var T = []uint32{0x00000000, 0xd4c6b32d, 0x7d4bd577,
0xa98d665a, 0x2e5119c3, 0xfa97aaee, 0x531accb4, 0x87dc7f99,
0x5ca23386, 0x886480ab, 0x21e9e6f1, 0xf52f55dc, 0x72f32a45,
0xa6359968, 0x0fb8ff32, 0xdb7e4c1f, 0x6d82d421, 0xb944670c,
0x10c90156, 0xc40fb27b, 0x43d3cde2, 0x97157ecf, 0x3e981895,
0xea5eabb8, 0x3120e7a7, 0xe5e6548a, 0x4c6b32d0, 0x98ad81fd,
0x1f71fe64, 0xcbb74d49, 0x623a2b13, 0xb6fc983e, 0x0fc31b6f,
0xdb05a842, 0x7288ce18, 0xa64e7d35, 0x219202ac, 0xf554b181,
0x5cd9d7db, 0x881f64f6, 0x536128e9, 0x87a79bc4, 0x2e2afd9e,
0xfaec4eb3, 0x7d30312a, 0xa9f68207, 0x007be45d, 0xd4bd5770,
0x6241cf4e, 0xb6877c63, 0x1f0a1a39, 0xcbcca914, 0x4c10d68d,
0x98d665a0, 0x315b03fa, 0xe59db0d7, 0x3ee3fcc8, 0xea254fe5,
0x43a829bf, 0x976e9a92, 0x10b2e50b, 0xc4745626, 0x6df9307c,
0xb93f8351, 0x1f8636de, 0xcb4085f3, 0x62cde3a9, 0xb60b5084,
0x31d72f1d, 0xe5119c30, 0x4c9cfa6a, 0x985a4947, 0x43240558,
0x97e2b675, 0x3e6fd02f, 0xeaa96302, 0x6d751c9b, 0xb9b3afb6,
0x103ec9ec, 0xc4f87ac1, 0x7204e2ff, 0xa6c251d2, 0x0f4f3788,
0xdb8984a5, 0x5c55fb3c, 0x88934811, 0x211e2e4b, 0xf5d89d66,
0x2ea6d179, 0xfa606254, 0x53ed040e, 0x872bb723, 0x00f7c8ba,
0xd4317b97, 0x7dbc1dcd, 0xa97aaee0, 0x10452db1, 0xc4839e9c,
0x6d0ef8c6, 0xb9c84beb, 0x3e143472, 0xead2875f, 0x435fe105,
0x97995228, 0x4ce71e37, 0x9821ad1a, 0x31accb40, 0xe56a786d,
0x62b607f4, 0xb670b4d9, 0x1ffdd283, 0xcb3b61ae, 0x7dc7f990,
0xa9014abd, 0x008c2ce7, 0xd44a9fca, 0x5396e053, 0x8750537e,
0x2edd3524, 0xfa1b8609, 0x2165ca16, 0xf5a3793b, 0x5c2e1f61,
0x88e8ac4c, 0x0f34d3d5, 0xdbf260f8, 0x727f06a2, 0xa6b9b58f,
0x3f0c6dbc, 0xebcade91, 0x4247b8cb, 0x96810be6, 0x115d747f,
0xc59bc752, 0x6c16a108, 0xb8d01225, 0x63ae5e3a, 0xb768ed17,
0x1ee58b4d, 0xca233860, 0x4dff47f9, 0x9939f4d4, 0x30b4928e,
0xe47221a3, 0x528eb99d, 0x86480ab0, 0x2fc56cea, 0xfb03dfc7,
0x7cdfa05e, 0xa8191373, 0x01947529, 0xd552c604, 0x0e2c8a1b,
0xdaea3936, 0x73675f6c, 0xa7a1ec41, 0x207d93d8, 0xf4bb20f5,
0x5d3646af, 0x89f0f582, 0x30cf76d3, 0xe409c5fe, 0x4d84a3a4,
0x99421089, 0x1e9e6f10, 0xca58dc3d, 0x63d5ba67, 0xb713094a,
0x6c6d4555, 0xb8abf678, 0x11269022, 0xc5e0230f, 0x423c5c96,
0x96faefbb, 0x3f7789e1, 0xebb13acc, 0x5d4da2f2, 0x898b11df,
0x20067785, 0xf4c0c4a8, 0x731cbb31, 0xa7da081c, 0x0e576e46,
0xda91dd6b, 0x01ef9174, 0xd5292259, 0x7ca44403, 0xa862f72e,
0x2fbe88b7, 0xfb783b9a, 0x52f55dc0, 0x8633eeed, 0x208a5b62,
0xf44ce84f, 0x5dc18e15, 0x89073d38, 0x0edb42a1, 0xda1df18c,
0x739097d6, 0xa75624fb, 0x7c2868e4, 0xa8eedbc9, 0x0163bd93,
0xd5a50ebe, 0x52797127, 0x86bfc20a, 0x2f32a450, 0xfbf4177d,
0x4d088f43, 0x99ce3c6e, 0x30435a34, 0xe485e919, 0x63599680,
0xb79f25ad, 0x1e1243f7, 0xcad4f0da, 0x11aabcc5, 0xc56c0fe8,
0x6ce169b2, 0xb827da9f, 0x3ffba506, 0xeb3d162b, 0x42b07071,
0x9676c35c, 0x2f49400d, 0xfb8ff320, 0x5202957a, 0x86c42657,
0x011859ce, 0xd5deeae3, 0x7c538cb9, 0xa8953f94, 0x73eb738b,
0xa72dc0a6, 0x0ea0a6fc, 0xda6615d1, 0x5dba6a48, 0x897cd965,
0x20f1bf3f, 0xf4370c12, 0x42cb942c, 0x960d2701, 0x3f80415b,
0xeb46f276, 0x6c9a8def, 0xb85c3ec2, 0x11d15898, 0xc517ebb5,
0x1e69a7aa, 0xcaaf1487, 0x632272dd, 0xb7e4c1f0, 0x3038be69,
0xe4fe0d44, 0x4d736b1e, 0x99b5d833,
}
go-git-5.13.2/plumbing/format/packfile/delta_selector.go 0000664 0000000 0000000 00000020671 14744245500 0023206 0 ustar 00root root 0000000 0000000 package packfile
import (
"sort"
"sync"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
)
const (
// deltas based on deltas, how many steps we can do.
// 50 is the default value used in JGit
maxDepth = int64(50)
)
// applyDelta is the set of object types that we should apply deltas
var applyDelta = map[plumbing.ObjectType]bool{
plumbing.BlobObject: true,
plumbing.TreeObject: true,
}
type deltaSelector struct {
storer storer.EncodedObjectStorer
}
func newDeltaSelector(s storer.EncodedObjectStorer) *deltaSelector {
return &deltaSelector{s}
}
// ObjectsToPack creates a list of ObjectToPack from the hashes
// provided, creating deltas if it's suitable, using an specific
// internal logic. `packWindow` specifies the size of the sliding
// window used to compare objects for delta compression; 0 turns off
// delta compression entirely.
func (dw *deltaSelector) ObjectsToPack(
hashes []plumbing.Hash,
packWindow uint,
) ([]*ObjectToPack, error) {
otp, err := dw.objectsToPack(hashes, packWindow)
if err != nil {
return nil, err
}
if packWindow == 0 {
return otp, nil
}
dw.sort(otp)
var objectGroups [][]*ObjectToPack
var prev *ObjectToPack
i := -1
for _, obj := range otp {
if prev == nil || prev.Type() != obj.Type() {
objectGroups = append(objectGroups, []*ObjectToPack{obj})
i++
prev = obj
} else {
objectGroups[i] = append(objectGroups[i], obj)
}
}
var wg sync.WaitGroup
var once sync.Once
for _, objs := range objectGroups {
objs := objs
wg.Add(1)
go func() {
if walkErr := dw.walk(objs, packWindow); walkErr != nil {
once.Do(func() {
err = walkErr
})
}
wg.Done()
}()
}
wg.Wait()
if err != nil {
return nil, err
}
return otp, nil
}
func (dw *deltaSelector) objectsToPack(
hashes []plumbing.Hash,
packWindow uint,
) ([]*ObjectToPack, error) {
var objectsToPack []*ObjectToPack
for _, h := range hashes {
var o plumbing.EncodedObject
var err error
if packWindow == 0 {
o, err = dw.encodedObject(h)
} else {
o, err = dw.encodedDeltaObject(h)
}
if err != nil {
return nil, err
}
otp := newObjectToPack(o)
if _, ok := o.(plumbing.DeltaObject); ok {
otp.CleanOriginal()
}
objectsToPack = append(objectsToPack, otp)
}
if packWindow == 0 {
return objectsToPack, nil
}
if err := dw.fixAndBreakChains(objectsToPack); err != nil {
return nil, err
}
return objectsToPack, nil
}
func (dw *deltaSelector) encodedDeltaObject(h plumbing.Hash) (plumbing.EncodedObject, error) {
edos, ok := dw.storer.(storer.DeltaObjectStorer)
if !ok {
return dw.encodedObject(h)
}
return edos.DeltaObject(plumbing.AnyObject, h)
}
func (dw *deltaSelector) encodedObject(h plumbing.Hash) (plumbing.EncodedObject, error) {
return dw.storer.EncodedObject(plumbing.AnyObject, h)
}
func (dw *deltaSelector) fixAndBreakChains(objectsToPack []*ObjectToPack) error {
m := make(map[plumbing.Hash]*ObjectToPack, len(objectsToPack))
for _, otp := range objectsToPack {
m[otp.Hash()] = otp
}
for _, otp := range objectsToPack {
if err := dw.fixAndBreakChainsOne(m, otp); err != nil {
return err
}
}
return nil
}
func (dw *deltaSelector) fixAndBreakChainsOne(objectsToPack map[plumbing.Hash]*ObjectToPack, otp *ObjectToPack) error {
if !otp.Object.Type().IsDelta() {
return nil
}
// Initial ObjectToPack instances might have a delta assigned to Object
// but no actual base initially. Once Base is assigned to a delta, it means
// we already fixed it.
if otp.Base != nil {
return nil
}
do, ok := otp.Object.(plumbing.DeltaObject)
if !ok {
// if this is not a DeltaObject, then we cannot retrieve its base,
// so we have to break the delta chain here.
return dw.undeltify(otp)
}
base, ok := objectsToPack[do.BaseHash()]
if !ok {
// The base of the delta is not in our list of objects to pack, so
// we break the chain.
return dw.undeltify(otp)
}
if err := dw.fixAndBreakChainsOne(objectsToPack, base); err != nil {
return err
}
otp.SetDelta(base, otp.Object)
return nil
}
func (dw *deltaSelector) restoreOriginal(otp *ObjectToPack) error {
if otp.Original != nil {
return nil
}
if !otp.Object.Type().IsDelta() {
return nil
}
obj, err := dw.encodedObject(otp.Hash())
if err != nil {
return err
}
otp.SetOriginal(obj)
return nil
}
// undeltify undeltifies an *ObjectToPack by retrieving the original object from
// the storer and resetting it.
func (dw *deltaSelector) undeltify(otp *ObjectToPack) error {
if err := dw.restoreOriginal(otp); err != nil {
return err
}
otp.Object = otp.Original
otp.Depth = 0
return nil
}
func (dw *deltaSelector) sort(objectsToPack []*ObjectToPack) {
sort.Sort(byTypeAndSize(objectsToPack))
}
func (dw *deltaSelector) walk(
objectsToPack []*ObjectToPack,
packWindow uint,
) error {
indexMap := make(map[plumbing.Hash]*deltaIndex)
for i := 0; i < len(objectsToPack); i++ {
// Clean up the index map and reconstructed delta objects for anything
// outside our pack window, to save memory.
if i > int(packWindow) {
obj := objectsToPack[i-int(packWindow)]
delete(indexMap, obj.Hash())
if obj.IsDelta() {
obj.SaveOriginalMetadata()
obj.CleanOriginal()
}
}
target := objectsToPack[i]
// If we already have a delta, we don't try to find a new one for this
// object. This happens when a delta is set to be reused from an existing
// packfile.
if target.IsDelta() {
continue
}
// We only want to create deltas from specific types.
if !applyDelta[target.Type()] {
continue
}
for j := i - 1; j >= 0 && i-j < int(packWindow); j-- {
base := objectsToPack[j]
// Objects must use only the same type as their delta base.
// Since objectsToPack is sorted by type and size, once we find
// a different type, we know we won't find more of them.
if base.Type() != target.Type() {
break
}
if err := dw.tryToDeltify(indexMap, base, target); err != nil {
return err
}
}
}
return nil
}
func (dw *deltaSelector) tryToDeltify(indexMap map[plumbing.Hash]*deltaIndex, base, target *ObjectToPack) error {
// Original object might not be present if we're reusing a delta, so we
// ensure it is restored.
if err := dw.restoreOriginal(target); err != nil {
return err
}
if err := dw.restoreOriginal(base); err != nil {
return err
}
// If the sizes are radically different, this is a bad pairing.
if target.Size() < base.Size()>>4 {
return nil
}
msz := dw.deltaSizeLimit(
target.Object.Size(),
base.Depth,
target.Depth,
target.IsDelta(),
)
// Nearly impossible to fit useful delta.
if msz <= 8 {
return nil
}
// If we have to insert a lot to make this work, find another.
if base.Size()-target.Size() > msz {
return nil
}
if _, ok := indexMap[base.Hash()]; !ok {
indexMap[base.Hash()] = new(deltaIndex)
}
// Now we can generate the delta using originals
delta, err := getDelta(indexMap[base.Hash()], base.Original, target.Original)
if err != nil {
return err
}
// if delta better than target
if delta.Size() < msz {
target.SetDelta(base, delta)
}
return nil
}
func (dw *deltaSelector) deltaSizeLimit(targetSize int64, baseDepth int,
targetDepth int, targetDelta bool) int64 {
if !targetDelta {
// Any delta should be no more than 50% of the original size
// (for text files deflate of whole form should shrink 50%).
n := targetSize >> 1
// Evenly distribute delta size limits over allowed depth.
// If src is non-delta (depth = 0), delta <= 50% of original.
// If src is almost at limit (9/10), delta <= 10% of original.
return n * (maxDepth - int64(baseDepth)) / maxDepth
}
// With a delta base chosen any new delta must be "better".
// Retain the distribution described above.
d := int64(targetDepth)
n := targetSize
// If target depth is bigger than maxDepth, this delta is not suitable to be used.
if d >= maxDepth {
return 0
}
// If src is whole (depth=0) and base is near limit (depth=9/10)
// any delta using src can be 10x larger and still be better.
//
// If src is near limit (depth=9/10) and base is whole (depth=0)
// a new delta dependent on src must be 1/10th the size.
return n * (maxDepth - int64(baseDepth)) / (maxDepth - d)
}
type byTypeAndSize []*ObjectToPack
func (a byTypeAndSize) Len() int { return len(a) }
func (a byTypeAndSize) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a byTypeAndSize) Less(i, j int) bool {
if a[i].Type() < a[j].Type() {
return false
}
if a[i].Type() > a[j].Type() {
return true
}
return a[i].Size() > a[j].Size()
}
go-git-5.13.2/plumbing/format/packfile/delta_selector_test.go 0000664 0000000 0000000 00000015023 14744245500 0024240 0 ustar 00root root 0000000 0000000 package packfile
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
type DeltaSelectorSuite struct {
ds *deltaSelector
store *memory.Storage
hashes map[string]plumbing.Hash
}
var _ = Suite(&DeltaSelectorSuite{})
func (s *DeltaSelectorSuite) SetUpTest(c *C) {
s.store = memory.NewStorage()
s.createTestObjects()
s.ds = newDeltaSelector(s.store)
}
func (s *DeltaSelectorSuite) TestSort(c *C) {
var o1 = newObjectToPack(newObject(plumbing.BlobObject, []byte("00000")))
var o4 = newObjectToPack(newObject(plumbing.BlobObject, []byte("0000")))
var o6 = newObjectToPack(newObject(plumbing.BlobObject, []byte("00")))
var o9 = newObjectToPack(newObject(plumbing.BlobObject, []byte("0")))
var o8 = newObjectToPack(newObject(plumbing.TreeObject, []byte("000")))
var o2 = newObjectToPack(newObject(plumbing.TreeObject, []byte("00")))
var o3 = newObjectToPack(newObject(plumbing.TreeObject, []byte("0")))
var o5 = newObjectToPack(newObject(plumbing.CommitObject, []byte("0000")))
var o7 = newObjectToPack(newObject(plumbing.CommitObject, []byte("00")))
toSort := []*ObjectToPack{o1, o2, o3, o4, o5, o6, o7, o8, o9}
s.ds.sort(toSort)
expected := []*ObjectToPack{o1, o4, o6, o9, o8, o2, o3, o5, o7}
c.Assert(toSort, DeepEquals, expected)
}
type testObject struct {
id string
object plumbing.EncodedObject
}
var testObjects []*testObject = []*testObject{{
id: "base",
object: newObject(plumbing.BlobObject,
genBytes([]piece{{
times: 1000,
val: "a",
}, {
times: 1000,
val: "b",
}})),
}, {
id: "smallBase",
object: newObject(plumbing.BlobObject,
genBytes([]piece{{
times: 1,
val: "a",
}, {
times: 1,
val: "b",
}, {
times: 6,
val: "c",
}})),
}, {
id: "smallTarget",
object: newObject(plumbing.BlobObject,
genBytes([]piece{{
times: 1,
val: "a",
}, {
times: 1,
val: "c",
}})),
}, {
id: "target",
object: newObject(plumbing.BlobObject,
genBytes([]piece{{
times: 1000,
val: "a",
}, {
times: 1000,
val: "b",
}, {
times: 1000,
val: "c",
}})),
}, {
id: "o1",
object: newObject(plumbing.BlobObject,
genBytes([]piece{{
times: 1000,
val: "a",
}, {
times: 1000,
val: "b",
}})),
}, {
id: "o2",
object: newObject(plumbing.BlobObject,
genBytes([]piece{{
times: 1000,
val: "a",
}, {
times: 500,
val: "b",
}})),
}, {
id: "o3",
object: newObject(plumbing.BlobObject,
genBytes([]piece{{
times: 1000,
val: "a",
}, {
times: 499,
val: "b",
}})),
}, {
id: "bigBase",
object: newObject(plumbing.BlobObject,
genBytes([]piece{{
times: 1000000,
val: "a",
}})),
}, {
id: "treeType",
object: newObject(plumbing.TreeObject,
[]byte("I am a tree!")),
}}
func (s *DeltaSelectorSuite) createTestObjects() {
s.hashes = make(map[string]plumbing.Hash)
for _, o := range testObjects {
h, err := s.store.SetEncodedObject(o.object)
if err != nil {
panic(err)
}
s.hashes[o.id] = h
}
}
func (s *DeltaSelectorSuite) TestObjectsToPack(c *C) {
// Different type
hashes := []plumbing.Hash{s.hashes["base"], s.hashes["treeType"]}
deltaWindowSize := uint(10)
otp, err := s.ds.ObjectsToPack(hashes, deltaWindowSize)
c.Assert(err, IsNil)
c.Assert(len(otp), Equals, 2)
c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["base"]])
c.Assert(otp[1].Object, Equals, s.store.Objects[s.hashes["treeType"]])
// Size radically different
hashes = []plumbing.Hash{s.hashes["bigBase"], s.hashes["target"]}
otp, err = s.ds.ObjectsToPack(hashes, deltaWindowSize)
c.Assert(err, IsNil)
c.Assert(len(otp), Equals, 2)
c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["bigBase"]])
c.Assert(otp[1].Object, Equals, s.store.Objects[s.hashes["target"]])
// Delta Size Limit with no best delta yet
hashes = []plumbing.Hash{s.hashes["smallBase"], s.hashes["smallTarget"]}
otp, err = s.ds.ObjectsToPack(hashes, deltaWindowSize)
c.Assert(err, IsNil)
c.Assert(len(otp), Equals, 2)
c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["smallBase"]])
c.Assert(otp[1].Object, Equals, s.store.Objects[s.hashes["smallTarget"]])
// It will create the delta
hashes = []plumbing.Hash{s.hashes["base"], s.hashes["target"]}
otp, err = s.ds.ObjectsToPack(hashes, deltaWindowSize)
c.Assert(err, IsNil)
c.Assert(len(otp), Equals, 2)
c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["target"]])
c.Assert(otp[0].IsDelta(), Equals, false)
c.Assert(otp[1].Original, Equals, s.store.Objects[s.hashes["base"]])
c.Assert(otp[1].IsDelta(), Equals, true)
c.Assert(otp[1].Depth, Equals, 1)
// If our base is another delta, the depth will increase by one
hashes = []plumbing.Hash{
s.hashes["o1"],
s.hashes["o2"],
s.hashes["o3"],
}
otp, err = s.ds.ObjectsToPack(hashes, deltaWindowSize)
c.Assert(err, IsNil)
c.Assert(len(otp), Equals, 3)
c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["o1"]])
c.Assert(otp[0].IsDelta(), Equals, false)
c.Assert(otp[1].Original, Equals, s.store.Objects[s.hashes["o2"]])
c.Assert(otp[1].IsDelta(), Equals, true)
c.Assert(otp[1].Depth, Equals, 1)
c.Assert(otp[2].Original, Equals, s.store.Objects[s.hashes["o3"]])
c.Assert(otp[2].IsDelta(), Equals, true)
c.Assert(otp[2].Depth, Equals, 2)
// Check that objects outside of the sliding window don't produce
// a delta.
hashes = make([]plumbing.Hash, 0, deltaWindowSize+2)
hashes = append(hashes, s.hashes["base"])
for i := uint(0); i < deltaWindowSize; i++ {
hashes = append(hashes, s.hashes["smallTarget"])
}
hashes = append(hashes, s.hashes["target"])
// Don't sort so we can easily check the sliding window without
// creating a bunch of new objects.
otp, err = s.ds.objectsToPack(hashes, deltaWindowSize)
c.Assert(err, IsNil)
err = s.ds.walk(otp, deltaWindowSize)
c.Assert(err, IsNil)
c.Assert(len(otp), Equals, int(deltaWindowSize)+2)
targetIdx := len(otp) - 1
c.Assert(otp[targetIdx].IsDelta(), Equals, false)
// Check that no deltas are created, and the objects are unsorted,
// if compression is off.
hashes = []plumbing.Hash{s.hashes["base"], s.hashes["target"]}
otp, err = s.ds.ObjectsToPack(hashes, 0)
c.Assert(err, IsNil)
c.Assert(len(otp), Equals, 2)
c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["base"]])
c.Assert(otp[0].IsDelta(), Equals, false)
c.Assert(otp[1].Original, Equals, s.store.Objects[s.hashes["target"]])
c.Assert(otp[1].IsDelta(), Equals, false)
c.Assert(otp[1].Depth, Equals, 0)
}
func (s *DeltaSelectorSuite) TestMaxDepth(c *C) {
dsl := s.ds.deltaSizeLimit(0, 0, int(maxDepth), true)
c.Assert(dsl, Equals, int64(0))
}
go-git-5.13.2/plumbing/format/packfile/delta_test.go 0000664 0000000 0000000 00000011307 14744245500 0022341 0 ustar 00root root 0000000 0000000 package packfile
import (
"bytes"
"io"
"math/rand"
"testing"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
type DeltaSuite struct {
testCases []deltaTest
}
var _ = Suite(&DeltaSuite{})
type deltaTest struct {
description string
base []piece
target []piece
}
func (s *DeltaSuite) SetUpSuite(c *C) {
s.testCases = []deltaTest{{
description: "distinct file",
base: []piece{{"0", 300}},
target: []piece{{"2", 200}},
}, {
description: "same file",
base: []piece{{"1", 3000}},
target: []piece{{"1", 3000}},
}, {
description: "small file",
base: []piece{{"1", 3}},
target: []piece{{"1", 3}, {"0", 1}},
}, {
description: "big file",
base: []piece{{"1", 300000}},
target: []piece{{"1", 30000}, {"0", 1000000}},
}, {
description: "add elements before",
base: []piece{{"0", 200}},
target: []piece{{"1", 300}, {"0", 200}},
}, {
description: "add 10 times more elements at the end",
base: []piece{{"1", 300}, {"0", 200}},
target: []piece{{"0", 2000}},
}, {
description: "add elements between",
base: []piece{{"0", 400}},
target: []piece{{"0", 200}, {"1", 200}, {"0", 200}},
}, {
description: "add elements after",
base: []piece{{"0", 200}},
target: []piece{{"0", 200}, {"1", 200}},
}, {
description: "modify elements at the end",
base: []piece{{"1", 300}, {"0", 200}},
target: []piece{{"0", 100}},
}, {
description: "complex modification",
base: []piece{{"0", 3}, {"1", 40}, {"2", 30}, {"3", 2},
{"4", 400}, {"5", 23}},
target: []piece{{"1", 30}, {"2", 20}, {"7", 40}, {"4", 400},
{"5", 10}},
}, {
description: "A copy operation bigger than 64kb",
base: []piece{{bigRandStr, 1}, {"1", 200}},
target: []piece{{bigRandStr, 1}},
}}
}
var bigRandStr = randStringBytes(100 * 1024)
const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
func randBytes(n int) []byte {
b := make([]byte, n)
for i := range b {
b[i] = letterBytes[rand.Intn(len(letterBytes))]
}
return b
}
func randStringBytes(n int) string {
return string(randBytes(n))
}
func (s *DeltaSuite) TestAddDelta(c *C) {
for _, t := range s.testCases {
baseBuf := genBytes(t.base)
targetBuf := genBytes(t.target)
delta := DiffDelta(baseBuf, targetBuf)
result, err := PatchDelta(baseBuf, delta)
c.Log("Executing test case:", t.description)
c.Assert(err, IsNil)
c.Assert(result, DeepEquals, targetBuf)
}
}
func (s *DeltaSuite) TestAddDeltaReader(c *C) {
for _, t := range s.testCases {
baseBuf := genBytes(t.base)
baseObj := &plumbing.MemoryObject{}
baseObj.Write(baseBuf)
targetBuf := genBytes(t.target)
delta := DiffDelta(baseBuf, targetBuf)
deltaRC := io.NopCloser(bytes.NewReader(delta))
c.Log("Executing test case:", t.description)
resultRC, err := ReaderFromDelta(baseObj, deltaRC)
c.Assert(err, IsNil)
result, err := io.ReadAll(resultRC)
c.Assert(err, IsNil)
err = resultRC.Close()
c.Assert(err, IsNil)
c.Assert(result, DeepEquals, targetBuf)
}
}
func (s *DeltaSuite) TestIncompleteDelta(c *C) {
for _, t := range s.testCases {
c.Log("Incomplete delta on:", t.description)
baseBuf := genBytes(t.base)
targetBuf := genBytes(t.target)
delta := DiffDelta(baseBuf, targetBuf)
delta = delta[:len(delta)-2]
result, err := PatchDelta(baseBuf, delta)
c.Assert(err, NotNil)
c.Assert(result, IsNil)
}
// check nil input too
result, err := PatchDelta(nil, nil)
c.Assert(err, NotNil)
c.Assert(result, IsNil)
}
func (s *DeltaSuite) TestMaxCopySizeDelta(c *C) {
baseBuf := randBytes(maxCopySize)
targetBuf := baseBuf[0:]
targetBuf = append(targetBuf, byte(1))
delta := DiffDelta(baseBuf, targetBuf)
result, err := PatchDelta(baseBuf, delta)
c.Assert(err, IsNil)
c.Assert(result, DeepEquals, targetBuf)
}
func (s *DeltaSuite) TestMaxCopySizeDeltaReader(c *C) {
baseBuf := randBytes(maxCopySize)
baseObj := &plumbing.MemoryObject{}
baseObj.Write(baseBuf)
targetBuf := baseBuf[0:]
targetBuf = append(targetBuf, byte(1))
delta := DiffDelta(baseBuf, targetBuf)
deltaRC := io.NopCloser(bytes.NewReader(delta))
resultRC, err := ReaderFromDelta(baseObj, deltaRC)
c.Assert(err, IsNil)
result, err := io.ReadAll(resultRC)
c.Assert(err, IsNil)
err = resultRC.Close()
c.Assert(err, IsNil)
c.Assert(result, DeepEquals, targetBuf)
}
func FuzzPatchDelta(f *testing.F) {
f.Add([]byte("some value"), []byte("\n\f\fsomenewvalue"))
f.Add([]byte("some value"), []byte("\n\x0e\x0evalue"))
f.Add([]byte("some value"), []byte("\n\x0e\x0eva"))
f.Add([]byte("some value"), []byte("\n\x80\x80\x80\x80\x80\x802\x7fvalue"))
f.Fuzz(func(t *testing.T, input1, input2 []byte) {
PatchDelta(input1, input2)
})
}
go-git-5.13.2/plumbing/format/packfile/diff_delta.go 0000664 0000000 0000000 00000010433 14744245500 0022271 0 ustar 00root root 0000000 0000000 package packfile
import (
"bytes"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-git/v5/utils/sync"
)
// See https://github.com/jelmer/dulwich/blob/master/dulwich/pack.py and
// https://github.com/tarruda/node-git-core/blob/master/src/js/delta.js
// for more info
const (
// Standard chunk size used to generate fingerprints
s = 16
// https://github.com/git/git/blob/f7466e94375b3be27f229c78873f0acf8301c0a5/diff-delta.c#L428
// Max size of a copy operation (64KB).
maxCopySize = 64 * 1024
// Min size of a copy operation.
minCopySize = 4
)
// GetDelta returns an EncodedObject of type OFSDeltaObject. Base and Target object,
// will be loaded into memory to be able to create the delta object.
// To generate target again, you will need the obtained object and "base" one.
// Error will be returned if base or target object cannot be read.
func GetDelta(base, target plumbing.EncodedObject) (plumbing.EncodedObject, error) {
return getDelta(new(deltaIndex), base, target)
}
func getDelta(index *deltaIndex, base, target plumbing.EncodedObject) (o plumbing.EncodedObject, err error) {
br, err := base.Reader()
if err != nil {
return nil, err
}
defer ioutil.CheckClose(br, &err)
tr, err := target.Reader()
if err != nil {
return nil, err
}
defer ioutil.CheckClose(tr, &err)
bb := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(bb)
_, err = bb.ReadFrom(br)
if err != nil {
return nil, err
}
tb := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(tb)
_, err = tb.ReadFrom(tr)
if err != nil {
return nil, err
}
db := diffDelta(index, bb.Bytes(), tb.Bytes())
delta := &plumbing.MemoryObject{}
_, err = delta.Write(db)
if err != nil {
return nil, err
}
delta.SetSize(int64(len(db)))
delta.SetType(plumbing.OFSDeltaObject)
return delta, nil
}
// DiffDelta returns the delta that transforms src into tgt.
func DiffDelta(src, tgt []byte) []byte {
return diffDelta(new(deltaIndex), src, tgt)
}
func diffDelta(index *deltaIndex, src []byte, tgt []byte) []byte {
buf := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(buf)
buf.Write(deltaEncodeSize(len(src)))
buf.Write(deltaEncodeSize(len(tgt)))
if len(index.entries) == 0 {
index.init(src)
}
ibuf := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(ibuf)
for i := 0; i < len(tgt); i++ {
offset, l := index.findMatch(src, tgt, i)
if l == 0 {
// couldn't find a match, just write the current byte and continue
ibuf.WriteByte(tgt[i])
} else if l < 0 {
// src is less than blksz, copy the rest of the target to avoid
// calls to findMatch
for ; i < len(tgt); i++ {
ibuf.WriteByte(tgt[i])
}
} else if l < s {
// remaining target is less than blksz, copy what's left of it
// and avoid calls to findMatch
for j := i; j < i+l; j++ {
ibuf.WriteByte(tgt[j])
}
i += l - 1
} else {
encodeInsertOperation(ibuf, buf)
rl := l
aOffset := offset
for rl > 0 {
if rl < maxCopySize {
buf.Write(encodeCopyOperation(aOffset, rl))
break
}
buf.Write(encodeCopyOperation(aOffset, maxCopySize))
rl -= maxCopySize
aOffset += maxCopySize
}
i += l - 1
}
}
encodeInsertOperation(ibuf, buf)
// buf.Bytes() is only valid until the next modifying operation on the buffer. Copy it.
return append([]byte{}, buf.Bytes()...)
}
func encodeInsertOperation(ibuf, buf *bytes.Buffer) {
if ibuf.Len() == 0 {
return
}
b := ibuf.Bytes()
s := ibuf.Len()
o := 0
for {
if s <= 127 {
break
}
buf.WriteByte(byte(127))
buf.Write(b[o : o+127])
s -= 127
o += 127
}
buf.WriteByte(byte(s))
buf.Write(b[o : o+s])
ibuf.Reset()
}
func deltaEncodeSize(size int) []byte {
var ret []byte
c := size & 0x7f
size >>= 7
for {
if size == 0 {
break
}
ret = append(ret, byte(c|0x80))
c = size & 0x7f
size >>= 7
}
ret = append(ret, byte(c))
return ret
}
func encodeCopyOperation(offset, length int) []byte {
code := 0x80
var opcodes []byte
var i uint
for i = 0; i < 4; i++ {
f := 0xff << (i * 8)
if offset&f != 0 {
opcodes = append(opcodes, byte(offset&f>>(i*8)))
code |= 0x01 << i
}
}
for i = 0; i < 3; i++ {
f := 0xff << (i * 8)
if length&f != 0 {
opcodes = append(opcodes, byte(length&f>>(i*8)))
code |= 0x10 << i
}
}
return append([]byte{byte(code)}, opcodes...)
}
go-git-5.13.2/plumbing/format/packfile/doc.go 0000664 0000000 0000000 00000002515 14744245500 0020757 0 ustar 00root root 0000000 0000000 // Package packfile implements encoding and decoding of packfile format.
//
// == pack-*.pack files have the following format:
//
// - A header appears at the beginning and consists of the following:
//
// 4-byte signature:
// The signature is: {'P', 'A', 'C', 'K'}
//
// 4-byte version number (network byte order):
// GIT currently accepts version number 2 or 3 but
// generates version 2 only.
//
// 4-byte number of objects contained in the pack (network byte order)
//
// Observation: we cannot have more than 4G versions ;-) and
// more than 4G objects in a pack.
//
// - The header is followed by number of object entries, each of
// which looks like this:
//
// (undeltified representation)
// n-byte type and length (3-bit type, (n-1)*7+4-bit length)
// compressed data
//
// (deltified representation)
// n-byte type and length (3-bit type, (n-1)*7+4-bit length)
// 20-byte base object name
// compressed delta data
//
// Observation: length of each object is encoded in a variable
// length format and is not constrained to 32-bit or anything.
//
// - The trailer records 20-byte SHA1 checksum of all of the above.
//
//
// Source:
// https://www.kernel.org/pub/software/scm/git/docs/v1.7.5/technical/pack-protocol.txt
package packfile
go-git-5.13.2/plumbing/format/packfile/encoder.go 0000664 0000000 0000000 00000011661 14744245500 0021633 0 ustar 00root root 0000000 0000000 package packfile
import (
"compress/zlib"
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/utils/binary"
"github.com/go-git/go-git/v5/utils/ioutil"
)
// Encoder gets the data from the storage and write it into the writer in PACK
// format
type Encoder struct {
selector *deltaSelector
w *offsetWriter
zw *zlib.Writer
hasher plumbing.Hasher
useRefDeltas bool
}
// NewEncoder creates a new packfile encoder using a specific Writer and
// EncodedObjectStorer. By default deltas used to generate the packfile will be
// OFSDeltaObject. To use Reference deltas, set useRefDeltas to true.
func NewEncoder(w io.Writer, s storer.EncodedObjectStorer, useRefDeltas bool) *Encoder {
h := plumbing.Hasher{
Hash: hash.New(hash.CryptoType),
}
mw := io.MultiWriter(w, h)
ow := newOffsetWriter(mw)
zw := zlib.NewWriter(mw)
return &Encoder{
selector: newDeltaSelector(s),
w: ow,
zw: zw,
hasher: h,
useRefDeltas: useRefDeltas,
}
}
// Encode creates a packfile containing all the objects referenced in
// hashes and writes it to the writer in the Encoder. `packWindow`
// specifies the size of the sliding window used to compare objects
// for delta compression; 0 turns off delta compression entirely.
func (e *Encoder) Encode(
hashes []plumbing.Hash,
packWindow uint,
) (plumbing.Hash, error) {
objects, err := e.selector.ObjectsToPack(hashes, packWindow)
if err != nil {
return plumbing.ZeroHash, err
}
return e.encode(objects)
}
func (e *Encoder) encode(objects []*ObjectToPack) (plumbing.Hash, error) {
if err := e.head(len(objects)); err != nil {
return plumbing.ZeroHash, err
}
for _, o := range objects {
if err := e.entry(o); err != nil {
return plumbing.ZeroHash, err
}
}
return e.footer()
}
func (e *Encoder) head(numEntries int) error {
return binary.Write(
e.w,
signature,
int32(VersionSupported),
int32(numEntries),
)
}
func (e *Encoder) entry(o *ObjectToPack) (err error) {
if o.WantWrite() {
// A cycle exists in this delta chain. This should only occur if a
// selected object representation disappeared during writing
// (for example due to a concurrent repack) and a different base
// was chosen, forcing a cycle. Select something other than a
// delta, and write this object.
e.selector.restoreOriginal(o)
o.BackToOriginal()
}
if o.IsWritten() {
return nil
}
o.MarkWantWrite()
if err := e.writeBaseIfDelta(o); err != nil {
return err
}
// We need to check if we already write that object due a cyclic delta chain
if o.IsWritten() {
return nil
}
o.Offset = e.w.Offset()
if o.IsDelta() {
if err := e.writeDeltaHeader(o); err != nil {
return err
}
} else {
if err := e.entryHead(o.Type(), o.Size()); err != nil {
return err
}
}
e.zw.Reset(e.w)
defer ioutil.CheckClose(e.zw, &err)
or, err := o.Object.Reader()
if err != nil {
return err
}
defer ioutil.CheckClose(or, &err)
_, err = io.Copy(e.zw, or)
return err
}
func (e *Encoder) writeBaseIfDelta(o *ObjectToPack) error {
if o.IsDelta() && !o.Base.IsWritten() {
// We must write base first
return e.entry(o.Base)
}
return nil
}
func (e *Encoder) writeDeltaHeader(o *ObjectToPack) error {
// Write offset deltas by default
t := plumbing.OFSDeltaObject
if e.useRefDeltas {
t = plumbing.REFDeltaObject
}
if err := e.entryHead(t, o.Object.Size()); err != nil {
return err
}
if e.useRefDeltas {
return e.writeRefDeltaHeader(o.Base.Hash())
} else {
return e.writeOfsDeltaHeader(o)
}
}
func (e *Encoder) writeRefDeltaHeader(base plumbing.Hash) error {
return binary.Write(e.w, base)
}
func (e *Encoder) writeOfsDeltaHeader(o *ObjectToPack) error {
// for OFS_DELTA, offset of the base is interpreted as negative offset
// relative to the type-byte of the header of the ofs-delta entry.
relativeOffset := o.Offset - o.Base.Offset
if relativeOffset <= 0 {
return fmt.Errorf("bad offset for OFS_DELTA entry: %d", relativeOffset)
}
return binary.WriteVariableWidthInt(e.w, relativeOffset)
}
func (e *Encoder) entryHead(typeNum plumbing.ObjectType, size int64) error {
t := int64(typeNum)
header := []byte{}
c := (t << firstLengthBits) | (size & maskFirstLength)
size >>= firstLengthBits
for {
if size == 0 {
break
}
header = append(header, byte(c|maskContinue))
c = size & int64(maskLength)
size >>= lengthBits
}
header = append(header, byte(c))
_, err := e.w.Write(header)
return err
}
func (e *Encoder) footer() (plumbing.Hash, error) {
h := e.hasher.Sum()
return h, binary.Write(e.w, h)
}
type offsetWriter struct {
w io.Writer
offset int64
}
func newOffsetWriter(w io.Writer) *offsetWriter {
return &offsetWriter{w: w}
}
func (ow *offsetWriter) Write(p []byte) (n int, err error) {
n, err = ow.w.Write(p)
ow.offset += int64(n)
return n, err
}
func (ow *offsetWriter) Offset() int64 {
return ow.offset
}
go-git-5.13.2/plumbing/format/packfile/encoder_advanced_test.go 0000664 0000000 0000000 00000006532 14744245500 0024520 0 ustar 00root root 0000000 0000000 package packfile_test
import (
"bytes"
"io"
"math/rand"
"testing"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/format/idxfile"
. "github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-billy/v5/memfs"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type EncoderAdvancedSuite struct {
fixtures.Suite
}
var _ = Suite(&EncoderAdvancedSuite{})
func (s *EncoderAdvancedSuite) TestEncodeDecode(c *C) {
if testing.Short() {
c.Skip("skipping test in short mode.")
}
fixs := fixtures.Basic().ByTag("packfile").ByTag(".git")
fixs = append(fixs, fixtures.ByURL("https://github.com/src-d/go-git.git").
ByTag("packfile").ByTag(".git").One())
fixs.Test(c, func(f *fixtures.Fixture) {
storage := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
s.testEncodeDecode(c, storage, 10)
})
}
func (s *EncoderAdvancedSuite) TestEncodeDecodeNoDeltaCompression(c *C) {
if testing.Short() {
c.Skip("skipping test in short mode.")
}
fixs := fixtures.Basic().ByTag("packfile").ByTag(".git")
fixs = append(fixs, fixtures.ByURL("https://github.com/src-d/go-git.git").
ByTag("packfile").ByTag(".git").One())
fixs.Test(c, func(f *fixtures.Fixture) {
storage := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
s.testEncodeDecode(c, storage, 0)
})
}
func (s *EncoderAdvancedSuite) testEncodeDecode(
c *C,
storage storer.Storer,
packWindow uint,
) {
objIter, err := storage.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
expectedObjects := map[plumbing.Hash]bool{}
var hashes []plumbing.Hash
err = objIter.ForEach(func(o plumbing.EncodedObject) error {
expectedObjects[o.Hash()] = true
hashes = append(hashes, o.Hash())
return err
})
c.Assert(err, IsNil)
// Shuffle hashes to avoid delta selector getting order right just because
// the initial order is correct.
auxHashes := make([]plumbing.Hash, len(hashes))
for i, j := range rand.Perm(len(hashes)) {
auxHashes[j] = hashes[i]
}
hashes = auxHashes
buf := bytes.NewBuffer(nil)
enc := NewEncoder(buf, storage, false)
encodeHash, err := enc.Encode(hashes, packWindow)
c.Assert(err, IsNil)
fs := memfs.New()
f, err := fs.Create("packfile")
c.Assert(err, IsNil)
_, err = f.Write(buf.Bytes())
c.Assert(err, IsNil)
_, err = f.Seek(0, io.SeekStart)
c.Assert(err, IsNil)
w := new(idxfile.Writer)
parser, err := NewParser(NewScanner(f), w)
c.Assert(err, IsNil)
_, err = parser.Parse()
c.Assert(err, IsNil)
index, err := w.Index()
c.Assert(err, IsNil)
_, err = f.Seek(0, io.SeekStart)
c.Assert(err, IsNil)
p := NewPackfile(index, fs, f, 0)
decodeHash, err := p.ID()
c.Assert(err, IsNil)
c.Assert(encodeHash, Equals, decodeHash)
objIter, err = p.GetAll()
c.Assert(err, IsNil)
obtainedObjects := map[plumbing.Hash]bool{}
err = objIter.ForEach(func(o plumbing.EncodedObject) error {
obtainedObjects[o.Hash()] = true
return nil
})
c.Assert(err, IsNil)
c.Assert(obtainedObjects, DeepEquals, expectedObjects)
for h := range obtainedObjects {
if !expectedObjects[h] {
c.Errorf("obtained unexpected object: %s", h)
}
}
for h := range expectedObjects {
if !obtainedObjects[h] {
c.Errorf("missing object: %s", h)
}
}
}
go-git-5.13.2/plumbing/format/packfile/encoder_test.go 0000664 0000000 0000000 00000017766 14744245500 0022706 0 ustar 00root root 0000000 0000000 package packfile
import (
"bytes"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/idxfile"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/storage/memory"
"github.com/go-git/go-billy/v5/memfs"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type EncoderSuite struct {
fixtures.Suite
buf *bytes.Buffer
store *memory.Storage
enc *Encoder
}
var _ = Suite(&EncoderSuite{})
func (s *EncoderSuite) SetUpTest(c *C) {
s.buf = bytes.NewBuffer(nil)
s.store = memory.NewStorage()
s.enc = NewEncoder(s.buf, s.store, false)
}
func (s *EncoderSuite) TestCorrectPackHeader(c *C) {
h, err := s.enc.Encode([]plumbing.Hash{}, 10)
c.Assert(err, IsNil)
hb := [hash.Size]byte(h)
// PACK + VERSION + OBJECTS + HASH
expectedResult := []byte{'P', 'A', 'C', 'K', 0, 0, 0, 2, 0, 0, 0, 0}
expectedResult = append(expectedResult, hb[:]...)
result := s.buf.Bytes()
c.Assert(result, DeepEquals, expectedResult)
}
func (s *EncoderSuite) TestCorrectPackWithOneEmptyObject(c *C) {
o := &plumbing.MemoryObject{}
o.SetType(plumbing.CommitObject)
o.SetSize(0)
_, err := s.store.SetEncodedObject(o)
c.Assert(err, IsNil)
h, err := s.enc.Encode([]plumbing.Hash{o.Hash()}, 10)
c.Assert(err, IsNil)
// PACK + VERSION(2) + OBJECT NUMBER(1)
expectedResult := []byte{'P', 'A', 'C', 'K', 0, 0, 0, 2, 0, 0, 0, 1}
// OBJECT HEADER(TYPE + SIZE)= 0001 0000
expectedResult = append(expectedResult, []byte{16}...)
// Zlib header
expectedResult = append(expectedResult,
[]byte{120, 156, 1, 0, 0, 255, 255, 0, 0, 0, 1}...)
// + HASH
hb := [hash.Size]byte(h)
expectedResult = append(expectedResult, hb[:]...)
result := s.buf.Bytes()
c.Assert(result, DeepEquals, expectedResult)
}
func (s *EncoderSuite) TestMaxObjectSize(c *C) {
o := s.store.NewEncodedObject()
o.SetSize(9223372036854775807)
o.SetType(plumbing.CommitObject)
_, err := s.store.SetEncodedObject(o)
c.Assert(err, IsNil)
hash, err := s.enc.Encode([]plumbing.Hash{o.Hash()}, 10)
c.Assert(err, IsNil)
c.Assert(hash.IsZero(), Not(Equals), true)
}
func (s *EncoderSuite) TestHashNotFound(c *C) {
h, err := s.enc.Encode([]plumbing.Hash{plumbing.NewHash("BAD")}, 10)
c.Assert(h, Equals, plumbing.ZeroHash)
c.Assert(err, NotNil)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
}
func (s *EncoderSuite) TestDecodeEncodeWithDeltaDecodeREF(c *C) {
s.enc = NewEncoder(s.buf, s.store, true)
s.simpleDeltaTest(c)
}
func (s *EncoderSuite) TestDecodeEncodeWithDeltaDecodeOFS(c *C) {
s.enc = NewEncoder(s.buf, s.store, false)
s.simpleDeltaTest(c)
}
func (s *EncoderSuite) TestDecodeEncodeWithDeltasDecodeREF(c *C) {
s.enc = NewEncoder(s.buf, s.store, true)
s.deltaOverDeltaTest(c)
}
func (s *EncoderSuite) TestDecodeEncodeWithDeltasDecodeOFS(c *C) {
s.enc = NewEncoder(s.buf, s.store, false)
s.deltaOverDeltaTest(c)
}
func (s *EncoderSuite) TestDecodeEncodeWithCycleREF(c *C) {
s.enc = NewEncoder(s.buf, s.store, true)
s.deltaOverDeltaCyclicTest(c)
}
func (s *EncoderSuite) TestDecodeEncodeWithCycleOFS(c *C) {
s.enc = NewEncoder(s.buf, s.store, false)
s.deltaOverDeltaCyclicTest(c)
}
func (s *EncoderSuite) simpleDeltaTest(c *C) {
srcObject := newObject(plumbing.BlobObject, []byte("0"))
targetObject := newObject(plumbing.BlobObject, []byte("01"))
deltaObject, err := GetDelta(srcObject, targetObject)
c.Assert(err, IsNil)
srcToPack := newObjectToPack(srcObject)
encHash, err := s.enc.encode([]*ObjectToPack{
srcToPack,
newDeltaObjectToPack(srcToPack, targetObject, deltaObject),
})
c.Assert(err, IsNil)
p, cleanup := packfileFromReader(c, s.buf)
defer cleanup()
decHash, err := p.ID()
c.Assert(err, IsNil)
c.Assert(encHash, Equals, decHash)
decSrc, err := p.Get(srcObject.Hash())
c.Assert(err, IsNil)
objectsEqual(c, decSrc, srcObject)
decTarget, err := p.Get(targetObject.Hash())
c.Assert(err, IsNil)
objectsEqual(c, decTarget, targetObject)
}
func (s *EncoderSuite) deltaOverDeltaTest(c *C) {
srcObject := newObject(plumbing.BlobObject, []byte("0"))
targetObject := newObject(plumbing.BlobObject, []byte("01"))
otherTargetObject := newObject(plumbing.BlobObject, []byte("011111"))
deltaObject, err := GetDelta(srcObject, targetObject)
c.Assert(err, IsNil)
c.Assert(deltaObject.Hash(), Not(Equals), plumbing.ZeroHash)
otherDeltaObject, err := GetDelta(targetObject, otherTargetObject)
c.Assert(err, IsNil)
c.Assert(otherDeltaObject.Hash(), Not(Equals), plumbing.ZeroHash)
srcToPack := newObjectToPack(srcObject)
targetToPack := newObjectToPack(targetObject)
encHash, err := s.enc.encode([]*ObjectToPack{
targetToPack,
srcToPack,
newDeltaObjectToPack(srcToPack, targetObject, deltaObject),
newDeltaObjectToPack(targetToPack, otherTargetObject, otherDeltaObject),
})
c.Assert(err, IsNil)
p, cleanup := packfileFromReader(c, s.buf)
defer cleanup()
decHash, err := p.ID()
c.Assert(err, IsNil)
c.Assert(encHash, Equals, decHash)
decSrc, err := p.Get(srcObject.Hash())
c.Assert(err, IsNil)
objectsEqual(c, decSrc, srcObject)
decTarget, err := p.Get(targetObject.Hash())
c.Assert(err, IsNil)
objectsEqual(c, decTarget, targetObject)
decOtherTarget, err := p.Get(otherTargetObject.Hash())
c.Assert(err, IsNil)
objectsEqual(c, decOtherTarget, otherTargetObject)
}
func (s *EncoderSuite) deltaOverDeltaCyclicTest(c *C) {
o1 := newObject(plumbing.BlobObject, []byte("0"))
o2 := newObject(plumbing.BlobObject, []byte("01"))
o3 := newObject(plumbing.BlobObject, []byte("011111"))
o4 := newObject(plumbing.BlobObject, []byte("01111100000"))
_, err := s.store.SetEncodedObject(o1)
c.Assert(err, IsNil)
_, err = s.store.SetEncodedObject(o2)
c.Assert(err, IsNil)
_, err = s.store.SetEncodedObject(o3)
c.Assert(err, IsNil)
_, err = s.store.SetEncodedObject(o4)
c.Assert(err, IsNil)
d2, err := GetDelta(o1, o2)
c.Assert(err, IsNil)
d3, err := GetDelta(o4, o3)
c.Assert(err, IsNil)
d4, err := GetDelta(o3, o4)
c.Assert(err, IsNil)
po1 := newObjectToPack(o1)
pd2 := newDeltaObjectToPack(po1, o2, d2)
pd3 := newObjectToPack(o3)
pd4 := newObjectToPack(o4)
pd3.SetDelta(pd4, d3)
pd4.SetDelta(pd3, d4)
// SetOriginal is used by delta selector when generating ObjectToPack.
// It also fills type, hash and size values to be used when Original
// is nil.
po1.SetOriginal(po1.Original)
pd2.SetOriginal(pd2.Original)
pd2.CleanOriginal()
pd3.SetOriginal(pd3.Original)
pd3.CleanOriginal()
pd4.SetOriginal(pd4.Original)
encHash, err := s.enc.encode([]*ObjectToPack{
po1,
pd2,
pd3,
pd4,
})
c.Assert(err, IsNil)
p, cleanup := packfileFromReader(c, s.buf)
defer cleanup()
decHash, err := p.ID()
c.Assert(err, IsNil)
c.Assert(encHash, Equals, decHash)
decSrc, err := p.Get(o1.Hash())
c.Assert(err, IsNil)
objectsEqual(c, decSrc, o1)
decTarget, err := p.Get(o2.Hash())
c.Assert(err, IsNil)
objectsEqual(c, decTarget, o2)
decOtherTarget, err := p.Get(o3.Hash())
c.Assert(err, IsNil)
objectsEqual(c, decOtherTarget, o3)
decAnotherTarget, err := p.Get(o4.Hash())
c.Assert(err, IsNil)
objectsEqual(c, decAnotherTarget, o4)
}
func objectsEqual(c *C, o1, o2 plumbing.EncodedObject) {
c.Assert(o1.Type(), Equals, o2.Type())
c.Assert(o1.Hash(), Equals, o2.Hash())
c.Assert(o1.Size(), Equals, o2.Size())
r1, err := o1.Reader()
c.Assert(err, IsNil)
b1, err := io.ReadAll(r1)
c.Assert(err, IsNil)
r2, err := o2.Reader()
c.Assert(err, IsNil)
b2, err := io.ReadAll(r2)
c.Assert(err, IsNil)
c.Assert(bytes.Compare(b1, b2), Equals, 0)
err = r2.Close()
c.Assert(err, IsNil)
err = r1.Close()
c.Assert(err, IsNil)
}
func packfileFromReader(c *C, buf *bytes.Buffer) (*Packfile, func()) {
fs := memfs.New()
file, err := fs.Create("packfile")
c.Assert(err, IsNil)
_, err = file.Write(buf.Bytes())
c.Assert(err, IsNil)
_, err = file.Seek(0, io.SeekStart)
c.Assert(err, IsNil)
scanner := NewScanner(file)
w := new(idxfile.Writer)
p, err := NewParser(scanner, w)
c.Assert(err, IsNil)
_, err = p.Parse()
c.Assert(err, IsNil)
index, err := w.Index()
c.Assert(err, IsNil)
return NewPackfile(index, fs, file, 0), func() {
c.Assert(file.Close(), IsNil)
}
}
go-git-5.13.2/plumbing/format/packfile/error.go 0000664 0000000 0000000 00000001205 14744245500 0021336 0 ustar 00root root 0000000 0000000 package packfile
import "fmt"
// Error specifies errors returned during packfile parsing.
type Error struct {
reason, details string
}
// NewError returns a new error.
func NewError(reason string) *Error {
return &Error{reason: reason}
}
// Error returns a text representation of the error.
func (e *Error) Error() string {
if e.details == "" {
return e.reason
}
return fmt.Sprintf("%s: %s", e.reason, e.details)
}
// AddDetails adds details to an error, with additional text.
func (e *Error) AddDetails(format string, args ...interface{}) *Error {
return &Error{
reason: e.reason,
details: fmt.Sprintf(format, args...),
}
}
go-git-5.13.2/plumbing/format/packfile/fsobject.go 0000664 0000000 0000000 00000005600 14744245500 0022007 0 ustar 00root root 0000000 0000000 package packfile
import (
"io"
billy "github.com/go-git/go-billy/v5"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/format/idxfile"
"github.com/go-git/go-git/v5/utils/ioutil"
)
// FSObject is an object from the packfile on the filesystem.
type FSObject struct {
hash plumbing.Hash
offset int64
size int64
typ plumbing.ObjectType
index idxfile.Index
fs billy.Filesystem
path string
cache cache.Object
largeObjectThreshold int64
}
// NewFSObject creates a new filesystem object.
func NewFSObject(
hash plumbing.Hash,
finalType plumbing.ObjectType,
offset int64,
contentSize int64,
index idxfile.Index,
fs billy.Filesystem,
path string,
cache cache.Object,
largeObjectThreshold int64,
) *FSObject {
return &FSObject{
hash: hash,
offset: offset,
size: contentSize,
typ: finalType,
index: index,
fs: fs,
path: path,
cache: cache,
largeObjectThreshold: largeObjectThreshold,
}
}
// Reader implements the plumbing.EncodedObject interface.
func (o *FSObject) Reader() (io.ReadCloser, error) {
obj, ok := o.cache.Get(o.hash)
if ok && obj != o {
reader, err := obj.Reader()
if err != nil {
return nil, err
}
return reader, nil
}
f, err := o.fs.Open(o.path)
if err != nil {
return nil, err
}
p := NewPackfileWithCache(o.index, nil, f, o.cache, o.largeObjectThreshold)
if o.largeObjectThreshold > 0 && o.size > o.largeObjectThreshold {
// We have a big object
h, err := p.objectHeaderAtOffset(o.offset)
if err != nil {
return nil, err
}
r, err := p.getReaderDirect(h)
if err != nil {
_ = f.Close()
return nil, err
}
return ioutil.NewReadCloserWithCloser(r, f.Close), nil
}
r, err := p.getObjectContent(o.offset)
if err != nil {
_ = f.Close()
return nil, err
}
if err := f.Close(); err != nil {
return nil, err
}
return r, nil
}
// SetSize implements the plumbing.EncodedObject interface. This method
// is a noop.
func (o *FSObject) SetSize(int64) {}
// SetType implements the plumbing.EncodedObject interface. This method is
// a noop.
func (o *FSObject) SetType(plumbing.ObjectType) {}
// Hash implements the plumbing.EncodedObject interface.
func (o *FSObject) Hash() plumbing.Hash { return o.hash }
// Size implements the plumbing.EncodedObject interface.
func (o *FSObject) Size() int64 { return o.size }
// Type implements the plumbing.EncodedObject interface.
func (o *FSObject) Type() plumbing.ObjectType {
return o.typ
}
// Writer implements the plumbing.EncodedObject interface. This method always
// returns a nil writer.
func (o *FSObject) Writer() (io.WriteCloser, error) {
return nil, nil
}
go-git-5.13.2/plumbing/format/packfile/object_pack.go 0000664 0000000 0000000 00000007605 14744245500 0022463 0 ustar 00root root 0000000 0000000 package packfile
import (
"github.com/go-git/go-git/v5/plumbing"
)
// ObjectToPack is a representation of an object that is going to be into a
// pack file.
type ObjectToPack struct {
// The main object to pack, it could be any object, including deltas
Object plumbing.EncodedObject
// Base is the object that a delta is based on (it could be also another delta).
// If the main object is not a delta, Base will be null
Base *ObjectToPack
// Original is the object that we can generate applying the delta to
// Base, or the same object as Object in the case of a non-delta
// object.
Original plumbing.EncodedObject
// Depth is the amount of deltas needed to resolve to obtain Original
// (delta based on delta based on ...)
Depth int
// offset in pack when object has been already written, or 0 if it
// has not been written yet
Offset int64
// Information from the original object
resolvedOriginal bool
originalType plumbing.ObjectType
originalSize int64
originalHash plumbing.Hash
}
// newObjectToPack creates a correct ObjectToPack based on a non-delta object
func newObjectToPack(o plumbing.EncodedObject) *ObjectToPack {
return &ObjectToPack{
Object: o,
Original: o,
}
}
// newDeltaObjectToPack creates a correct ObjectToPack for a delta object, based on
// his base (could be another delta), the delta target (in this case called original),
// and the delta Object itself
func newDeltaObjectToPack(base *ObjectToPack, original, delta plumbing.EncodedObject) *ObjectToPack {
return &ObjectToPack{
Object: delta,
Base: base,
Original: original,
Depth: base.Depth + 1,
}
}
// BackToOriginal converts that ObjectToPack to a non-deltified object if it was one
func (o *ObjectToPack) BackToOriginal() {
if o.IsDelta() && o.Original != nil {
o.Object = o.Original
o.Base = nil
o.Depth = 0
}
}
// IsWritten returns if that ObjectToPack was
// already written into the packfile or not
func (o *ObjectToPack) IsWritten() bool {
return o.Offset > 1
}
// MarkWantWrite marks this ObjectToPack as WantWrite
// to avoid delta chain loops
func (o *ObjectToPack) MarkWantWrite() {
o.Offset = 1
}
// WantWrite checks if this ObjectToPack was marked as WantWrite before
func (o *ObjectToPack) WantWrite() bool {
return o.Offset == 1
}
// SetOriginal sets both Original and saves size, type and hash. If object
// is nil Original is set but previous resolved values are kept
func (o *ObjectToPack) SetOriginal(obj plumbing.EncodedObject) {
o.Original = obj
o.SaveOriginalMetadata()
}
// SaveOriginalMetadata saves size, type and hash of Original object
func (o *ObjectToPack) SaveOriginalMetadata() {
if o.Original != nil {
o.originalSize = o.Original.Size()
o.originalType = o.Original.Type()
o.originalHash = o.Original.Hash()
o.resolvedOriginal = true
}
}
// CleanOriginal sets Original to nil
func (o *ObjectToPack) CleanOriginal() {
o.Original = nil
}
func (o *ObjectToPack) Type() plumbing.ObjectType {
if o.Original != nil {
return o.Original.Type()
}
if o.resolvedOriginal {
return o.originalType
}
if o.Base != nil {
return o.Base.Type()
}
if o.Object != nil {
return o.Object.Type()
}
panic("cannot get type")
}
func (o *ObjectToPack) Hash() plumbing.Hash {
if o.Original != nil {
return o.Original.Hash()
}
if o.resolvedOriginal {
return o.originalHash
}
do, ok := o.Object.(plumbing.DeltaObject)
if ok {
return do.ActualHash()
}
panic("cannot get hash")
}
func (o *ObjectToPack) Size() int64 {
if o.Original != nil {
return o.Original.Size()
}
if o.resolvedOriginal {
return o.originalSize
}
do, ok := o.Object.(plumbing.DeltaObject)
if ok {
return do.ActualSize()
}
panic("cannot get ObjectToPack size")
}
func (o *ObjectToPack) IsDelta() bool {
return o.Base != nil
}
func (o *ObjectToPack) SetDelta(base *ObjectToPack, delta plumbing.EncodedObject) {
o.Object = delta
o.Base = base
o.Depth = base.Depth + 1
}
go-git-5.13.2/plumbing/format/packfile/object_pack_test.go 0000664 0000000 0000000 00000002320 14744245500 0023507 0 ustar 00root root 0000000 0000000 package packfile
import (
"io"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
type ObjectToPackSuite struct{}
var _ = Suite(&ObjectToPackSuite{})
func (s *ObjectToPackSuite) TestObjectToPack(c *C) {
obj := &dummyObject{}
otp := newObjectToPack(obj)
c.Assert(obj, Equals, otp.Object)
c.Assert(obj, Equals, otp.Original)
c.Assert(otp.Base, IsNil)
c.Assert(otp.IsDelta(), Equals, false)
original := &dummyObject{}
delta := &dummyObject{}
deltaToPack := newDeltaObjectToPack(otp, original, delta)
c.Assert(obj, Equals, deltaToPack.Object)
c.Assert(original, Equals, deltaToPack.Original)
c.Assert(otp, Equals, deltaToPack.Base)
c.Assert(deltaToPack.IsDelta(), Equals, true)
}
type dummyObject struct{}
func (*dummyObject) Hash() plumbing.Hash { return plumbing.ZeroHash }
func (*dummyObject) Type() plumbing.ObjectType { return plumbing.InvalidObject }
func (*dummyObject) SetType(plumbing.ObjectType) {}
func (*dummyObject) Size() int64 { return 0 }
func (*dummyObject) SetSize(s int64) {}
func (*dummyObject) Reader() (io.ReadCloser, error) { return nil, nil }
func (*dummyObject) Writer() (io.WriteCloser, error) { return nil, nil }
go-git-5.13.2/plumbing/format/packfile/packfile.go 0000664 0000000 0000000 00000036715 14744245500 0022001 0 ustar 00root root 0000000 0000000 package packfile
import (
"bytes"
"fmt"
"io"
"os"
billy "github.com/go-git/go-billy/v5"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/format/idxfile"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-git/v5/utils/sync"
)
var (
// ErrInvalidObject is returned by Decode when an invalid object is
// found in the packfile.
ErrInvalidObject = NewError("invalid git object")
// ErrZLib is returned by Decode when there was an error unzipping
// the packfile contents.
ErrZLib = NewError("zlib reading error")
)
// When reading small objects from packfile it is beneficial to do so at
// once to exploit the buffered I/O. In many cases the objects are so small
// that they were already loaded to memory when the object header was
// loaded from the packfile. Wrapping in FSObject would cause this buffered
// data to be thrown away and then re-read later, with the additional
// seeking causing reloads from disk. Objects smaller than this threshold
// are now always read into memory and stored in cache instead of being
// wrapped in FSObject.
const smallObjectThreshold = 16 * 1024
// Packfile allows retrieving information from inside a packfile.
type Packfile struct {
idxfile.Index
fs billy.Filesystem
file billy.File
s *Scanner
deltaBaseCache cache.Object
offsetToType map[int64]plumbing.ObjectType
largeObjectThreshold int64
}
// NewPackfileWithCache creates a new Packfile with the given object cache.
// If the filesystem is provided, the packfile will return FSObjects, otherwise
// it will return MemoryObjects.
func NewPackfileWithCache(
index idxfile.Index,
fs billy.Filesystem,
file billy.File,
cache cache.Object,
largeObjectThreshold int64,
) *Packfile {
s := NewScanner(file)
return &Packfile{
index,
fs,
file,
s,
cache,
make(map[int64]plumbing.ObjectType),
largeObjectThreshold,
}
}
// NewPackfile returns a packfile representation for the given packfile file
// and packfile idx.
// If the filesystem is provided, the packfile will return FSObjects, otherwise
// it will return MemoryObjects.
func NewPackfile(index idxfile.Index, fs billy.Filesystem, file billy.File, largeObjectThreshold int64) *Packfile {
return NewPackfileWithCache(index, fs, file, cache.NewObjectLRUDefault(), largeObjectThreshold)
}
// Get retrieves the encoded object in the packfile with the given hash.
func (p *Packfile) Get(h plumbing.Hash) (plumbing.EncodedObject, error) {
offset, err := p.FindOffset(h)
if err != nil {
return nil, err
}
return p.objectAtOffset(offset, h)
}
// GetByOffset retrieves the encoded object from the packfile at the given
// offset.
func (p *Packfile) GetByOffset(o int64) (plumbing.EncodedObject, error) {
hash, err := p.FindHash(o)
if err != nil {
return nil, err
}
return p.objectAtOffset(o, hash)
}
// GetSizeByOffset retrieves the size of the encoded object from the
// packfile with the given offset.
func (p *Packfile) GetSizeByOffset(o int64) (size int64, err error) {
if _, err := p.s.SeekFromStart(o); err != nil {
if err == io.EOF || isInvalid(err) {
return 0, plumbing.ErrObjectNotFound
}
return 0, err
}
h, err := p.nextObjectHeader()
if err != nil {
return 0, err
}
return p.getObjectSize(h)
}
func (p *Packfile) objectHeaderAtOffset(offset int64) (*ObjectHeader, error) {
h, err := p.s.SeekObjectHeader(offset)
p.s.pendingObject = nil
return h, err
}
func (p *Packfile) nextObjectHeader() (*ObjectHeader, error) {
h, err := p.s.NextObjectHeader()
p.s.pendingObject = nil
return h, err
}
func (p *Packfile) getDeltaObjectSize(buf *bytes.Buffer) int64 {
delta := buf.Bytes()
_, delta = decodeLEB128(delta) // skip src size
sz, _ := decodeLEB128(delta)
return int64(sz)
}
func (p *Packfile) getObjectSize(h *ObjectHeader) (int64, error) {
switch h.Type {
case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject:
return h.Length, nil
case plumbing.REFDeltaObject, plumbing.OFSDeltaObject:
buf := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(buf)
if _, _, err := p.s.NextObject(buf); err != nil {
return 0, err
}
return p.getDeltaObjectSize(buf), nil
default:
return 0, ErrInvalidObject.AddDetails("type %q", h.Type)
}
}
func (p *Packfile) getObjectType(h *ObjectHeader) (typ plumbing.ObjectType, err error) {
switch h.Type {
case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject:
return h.Type, nil
case plumbing.REFDeltaObject, plumbing.OFSDeltaObject:
var offset int64
if h.Type == plumbing.REFDeltaObject {
offset, err = p.FindOffset(h.Reference)
if err != nil {
return
}
} else {
offset = h.OffsetReference
}
if baseType, ok := p.offsetToType[offset]; ok {
typ = baseType
} else {
h, err = p.objectHeaderAtOffset(offset)
if err != nil {
return
}
typ, err = p.getObjectType(h)
if err != nil {
return
}
}
default:
err = ErrInvalidObject.AddDetails("type %q", h.Type)
}
p.offsetToType[h.Offset] = typ
return
}
func (p *Packfile) objectAtOffset(offset int64, hash plumbing.Hash) (plumbing.EncodedObject, error) {
if obj, ok := p.cacheGet(hash); ok {
return obj, nil
}
h, err := p.objectHeaderAtOffset(offset)
if err != nil {
if err == io.EOF || isInvalid(err) {
return nil, plumbing.ErrObjectNotFound
}
return nil, err
}
return p.getNextObject(h, hash)
}
func (p *Packfile) getNextObject(h *ObjectHeader, hash plumbing.Hash) (plumbing.EncodedObject, error) {
var err error
// If we have no filesystem, we will return a MemoryObject instead
// of an FSObject.
if p.fs == nil {
return p.getNextMemoryObject(h)
}
// If the object is small enough then read it completely into memory now since
// it is already read from disk into buffer anyway. For delta objects we want
// to perform the optimization too, but we have to be careful about applying
// small deltas on big objects.
var size int64
if h.Length <= smallObjectThreshold {
if h.Type != plumbing.OFSDeltaObject && h.Type != plumbing.REFDeltaObject {
return p.getNextMemoryObject(h)
}
// For delta objects we read the delta data and apply the small object
// optimization only if the expanded version of the object still meets
// the small object threshold condition.
buf := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(buf)
if _, _, err := p.s.NextObject(buf); err != nil {
return nil, err
}
size = p.getDeltaObjectSize(buf)
if size <= smallObjectThreshold {
var obj = new(plumbing.MemoryObject)
obj.SetSize(size)
if h.Type == plumbing.REFDeltaObject {
err = p.fillREFDeltaObjectContentWithBuffer(obj, h.Reference, buf)
} else {
err = p.fillOFSDeltaObjectContentWithBuffer(obj, h.OffsetReference, buf)
}
return obj, err
}
} else {
size, err = p.getObjectSize(h)
if err != nil {
return nil, err
}
}
typ, err := p.getObjectType(h)
if err != nil {
return nil, err
}
p.offsetToType[h.Offset] = typ
return NewFSObject(
hash,
typ,
h.Offset,
size,
p.Index,
p.fs,
p.file.Name(),
p.deltaBaseCache,
p.largeObjectThreshold,
), nil
}
func (p *Packfile) getObjectContent(offset int64) (io.ReadCloser, error) {
h, err := p.objectHeaderAtOffset(offset)
if err != nil {
return nil, err
}
// getObjectContent is called from FSObject, so we have to explicitly
// get memory object here to avoid recursive cycle
obj, err := p.getNextMemoryObject(h)
if err != nil {
return nil, err
}
return obj.Reader()
}
func asyncReader(p *Packfile) (io.ReadCloser, error) {
reader := ioutil.NewReaderUsingReaderAt(p.file, p.s.r.offset)
zr, err := sync.GetZlibReader(reader)
if err != nil {
return nil, fmt.Errorf("zlib reset error: %s", err)
}
return ioutil.NewReadCloserWithCloser(zr.Reader, func() error {
sync.PutZlibReader(zr)
return nil
}), nil
}
func (p *Packfile) getReaderDirect(h *ObjectHeader) (io.ReadCloser, error) {
switch h.Type {
case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject:
return asyncReader(p)
case plumbing.REFDeltaObject:
deltaRc, err := asyncReader(p)
if err != nil {
return nil, err
}
r, err := p.readREFDeltaObjectContent(h, deltaRc)
if err != nil {
return nil, err
}
return r, nil
case plumbing.OFSDeltaObject:
deltaRc, err := asyncReader(p)
if err != nil {
return nil, err
}
r, err := p.readOFSDeltaObjectContent(h, deltaRc)
if err != nil {
return nil, err
}
return r, nil
default:
return nil, ErrInvalidObject.AddDetails("type %q", h.Type)
}
}
func (p *Packfile) getNextMemoryObject(h *ObjectHeader) (plumbing.EncodedObject, error) {
var obj = new(plumbing.MemoryObject)
obj.SetSize(h.Length)
obj.SetType(h.Type)
var err error
switch h.Type {
case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject:
err = p.fillRegularObjectContent(obj)
case plumbing.REFDeltaObject:
err = p.fillREFDeltaObjectContent(obj, h.Reference)
case plumbing.OFSDeltaObject:
err = p.fillOFSDeltaObjectContent(obj, h.OffsetReference)
default:
err = ErrInvalidObject.AddDetails("type %q", h.Type)
}
if err != nil {
return nil, err
}
p.offsetToType[h.Offset] = obj.Type()
return obj, nil
}
func (p *Packfile) fillRegularObjectContent(obj plumbing.EncodedObject) (err error) {
w, err := obj.Writer()
if err != nil {
return err
}
defer ioutil.CheckClose(w, &err)
_, _, err = p.s.NextObject(w)
p.cachePut(obj)
return err
}
func (p *Packfile) fillREFDeltaObjectContent(obj plumbing.EncodedObject, ref plumbing.Hash) error {
buf := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(buf)
_, _, err := p.s.NextObject(buf)
if err != nil {
return err
}
return p.fillREFDeltaObjectContentWithBuffer(obj, ref, buf)
}
func (p *Packfile) readREFDeltaObjectContent(h *ObjectHeader, deltaRC io.Reader) (io.ReadCloser, error) {
var err error
base, ok := p.cacheGet(h.Reference)
if !ok {
base, err = p.Get(h.Reference)
if err != nil {
return nil, err
}
}
return ReaderFromDelta(base, deltaRC)
}
func (p *Packfile) fillREFDeltaObjectContentWithBuffer(obj plumbing.EncodedObject, ref plumbing.Hash, buf *bytes.Buffer) error {
var err error
base, ok := p.cacheGet(ref)
if !ok {
base, err = p.Get(ref)
if err != nil {
return err
}
}
obj.SetType(base.Type())
err = ApplyDelta(obj, base, buf.Bytes())
p.cachePut(obj)
return err
}
func (p *Packfile) fillOFSDeltaObjectContent(obj plumbing.EncodedObject, offset int64) error {
buf := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(buf)
_, _, err := p.s.NextObject(buf)
if err != nil {
return err
}
return p.fillOFSDeltaObjectContentWithBuffer(obj, offset, buf)
}
func (p *Packfile) readOFSDeltaObjectContent(h *ObjectHeader, deltaRC io.Reader) (io.ReadCloser, error) {
hash, err := p.FindHash(h.OffsetReference)
if err != nil {
return nil, err
}
base, err := p.objectAtOffset(h.OffsetReference, hash)
if err != nil {
return nil, err
}
return ReaderFromDelta(base, deltaRC)
}
func (p *Packfile) fillOFSDeltaObjectContentWithBuffer(obj plumbing.EncodedObject, offset int64, buf *bytes.Buffer) error {
hash, err := p.FindHash(offset)
if err != nil {
return err
}
base, err := p.objectAtOffset(offset, hash)
if err != nil {
return err
}
obj.SetType(base.Type())
err = ApplyDelta(obj, base, buf.Bytes())
p.cachePut(obj)
return err
}
func (p *Packfile) cacheGet(h plumbing.Hash) (plumbing.EncodedObject, bool) {
if p.deltaBaseCache == nil {
return nil, false
}
return p.deltaBaseCache.Get(h)
}
func (p *Packfile) cachePut(obj plumbing.EncodedObject) {
if p.deltaBaseCache == nil {
return
}
p.deltaBaseCache.Put(obj)
}
// GetAll returns an iterator with all encoded objects in the packfile.
// The iterator returned is not thread-safe, it should be used in the same
// thread as the Packfile instance.
func (p *Packfile) GetAll() (storer.EncodedObjectIter, error) {
return p.GetByType(plumbing.AnyObject)
}
// GetByType returns all the objects of the given type.
func (p *Packfile) GetByType(typ plumbing.ObjectType) (storer.EncodedObjectIter, error) {
switch typ {
case plumbing.AnyObject,
plumbing.BlobObject,
plumbing.TreeObject,
plumbing.CommitObject,
plumbing.TagObject:
entries, err := p.EntriesByOffset()
if err != nil {
return nil, err
}
return &objectIter{
// Easiest way to provide an object decoder is just to pass a Packfile
// instance. To not mess with the seeks, it's a new instance with a
// different scanner but the same cache and offset to hash map for
// reusing as much cache as possible.
p: p,
iter: entries,
typ: typ,
}, nil
default:
return nil, plumbing.ErrInvalidType
}
}
// ID returns the ID of the packfile, which is the checksum at the end of it.
func (p *Packfile) ID() (plumbing.Hash, error) {
prev, err := p.file.Seek(-20, io.SeekEnd)
if err != nil {
return plumbing.ZeroHash, err
}
var hash plumbing.Hash
if _, err := io.ReadFull(p.file, hash[:]); err != nil {
return plumbing.ZeroHash, err
}
if _, err := p.file.Seek(prev, io.SeekStart); err != nil {
return plumbing.ZeroHash, err
}
return hash, nil
}
// Scanner returns the packfile's Scanner
func (p *Packfile) Scanner() *Scanner {
return p.s
}
// Close the packfile and its resources.
func (p *Packfile) Close() error {
closer, ok := p.file.(io.Closer)
if !ok {
return nil
}
return closer.Close()
}
type objectIter struct {
p *Packfile
typ plumbing.ObjectType
iter idxfile.EntryIter
}
func (i *objectIter) Next() (plumbing.EncodedObject, error) {
for {
e, err := i.iter.Next()
if err != nil {
return nil, err
}
if i.typ != plumbing.AnyObject {
if typ, ok := i.p.offsetToType[int64(e.Offset)]; ok {
if typ != i.typ {
continue
}
} else if obj, ok := i.p.cacheGet(e.Hash); ok {
if obj.Type() != i.typ {
i.p.offsetToType[int64(e.Offset)] = obj.Type()
continue
}
return obj, nil
} else {
h, err := i.p.objectHeaderAtOffset(int64(e.Offset))
if err != nil {
return nil, err
}
if h.Type == plumbing.REFDeltaObject || h.Type == plumbing.OFSDeltaObject {
typ, err := i.p.getObjectType(h)
if err != nil {
return nil, err
}
if typ != i.typ {
i.p.offsetToType[int64(e.Offset)] = typ
continue
}
// getObjectType will seek in the file so we cannot use getNextObject safely
return i.p.objectAtOffset(int64(e.Offset), e.Hash)
} else {
if h.Type != i.typ {
i.p.offsetToType[int64(e.Offset)] = h.Type
continue
}
return i.p.getNextObject(h, e.Hash)
}
}
}
obj, err := i.p.objectAtOffset(int64(e.Offset), e.Hash)
if err != nil {
return nil, err
}
return obj, nil
}
}
func (i *objectIter) ForEach(f func(plumbing.EncodedObject) error) error {
for {
o, err := i.Next()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
if err := f(o); err != nil {
return err
}
}
}
func (i *objectIter) Close() {
i.iter.Close()
}
// isInvalid checks whether an error is an os.PathError with an os.ErrInvalid
// error inside. It also checks for the windows error, which is different from
// os.ErrInvalid.
func isInvalid(err error) bool {
pe, ok := err.(*os.PathError)
if !ok {
return false
}
errstr := pe.Err.Error()
return errstr == errInvalidUnix || errstr == errInvalidWindows
}
// errInvalidWindows is the Windows equivalent to os.ErrInvalid
const errInvalidWindows = "The parameter is incorrect."
var errInvalidUnix = os.ErrInvalid.Error()
go-git-5.13.2/plumbing/format/packfile/packfile_test.go 0000664 0000000 0000000 00000020506 14744245500 0023027 0 ustar 00root root 0000000 0000000 package packfile_test
import (
"io"
"math"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/idxfile"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
. "gopkg.in/check.v1"
)
type PackfileSuite struct {
fixtures.Suite
p *packfile.Packfile
idx *idxfile.MemoryIndex
f *fixtures.Fixture
}
var _ = Suite(&PackfileSuite{})
func (s *PackfileSuite) TestGet(c *C) {
for h := range expectedEntries {
obj, err := s.p.Get(h)
c.Assert(err, IsNil)
c.Assert(obj, Not(IsNil))
c.Assert(obj.Hash(), Equals, h)
}
_, err := s.p.Get(plumbing.ZeroHash)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
}
func (s *PackfileSuite) TestGetByOffset(c *C) {
for h, o := range expectedEntries {
obj, err := s.p.GetByOffset(o)
c.Assert(err, IsNil)
c.Assert(obj, Not(IsNil))
c.Assert(obj.Hash(), Equals, h)
}
_, err := s.p.GetByOffset(math.MaxInt64)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
}
func (s *PackfileSuite) TestID(c *C) {
id, err := s.p.ID()
c.Assert(err, IsNil)
c.Assert(id.String(), Equals, s.f.PackfileHash)
}
func (s *PackfileSuite) TestGetAll(c *C) {
iter, err := s.p.GetAll()
c.Assert(err, IsNil)
var objects int
for {
o, err := iter.Next()
if err == io.EOF {
break
}
c.Assert(err, IsNil)
objects++
_, ok := expectedEntries[o.Hash()]
c.Assert(ok, Equals, true)
}
c.Assert(objects, Equals, len(expectedEntries))
}
var expectedEntries = map[plumbing.Hash]int64{
plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"): 615,
plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88"): 1524,
plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"): 1063,
plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9"): 78882,
plumbing.NewHash("4d081c50e250fa32ea8b1313cf8bb7c2ad7627fd"): 84688,
plumbing.NewHash("586af567d0bb5e771e49bdd9434f5e0fb76d25fa"): 84559,
plumbing.NewHash("5a877e6a906a2743ad6e45d99c1793642aaf8eda"): 84479,
plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"): 186,
plumbing.NewHash("7e59600739c96546163833214c36459e324bad0a"): 84653,
plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198"): 78050,
plumbing.NewHash("8dcef98b1d52143e1e2dbc458ffe38f925786bf2"): 84741,
plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"): 286,
plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492"): 80998,
plumbing.NewHash("9dea2395f5403188298c1dabe8bdafe562c491e3"): 84032,
plumbing.NewHash("a39771a7651f97faf5c72e08224d857fc35133db"): 84430,
plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"): 838,
plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"): 84375,
plumbing.NewHash("aa9b383c260e1d05fbbf6b30a02914555e20c725"): 84760,
plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"): 449,
plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"): 1392,
plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"): 1230,
plumbing.NewHash("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f"): 1713,
plumbing.NewHash("c2d30fa8ef288618f65f6eed6e168e0d514886f4"): 84725,
plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956"): 80725,
plumbing.NewHash("cf4aa3b38974fb7d81f367c0830f7d78d65ab86b"): 84608,
plumbing.NewHash("d3ff53e0564a9f87d8e84b6e28e5060e517008aa"): 1685,
plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d"): 2351,
plumbing.NewHash("dbd3641b371024f44d0e469a9c8f5457b0660de1"): 84115,
plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"): 12,
plumbing.NewHash("eba74343e2f15d62adedfd8c883ee0262b5c8021"): 84708,
plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e"): 84671,
}
func (s *PackfileSuite) SetUpTest(c *C) {
s.f = fixtures.Basic().One()
s.idx = idxfile.NewMemoryIndex()
c.Assert(idxfile.NewDecoder(s.f.Idx()).Decode(s.idx), IsNil)
s.p = packfile.NewPackfile(s.idx, fixtures.Filesystem, s.f.Packfile(), 0)
}
func (s *PackfileSuite) TearDownTest(c *C) {
c.Assert(s.p.Close(), IsNil)
}
func (s *PackfileSuite) TestDecode(c *C) {
fixtures.Basic().ByTag("packfile").Test(c, func(f *fixtures.Fixture) {
index := getIndexFromIdxFile(f.Idx())
p := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0)
defer p.Close()
for _, h := range expectedHashes {
obj, err := p.Get(plumbing.NewHash(h))
c.Assert(err, IsNil)
c.Assert(obj.Hash().String(), Equals, h)
}
})
}
func (s *PackfileSuite) TestDecodeByTypeRefDelta(c *C) {
f := fixtures.Basic().ByTag("ref-delta").One()
index := getIndexFromIdxFile(f.Idx())
packfile := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0)
defer packfile.Close()
iter, err := packfile.GetByType(plumbing.CommitObject)
c.Assert(err, IsNil)
var count int
for {
obj, err := iter.Next()
if err == io.EOF {
break
}
count++
c.Assert(err, IsNil)
c.Assert(obj.Type(), Equals, plumbing.CommitObject)
}
c.Assert(count > 0, Equals, true)
}
func (s *PackfileSuite) TestDecodeByType(c *C) {
ts := []plumbing.ObjectType{
plumbing.CommitObject,
plumbing.TagObject,
plumbing.TreeObject,
plumbing.BlobObject,
}
fixtures.Basic().ByTag("packfile").Test(c, func(f *fixtures.Fixture) {
for _, t := range ts {
index := getIndexFromIdxFile(f.Idx())
packfile := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0)
defer packfile.Close()
iter, err := packfile.GetByType(t)
c.Assert(err, IsNil)
c.Assert(iter.ForEach(func(obj plumbing.EncodedObject) error {
c.Assert(obj.Type(), Equals, t)
return nil
}), IsNil)
}
})
}
func (s *PackfileSuite) TestDecodeByTypeConstructor(c *C) {
f := fixtures.Basic().ByTag("packfile").One()
index := getIndexFromIdxFile(f.Idx())
packfile := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0)
defer packfile.Close()
_, err := packfile.GetByType(plumbing.OFSDeltaObject)
c.Assert(err, Equals, plumbing.ErrInvalidType)
_, err = packfile.GetByType(plumbing.REFDeltaObject)
c.Assert(err, Equals, plumbing.ErrInvalidType)
_, err = packfile.GetByType(plumbing.InvalidObject)
c.Assert(err, Equals, plumbing.ErrInvalidType)
}
var expectedHashes = []string{
"918c48b83bd081e863dbe1b80f8998f058cd8294",
"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
"1669dce138d9b841a518c64b10914d88f5e488ea",
"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
"b8e471f58bcbca63b07bda20e428190409c2db47",
"35e85108805c84807bc66a02d91535e1e24b38b9",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
"32858aad3c383ed1ff0a0f9bdf231d54a00c9e88",
"d3ff53e0564a9f87d8e84b6e28e5060e517008aa",
"c192bd6a24ea1ab01d78686e417c8bdc7c3d197f",
"d5c0f4ab811897cadf03aec358ae60d21f91c50d",
"49c6bb89b17060d7b4deacb7b338fcc6ea2352a9",
"cf4aa3b38974fb7d81f367c0830f7d78d65ab86b",
"9dea2395f5403188298c1dabe8bdafe562c491e3",
"586af567d0bb5e771e49bdd9434f5e0fb76d25fa",
"9a48f23120e880dfbe41f7c9b7b708e9ee62a492",
"5a877e6a906a2743ad6e45d99c1793642aaf8eda",
"c8f1d8c61f9da76f4cb49fd86322b6e685dba956",
"a8d315b2b1c615d43042c3a62402b8a54288cf5c",
"a39771a7651f97faf5c72e08224d857fc35133db",
"880cd14280f4b9b6ed3986d6671f907d7cc2a198",
"fb72698cab7617ac416264415f13224dfd7a165e",
"4d081c50e250fa32ea8b1313cf8bb7c2ad7627fd",
"eba74343e2f15d62adedfd8c883ee0262b5c8021",
"c2d30fa8ef288618f65f6eed6e168e0d514886f4",
"8dcef98b1d52143e1e2dbc458ffe38f925786bf2",
"aa9b383c260e1d05fbbf6b30a02914555e20c725",
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"dbd3641b371024f44d0e469a9c8f5457b0660de1",
"e8d3ffab552895c19b9fcf7aa264d277cde33881",
"7e59600739c96546163833214c36459e324bad0a",
}
func getIndexFromIdxFile(r io.Reader) idxfile.Index {
idx := idxfile.NewMemoryIndex()
if err := idxfile.NewDecoder(r).Decode(idx); err != nil {
panic(err)
}
return idx
}
func (s *PackfileSuite) TestSize(c *C) {
f := fixtures.Basic().ByTag("ref-delta").One()
index := getIndexFromIdxFile(f.Idx())
packfile := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0)
defer packfile.Close()
// Get the size of binary.jpg, which is not delta-encoded.
offset, err := packfile.FindOffset(plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d"))
c.Assert(err, IsNil)
size, err := packfile.GetSizeByOffset(offset)
c.Assert(err, IsNil)
c.Assert(size, Equals, int64(76110))
// Get the size of the root commit, which is delta-encoded.
offset, err = packfile.FindOffset(plumbing.NewHash(f.Head))
c.Assert(err, IsNil)
size, err = packfile.GetSizeByOffset(offset)
c.Assert(err, IsNil)
c.Assert(size, Equals, int64(245))
}
go-git-5.13.2/plumbing/format/packfile/parser.go 0000664 0000000 0000000 00000034632 14744245500 0021513 0 ustar 00root root 0000000 0000000 package packfile
import (
"bytes"
"errors"
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-git/v5/utils/sync"
)
var (
// ErrReferenceDeltaNotFound is returned when the reference delta is not
// found.
ErrReferenceDeltaNotFound = errors.New("reference delta not found")
// ErrNotSeekableSource is returned when the source for the parser is not
// seekable and a storage was not provided, so it can't be parsed.
ErrNotSeekableSource = errors.New("parser source is not seekable and storage was not provided")
// ErrDeltaNotCached is returned when the delta could not be found in cache.
ErrDeltaNotCached = errors.New("delta could not be found in cache")
)
// Observer interface is implemented by index encoders.
type Observer interface {
// OnHeader is called when a new packfile is opened.
OnHeader(count uint32) error
// OnInflatedObjectHeader is called for each object header read.
OnInflatedObjectHeader(t plumbing.ObjectType, objSize int64, pos int64) error
// OnInflatedObjectContent is called for each decoded object.
OnInflatedObjectContent(h plumbing.Hash, pos int64, crc uint32, content []byte) error
// OnFooter is called when decoding is done.
OnFooter(h plumbing.Hash) error
}
// Parser decodes a packfile and calls any observer associated to it. Is used
// to generate indexes.
type Parser struct {
storage storer.EncodedObjectStorer
scanner *Scanner
count uint32
oi []*objectInfo
oiByHash map[plumbing.Hash]*objectInfo
oiByOffset map[int64]*objectInfo
checksum plumbing.Hash
cache *cache.BufferLRU
// delta content by offset, only used if source is not seekable
deltas map[int64][]byte
ob []Observer
}
// NewParser creates a new Parser. The Scanner source must be seekable.
// If it's not, NewParserWithStorage should be used instead.
func NewParser(scanner *Scanner, ob ...Observer) (*Parser, error) {
return NewParserWithStorage(scanner, nil, ob...)
}
// NewParserWithStorage creates a new Parser. The scanner source must either
// be seekable or a storage must be provided.
func NewParserWithStorage(
scanner *Scanner,
storage storer.EncodedObjectStorer,
ob ...Observer,
) (*Parser, error) {
if !scanner.IsSeekable && storage == nil {
return nil, ErrNotSeekableSource
}
var deltas map[int64][]byte
if !scanner.IsSeekable {
deltas = make(map[int64][]byte)
}
return &Parser{
storage: storage,
scanner: scanner,
ob: ob,
count: 0,
cache: cache.NewBufferLRUDefault(),
deltas: deltas,
}, nil
}
func (p *Parser) forEachObserver(f func(o Observer) error) error {
for _, o := range p.ob {
if err := f(o); err != nil {
return err
}
}
return nil
}
func (p *Parser) onHeader(count uint32) error {
return p.forEachObserver(func(o Observer) error {
return o.OnHeader(count)
})
}
func (p *Parser) onInflatedObjectHeader(
t plumbing.ObjectType,
objSize int64,
pos int64,
) error {
return p.forEachObserver(func(o Observer) error {
return o.OnInflatedObjectHeader(t, objSize, pos)
})
}
func (p *Parser) onInflatedObjectContent(
h plumbing.Hash,
pos int64,
crc uint32,
content []byte,
) error {
return p.forEachObserver(func(o Observer) error {
return o.OnInflatedObjectContent(h, pos, crc, content)
})
}
func (p *Parser) onFooter(h plumbing.Hash) error {
return p.forEachObserver(func(o Observer) error {
return o.OnFooter(h)
})
}
// Parse start decoding phase of the packfile.
func (p *Parser) Parse() (plumbing.Hash, error) {
if err := p.init(); err != nil {
return plumbing.ZeroHash, err
}
if err := p.indexObjects(); err != nil {
return plumbing.ZeroHash, err
}
var err error
p.checksum, err = p.scanner.Checksum()
if err != nil && err != io.EOF {
return plumbing.ZeroHash, err
}
if err := p.resolveDeltas(); err != nil {
return plumbing.ZeroHash, err
}
if err := p.onFooter(p.checksum); err != nil {
return plumbing.ZeroHash, err
}
return p.checksum, nil
}
func (p *Parser) init() error {
_, c, err := p.scanner.Header()
if err != nil {
return err
}
if err := p.onHeader(c); err != nil {
return err
}
p.count = c
p.oiByHash = make(map[plumbing.Hash]*objectInfo, p.count)
p.oiByOffset = make(map[int64]*objectInfo, p.count)
p.oi = make([]*objectInfo, p.count)
return nil
}
type objectHeaderWriter func(typ plumbing.ObjectType, sz int64) error
type lazyObjectWriter interface {
// LazyWriter enables an object to be lazily written.
// It returns:
// - w: a writer to receive the object's content.
// - lwh: a func to write the object header.
// - err: any error from the initial writer creation process.
//
// Note that if the object header is not written BEFORE the writer
// is used, this will result in an invalid object.
LazyWriter() (w io.WriteCloser, lwh objectHeaderWriter, err error)
}
func (p *Parser) indexObjects() error {
buf := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(buf)
for i := uint32(0); i < p.count; i++ {
oh, err := p.scanner.NextObjectHeader()
if err != nil {
return err
}
delta := false
var ota *objectInfo
switch t := oh.Type; t {
case plumbing.OFSDeltaObject:
delta = true
parent, ok := p.oiByOffset[oh.OffsetReference]
if !ok {
return plumbing.ErrObjectNotFound
}
ota = newDeltaObject(oh.Offset, oh.Length, t, parent)
parent.Children = append(parent.Children, ota)
case plumbing.REFDeltaObject:
delta = true
parent, ok := p.oiByHash[oh.Reference]
if !ok {
// can't find referenced object in this pack file
// this must be a "thin" pack.
parent = &objectInfo{ //Placeholder parent
SHA1: oh.Reference,
ExternalRef: true, // mark as an external reference that must be resolved
Type: plumbing.AnyObject,
DiskType: plumbing.AnyObject,
}
p.oiByHash[oh.Reference] = parent
}
ota = newDeltaObject(oh.Offset, oh.Length, t, parent)
parent.Children = append(parent.Children, ota)
default:
ota = newBaseObject(oh.Offset, oh.Length, t)
}
hasher := plumbing.NewHasher(oh.Type, oh.Length)
writers := []io.Writer{hasher}
var obj *plumbing.MemoryObject
// Lazy writing is only available for non-delta objects.
if p.storage != nil && !delta {
// When a storage is set and supports lazy writing,
// use that instead of creating a memory object.
if low, ok := p.storage.(lazyObjectWriter); ok {
ow, lwh, err := low.LazyWriter()
if err != nil {
return err
}
if err = lwh(oh.Type, oh.Length); err != nil {
return err
}
defer ow.Close()
writers = append(writers, ow)
} else {
obj = new(plumbing.MemoryObject)
obj.SetSize(oh.Length)
obj.SetType(oh.Type)
writers = append(writers, obj)
}
}
if delta && !p.scanner.IsSeekable {
buf.Reset()
buf.Grow(int(oh.Length))
writers = append(writers, buf)
}
mw := io.MultiWriter(writers...)
_, crc, err := p.scanner.NextObject(mw)
if err != nil {
return err
}
// Non delta objects needs to be added into the storage. This
// is only required when lazy writing is not supported.
if obj != nil {
if _, err := p.storage.SetEncodedObject(obj); err != nil {
return err
}
}
ota.Crc32 = crc
ota.Length = oh.Length
if !delta {
sha1 := hasher.Sum()
// Move children of placeholder parent into actual parent, in case this
// was a non-external delta reference.
if placeholder, ok := p.oiByHash[sha1]; ok {
ota.Children = placeholder.Children
for _, c := range ota.Children {
c.Parent = ota
}
}
ota.SHA1 = sha1
p.oiByHash[ota.SHA1] = ota
}
if delta && !p.scanner.IsSeekable {
data := buf.Bytes()
p.deltas[oh.Offset] = make([]byte, len(data))
copy(p.deltas[oh.Offset], data)
}
p.oiByOffset[oh.Offset] = ota
p.oi[i] = ota
}
return nil
}
func (p *Parser) resolveDeltas() error {
buf := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(buf)
for _, obj := range p.oi {
buf.Reset()
buf.Grow(int(obj.Length))
err := p.get(obj, buf)
if err != nil {
return err
}
if err := p.onInflatedObjectHeader(obj.Type, obj.Length, obj.Offset); err != nil {
return err
}
if err := p.onInflatedObjectContent(obj.SHA1, obj.Offset, obj.Crc32, nil); err != nil {
return err
}
if !obj.IsDelta() && len(obj.Children) > 0 {
// Dealing with an io.ReaderAt object, means we can
// create it once and reuse across all children.
r := bytes.NewReader(buf.Bytes())
for _, child := range obj.Children {
// Even though we are discarding the output, we still need to read it to
// so that the scanner can advance to the next object, and the SHA1 can be
// calculated.
if err := p.resolveObject(io.Discard, child, r); err != nil {
return err
}
p.resolveExternalRef(child)
}
// Remove the delta from the cache.
if obj.DiskType.IsDelta() && !p.scanner.IsSeekable {
delete(p.deltas, obj.Offset)
}
}
}
return nil
}
func (p *Parser) resolveExternalRef(o *objectInfo) {
if ref, ok := p.oiByHash[o.SHA1]; ok && ref.ExternalRef {
p.oiByHash[o.SHA1] = o
o.Children = ref.Children
for _, c := range o.Children {
c.Parent = o
}
}
}
func (p *Parser) get(o *objectInfo, buf *bytes.Buffer) (err error) {
if !o.ExternalRef { // skip cache check for placeholder parents
b, ok := p.cache.Get(o.Offset)
if ok {
_, err := buf.Write(b)
return err
}
}
// If it's not on the cache and is not a delta we can try to find it in the
// storage, if there's one. External refs must enter here.
if p.storage != nil && !o.Type.IsDelta() {
var e plumbing.EncodedObject
e, err = p.storage.EncodedObject(plumbing.AnyObject, o.SHA1)
if err != nil {
return err
}
o.Type = e.Type()
var r io.ReadCloser
r, err = e.Reader()
if err != nil {
return err
}
defer ioutil.CheckClose(r, &err)
_, err = buf.ReadFrom(io.LimitReader(r, e.Size()))
return err
}
if o.ExternalRef {
// we were not able to resolve a ref in a thin pack
return ErrReferenceDeltaNotFound
}
if o.DiskType.IsDelta() {
b := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(b)
buf.Grow(int(o.Length))
err := p.get(o.Parent, b)
if err != nil {
return err
}
err = p.resolveObject(buf, o, bytes.NewReader(b.Bytes()))
if err != nil {
return err
}
} else {
err := p.readData(buf, o)
if err != nil {
return err
}
}
// If the scanner is seekable, caching this data into
// memory by offset seems wasteful.
// There is a trade-off to be considered here in terms
// of execution time vs memory consumption.
//
// TODO: improve seekable execution time, so that we can
// skip this cache.
if len(o.Children) > 0 {
data := make([]byte, buf.Len())
copy(data, buf.Bytes())
p.cache.Put(o.Offset, data)
}
return nil
}
// resolveObject resolves an object from base, using information
// provided by o.
//
// This call has the side-effect of changing field values
// from the object info o:
// - Type: OFSDeltaObject may become the target type (e.g. Blob).
// - Size: The size may be update with the target size.
// - Hash: Zero hashes will be calculated as part of the object
// resolution. Hence why this process can't be avoided even when w
// is an io.Discard.
//
// base must be an io.ReaderAt, which is a requirement from
// patchDeltaStream. The main reason being that reversing an
// delta object may lead to going backs and forths within base,
// which is not supported by io.Reader.
func (p *Parser) resolveObject(
w io.Writer,
o *objectInfo,
base io.ReaderAt,
) error {
if !o.DiskType.IsDelta() {
return nil
}
buf := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(buf)
err := p.readData(buf, o)
if err != nil {
return err
}
writers := []io.Writer{w}
var obj *plumbing.MemoryObject
var lwh objectHeaderWriter
if p.storage != nil {
if low, ok := p.storage.(lazyObjectWriter); ok {
ow, wh, err := low.LazyWriter()
if err != nil {
return err
}
lwh = wh
defer ow.Close()
writers = append(writers, ow)
} else {
obj = new(plumbing.MemoryObject)
ow, err := obj.Writer()
if err != nil {
return err
}
writers = append(writers, ow)
}
}
mw := io.MultiWriter(writers...)
err = applyPatchBase(o, base, buf, mw, lwh)
if err != nil {
return err
}
if obj != nil {
obj.SetType(o.Type)
obj.SetSize(o.Size()) // Size here is correct as it was populated by applyPatchBase.
if _, err := p.storage.SetEncodedObject(obj); err != nil {
return err
}
}
return err
}
func (p *Parser) readData(w io.Writer, o *objectInfo) error {
if !p.scanner.IsSeekable && o.DiskType.IsDelta() {
data, ok := p.deltas[o.Offset]
if !ok {
return ErrDeltaNotCached
}
_, err := w.Write(data)
return err
}
if _, err := p.scanner.SeekObjectHeader(o.Offset); err != nil {
return err
}
if _, _, err := p.scanner.NextObject(w); err != nil {
return err
}
return nil
}
// applyPatchBase applies the patch to target.
//
// Note that ota will be updated based on the description in resolveObject.
func applyPatchBase(ota *objectInfo, base io.ReaderAt, delta io.Reader, target io.Writer, wh objectHeaderWriter) error {
if target == nil {
return fmt.Errorf("cannot apply patch against nil target")
}
typ := ota.Type
if ota.SHA1 == plumbing.ZeroHash {
typ = ota.Parent.Type
}
sz, h, err := patchDeltaWriter(target, base, delta, typ, wh)
if err != nil {
return err
}
if ota.SHA1 == plumbing.ZeroHash {
ota.Type = typ
ota.Length = int64(sz)
ota.SHA1 = h
}
return nil
}
func getSHA1(t plumbing.ObjectType, data []byte) (plumbing.Hash, error) {
hasher := plumbing.NewHasher(t, int64(len(data)))
if _, err := hasher.Write(data); err != nil {
return plumbing.ZeroHash, err
}
return hasher.Sum(), nil
}
type objectInfo struct {
Offset int64
Length int64
Type plumbing.ObjectType
DiskType plumbing.ObjectType
ExternalRef bool // indicates this is an external reference in a thin pack file
Crc32 uint32
Parent *objectInfo
Children []*objectInfo
SHA1 plumbing.Hash
}
func newBaseObject(offset, length int64, t plumbing.ObjectType) *objectInfo {
return newDeltaObject(offset, length, t, nil)
}
func newDeltaObject(
offset, length int64,
t plumbing.ObjectType,
parent *objectInfo,
) *objectInfo {
obj := &objectInfo{
Offset: offset,
Length: length,
Type: t,
DiskType: t,
Crc32: 0,
Parent: parent,
}
return obj
}
func (o *objectInfo) IsDelta() bool {
return o.Type.IsDelta()
}
func (o *objectInfo) Size() int64 {
return o.Length
}
go-git-5.13.2/plumbing/format/packfile/parser_test.go 0000664 0000000 0000000 00000020422 14744245500 0022542 0 ustar 00root root 0000000 0000000 package packfile_test
import (
"io"
"os"
"testing"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-billy/v5/util"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/filesystem"
. "gopkg.in/check.v1"
)
type ParserSuite struct {
fixtures.Suite
}
var _ = Suite(&ParserSuite{})
func (s *ParserSuite) TestParserHashes(c *C) {
f := fixtures.Basic().One()
scanner := packfile.NewScanner(f.Packfile())
obs := new(testObserver)
parser, err := packfile.NewParser(scanner, obs)
c.Assert(err, IsNil)
ch, err := parser.Parse()
c.Assert(err, IsNil)
checksum := "a3fed42da1e8189a077c0e6846c040dcf73fc9dd"
c.Assert(ch.String(), Equals, checksum)
c.Assert(obs.checksum, Equals, checksum)
c.Assert(int(obs.count), Equals, int(31))
commit := plumbing.CommitObject
blob := plumbing.BlobObject
tree := plumbing.TreeObject
objs := []observerObject{
{"e8d3ffab552895c19b9fcf7aa264d277cde33881", commit, 254, 12, 0xaa07ba4b},
{"6ecf0ef2c2dffb796033e5a02219af86ec6584e5", commit, 245, 186, 0xf706df58},
{"918c48b83bd081e863dbe1b80f8998f058cd8294", commit, 242, 286, 0x12438846},
{"af2d6a6954d532f8ffb47615169c8fdf9d383a1a", commit, 242, 449, 0x2905a38c},
{"1669dce138d9b841a518c64b10914d88f5e488ea", commit, 333, 615, 0xd9429436},
{"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69", commit, 332, 838, 0xbecfde4e},
{"35e85108805c84807bc66a02d91535e1e24b38b9", commit, 244, 1063, 0x780e4b3e},
{"b8e471f58bcbca63b07bda20e428190409c2db47", commit, 243, 1230, 0xdc18344f},
{"b029517f6300c2da0f4b651b8642506cd6aaf45d", commit, 187, 1392, 0xcf4e4280},
{"32858aad3c383ed1ff0a0f9bdf231d54a00c9e88", blob, 189, 1524, 0x1f08118a},
{"d3ff53e0564a9f87d8e84b6e28e5060e517008aa", blob, 18, 1685, 0xafded7b8},
{"c192bd6a24ea1ab01d78686e417c8bdc7c3d197f", blob, 1072, 1713, 0xcc1428ed},
{"d5c0f4ab811897cadf03aec358ae60d21f91c50d", blob, 76110, 2351, 0x1631d22f},
{"880cd14280f4b9b6ed3986d6671f907d7cc2a198", blob, 2780, 78050, 0xbfff5850},
{"49c6bb89b17060d7b4deacb7b338fcc6ea2352a9", blob, 217848, 78882, 0xd108e1d8},
{"c8f1d8c61f9da76f4cb49fd86322b6e685dba956", blob, 706, 80725, 0x8e97ba25},
{"9a48f23120e880dfbe41f7c9b7b708e9ee62a492", blob, 11488, 80998, 0x7316ff70},
{"9dea2395f5403188298c1dabe8bdafe562c491e3", blob, 78, 84032, 0xdb4fce56},
{"dbd3641b371024f44d0e469a9c8f5457b0660de1", tree, 272, 84115, 0x901cce2c},
{"a8d315b2b1c615d43042c3a62402b8a54288cf5c", tree, 271, 84375, 0xec4552b0},
{"a39771a7651f97faf5c72e08224d857fc35133db", tree, 38, 84430, 0x847905bf},
{"5a877e6a906a2743ad6e45d99c1793642aaf8eda", tree, 75, 84479, 0x3689459a},
{"586af567d0bb5e771e49bdd9434f5e0fb76d25fa", tree, 38, 84559, 0xe67af94a},
{"cf4aa3b38974fb7d81f367c0830f7d78d65ab86b", tree, 34, 84608, 0xc2314a2e},
{"7e59600739c96546163833214c36459e324bad0a", blob, 9, 84653, 0xcd987848},
{"fb72698cab7617ac416264415f13224dfd7a165e", tree, 238, 84671, 0x8a853a6d},
{"4d081c50e250fa32ea8b1313cf8bb7c2ad7627fd", tree, 179, 84688, 0x70c6518},
{"eba74343e2f15d62adedfd8c883ee0262b5c8021", tree, 148, 84708, 0x4f4108e2},
{"c2d30fa8ef288618f65f6eed6e168e0d514886f4", tree, 110, 84725, 0xd6fe09e9},
{"8dcef98b1d52143e1e2dbc458ffe38f925786bf2", tree, 111, 84741, 0xf07a2804},
{"aa9b383c260e1d05fbbf6b30a02914555e20c725", tree, 73, 84760, 0x1d75d6be},
}
c.Assert(obs.objects, DeepEquals, objs)
}
func (s *ParserSuite) TestThinPack(c *C) {
fs := osfs.New(c.MkDir())
path, err := util.TempDir(fs, "", "")
c.Assert(err, IsNil)
// Initialize an empty repository
r, err := git.PlainInit(path, true)
c.Assert(err, IsNil)
// Try to parse a thin pack without having the required objects in the repo to
// see if the correct errors are returned
thinpack := fixtures.ByTag("thinpack").One()
scanner := packfile.NewScanner(thinpack.Packfile())
parser, err := packfile.NewParserWithStorage(scanner, r.Storer) // ParserWithStorage writes to the storer all parsed objects!
c.Assert(err, IsNil)
_, err = parser.Parse()
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
path, err = util.TempDir(fs, "", "")
c.Assert(err, IsNil)
// start over with a clean repo
r, err = git.PlainInit(path, true)
c.Assert(err, IsNil)
// Now unpack a base packfile into our empty repo:
f := fixtures.ByURL("https://github.com/spinnaker/spinnaker.git").One()
w, err := r.Storer.(storer.PackfileWriter).PackfileWriter()
c.Assert(err, IsNil)
_, err = io.Copy(w, f.Packfile())
c.Assert(err, IsNil)
w.Close()
// Check that the test object that will come with our thin pack is *not* in the repo
_, err = r.Storer.EncodedObject(plumbing.CommitObject, plumbing.NewHash(thinpack.Head))
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
// Now unpack the thin pack:
scanner = packfile.NewScanner(thinpack.Packfile())
parser, err = packfile.NewParserWithStorage(scanner, r.Storer) // ParserWithStorage writes to the storer all parsed objects!
c.Assert(err, IsNil)
h, err := parser.Parse()
c.Assert(err, IsNil)
c.Assert(h, Equals, plumbing.NewHash("1288734cbe0b95892e663221d94b95de1f5d7be8"))
// Check that our test object is now accessible
_, err = r.Storer.EncodedObject(plumbing.CommitObject, plumbing.NewHash(thinpack.Head))
c.Assert(err, IsNil)
}
func (s *ParserSuite) TestResolveExternalRefsInThinPack(c *C) {
extRefsThinPack := fixtures.ByTag("codecommit").One()
scanner := packfile.NewScanner(extRefsThinPack.Packfile())
obs := new(testObserver)
parser, err := packfile.NewParser(scanner, obs)
c.Assert(err, IsNil)
_, err = parser.Parse()
c.Assert(err, IsNil)
}
func (s *ParserSuite) TestResolveExternalRefs(c *C) {
extRefsThinPack := fixtures.ByTag("delta-before-base").One()
scanner := packfile.NewScanner(extRefsThinPack.Packfile())
obs := new(testObserver)
parser, err := packfile.NewParser(scanner, obs)
c.Assert(err, IsNil)
_, err = parser.Parse()
c.Assert(err, IsNil)
}
type observerObject struct {
hash string
otype plumbing.ObjectType
size int64
offset int64
crc uint32
}
type testObserver struct {
count uint32
checksum string
objects []observerObject
pos map[int64]int
}
func (t *testObserver) OnHeader(count uint32) error {
t.count = count
t.pos = make(map[int64]int, count)
return nil
}
func (t *testObserver) OnInflatedObjectHeader(otype plumbing.ObjectType, objSize int64, pos int64) error {
o := t.get(pos)
o.otype = otype
o.size = objSize
o.offset = pos
t.put(pos, o)
return nil
}
func (t *testObserver) OnInflatedObjectContent(h plumbing.Hash, pos int64, crc uint32, _ []byte) error {
o := t.get(pos)
o.hash = h.String()
o.crc = crc
t.put(pos, o)
return nil
}
func (t *testObserver) OnFooter(h plumbing.Hash) error {
t.checksum = h.String()
return nil
}
func (t *testObserver) get(pos int64) observerObject {
i, ok := t.pos[pos]
if ok {
return t.objects[i]
}
return observerObject{}
}
func (t *testObserver) put(pos int64, o observerObject) {
i, ok := t.pos[pos]
if ok {
t.objects[i] = o
return
}
t.pos[pos] = len(t.objects)
t.objects = append(t.objects, o)
}
func BenchmarkParse(b *testing.B) {
defer fixtures.Clean()
for _, f := range fixtures.ByTag("packfile") {
b.Run(f.URL, func(b *testing.B) {
for i := 0; i < b.N; i++ {
parser, err := packfile.NewParser(packfile.NewScanner(f.Packfile()))
if err != nil {
b.Fatal(err)
}
_, err = parser.Parse()
if err != nil {
b.Fatal(err)
}
}
})
}
}
func BenchmarkParseBasic(b *testing.B) {
defer fixtures.Clean()
f := fixtures.Basic().One()
for i := 0; i < b.N; i++ {
parser, err := packfile.NewParser(packfile.NewScanner(f.Packfile()))
if err != nil {
b.Fatal(err)
}
_, err = parser.Parse()
if err != nil {
b.Fatal(err)
}
}
}
func BenchmarkParser(b *testing.B) {
f := fixtures.Basic().One()
defer fixtures.Clean()
b.ResetTimer()
for n := 0; n < b.N; n++ {
b.StopTimer()
scanner := packfile.NewScanner(f.Packfile())
fs := osfs.New(os.TempDir())
storage := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
parser, err := packfile.NewParserWithStorage(scanner, storage)
if err != nil {
b.Error(err)
}
b.StartTimer()
_, err = parser.Parse()
b.StopTimer()
if err != nil {
b.Error(err)
}
}
}
go-git-5.13.2/plumbing/format/packfile/patch_delta.go 0000664 0000000 0000000 00000026712 14744245500 0022467 0 ustar 00root root 0000000 0000000 package packfile
import (
"bufio"
"bytes"
"errors"
"fmt"
"io"
"math"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-git/v5/utils/sync"
)
// See https://github.com/git/git/blob/49fa3dc76179e04b0833542fa52d0f287a4955ac/delta.h
// https://github.com/git/git/blob/c2c5f6b1e479f2c38e0e01345350620944e3527f/patch-delta.c,
// and https://github.com/tarruda/node-git-core/blob/master/src/js/delta.js
// for details about the delta format.
var (
ErrInvalidDelta = errors.New("invalid delta")
ErrDeltaCmd = errors.New("wrong delta command")
)
const (
payload = 0x7f // 0111 1111
continuation = 0x80 // 1000 0000
// maxPatchPreemptionSize defines what is the max size of bytes to be
// premptively made available for a patch operation.
maxPatchPreemptionSize uint = 65536
// minDeltaSize defines the smallest size for a delta.
minDeltaSize = 4
)
type offset struct {
mask byte
shift uint
}
var offsets = []offset{
{mask: 0x01, shift: 0},
{mask: 0x02, shift: 8},
{mask: 0x04, shift: 16},
{mask: 0x08, shift: 24},
}
var sizes = []offset{
{mask: 0x10, shift: 0},
{mask: 0x20, shift: 8},
{mask: 0x40, shift: 16},
}
// ApplyDelta writes to target the result of applying the modification deltas in delta to base.
func ApplyDelta(target, base plumbing.EncodedObject, delta []byte) (err error) {
r, err := base.Reader()
if err != nil {
return err
}
defer ioutil.CheckClose(r, &err)
w, err := target.Writer()
if err != nil {
return err
}
defer ioutil.CheckClose(w, &err)
buf := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(buf)
_, err = buf.ReadFrom(r)
if err != nil {
return err
}
src := buf.Bytes()
dst := sync.GetBytesBuffer()
defer sync.PutBytesBuffer(dst)
err = patchDelta(dst, src, delta)
if err != nil {
return err
}
target.SetSize(int64(dst.Len()))
b := sync.GetByteSlice()
_, err = io.CopyBuffer(w, dst, *b)
sync.PutByteSlice(b)
return err
}
// PatchDelta returns the result of applying the modification deltas in delta to src.
// An error will be returned if delta is corrupted (ErrInvalidDelta) or an action command
// is not copy from source or copy from delta (ErrDeltaCmd).
func PatchDelta(src, delta []byte) ([]byte, error) {
if len(src) == 0 || len(delta) < minDeltaSize {
return nil, ErrInvalidDelta
}
b := &bytes.Buffer{}
if err := patchDelta(b, src, delta); err != nil {
return nil, err
}
return b.Bytes(), nil
}
func ReaderFromDelta(base plumbing.EncodedObject, deltaRC io.Reader) (io.ReadCloser, error) {
deltaBuf := bufio.NewReaderSize(deltaRC, 1024)
srcSz, err := decodeLEB128ByteReader(deltaBuf)
if err != nil {
if err == io.EOF {
return nil, ErrInvalidDelta
}
return nil, err
}
if srcSz != uint(base.Size()) {
return nil, ErrInvalidDelta
}
targetSz, err := decodeLEB128ByteReader(deltaBuf)
if err != nil {
if err == io.EOF {
return nil, ErrInvalidDelta
}
return nil, err
}
remainingTargetSz := targetSz
dstRd, dstWr := io.Pipe()
go func() {
baseRd, err := base.Reader()
if err != nil {
_ = dstWr.CloseWithError(ErrInvalidDelta)
return
}
defer baseRd.Close()
baseBuf := bufio.NewReader(baseRd)
basePos := uint(0)
for {
cmd, err := deltaBuf.ReadByte()
if err == io.EOF {
_ = dstWr.CloseWithError(ErrInvalidDelta)
return
}
if err != nil {
_ = dstWr.CloseWithError(err)
return
}
switch {
case isCopyFromSrc(cmd):
offset, err := decodeOffsetByteReader(cmd, deltaBuf)
if err != nil {
_ = dstWr.CloseWithError(err)
return
}
sz, err := decodeSizeByteReader(cmd, deltaBuf)
if err != nil {
_ = dstWr.CloseWithError(err)
return
}
if invalidSize(sz, targetSz) ||
invalidOffsetSize(offset, sz, srcSz) {
_ = dstWr.Close()
return
}
discard := offset - basePos
if basePos > offset {
_ = baseRd.Close()
baseRd, err = base.Reader()
if err != nil {
_ = dstWr.CloseWithError(ErrInvalidDelta)
return
}
baseBuf.Reset(baseRd)
discard = offset
}
for discard > math.MaxInt32 {
n, err := baseBuf.Discard(math.MaxInt32)
if err != nil {
_ = dstWr.CloseWithError(err)
return
}
basePos += uint(n)
discard -= uint(n)
}
for discard > 0 {
n, err := baseBuf.Discard(int(discard))
if err != nil {
_ = dstWr.CloseWithError(err)
return
}
basePos += uint(n)
discard -= uint(n)
}
if _, err := io.Copy(dstWr, io.LimitReader(baseBuf, int64(sz))); err != nil {
_ = dstWr.CloseWithError(err)
return
}
remainingTargetSz -= sz
basePos += sz
case isCopyFromDelta(cmd):
sz := uint(cmd) // cmd is the size itself
if invalidSize(sz, targetSz) {
_ = dstWr.CloseWithError(ErrInvalidDelta)
return
}
if _, err := io.Copy(dstWr, io.LimitReader(deltaBuf, int64(sz))); err != nil {
_ = dstWr.CloseWithError(err)
return
}
remainingTargetSz -= sz
default:
_ = dstWr.CloseWithError(ErrDeltaCmd)
return
}
if remainingTargetSz <= 0 {
_ = dstWr.Close()
return
}
}
}()
return dstRd, nil
}
func patchDelta(dst *bytes.Buffer, src, delta []byte) error {
if len(delta) < minCopySize {
return ErrInvalidDelta
}
srcSz, delta := decodeLEB128(delta)
if srcSz != uint(len(src)) {
return ErrInvalidDelta
}
targetSz, delta := decodeLEB128(delta)
remainingTargetSz := targetSz
var cmd byte
growSz := min(targetSz, maxPatchPreemptionSize)
dst.Grow(int(growSz))
for {
if len(delta) == 0 {
return ErrInvalidDelta
}
cmd = delta[0]
delta = delta[1:]
switch {
case isCopyFromSrc(cmd):
var offset, sz uint
var err error
offset, delta, err = decodeOffset(cmd, delta)
if err != nil {
return err
}
sz, delta, err = decodeSize(cmd, delta)
if err != nil {
return err
}
if invalidSize(sz, targetSz) ||
invalidOffsetSize(offset, sz, srcSz) {
break
}
dst.Write(src[offset : offset+sz])
remainingTargetSz -= sz
case isCopyFromDelta(cmd):
sz := uint(cmd) // cmd is the size itself
if invalidSize(sz, targetSz) {
return ErrInvalidDelta
}
if uint(len(delta)) < sz {
return ErrInvalidDelta
}
dst.Write(delta[0:sz])
remainingTargetSz -= sz
delta = delta[sz:]
default:
return ErrDeltaCmd
}
if remainingTargetSz <= 0 {
break
}
}
return nil
}
func patchDeltaWriter(dst io.Writer, base io.ReaderAt, delta io.Reader,
typ plumbing.ObjectType, writeHeader objectHeaderWriter) (uint, plumbing.Hash, error) {
deltaBuf := bufio.NewReaderSize(delta, 1024)
srcSz, err := decodeLEB128ByteReader(deltaBuf)
if err != nil {
if err == io.EOF {
return 0, plumbing.ZeroHash, ErrInvalidDelta
}
return 0, plumbing.ZeroHash, err
}
if r, ok := base.(*bytes.Reader); ok && srcSz != uint(r.Size()) {
return 0, plumbing.ZeroHash, ErrInvalidDelta
}
targetSz, err := decodeLEB128ByteReader(deltaBuf)
if err != nil {
if err == io.EOF {
return 0, plumbing.ZeroHash, ErrInvalidDelta
}
return 0, plumbing.ZeroHash, err
}
// If header still needs to be written, caller will provide
// a LazyObjectWriterHeader. This seems to be the case when
// dealing with thin-packs.
if writeHeader != nil {
err = writeHeader(typ, int64(targetSz))
if err != nil {
return 0, plumbing.ZeroHash, fmt.Errorf("could not lazy write header: %w", err)
}
}
remainingTargetSz := targetSz
hasher := plumbing.NewHasher(typ, int64(targetSz))
mw := io.MultiWriter(dst, hasher)
bufp := sync.GetByteSlice()
defer sync.PutByteSlice(bufp)
sr := io.NewSectionReader(base, int64(0), int64(srcSz))
// Keep both the io.LimitedReader types, so we can reset N.
baselr := io.LimitReader(sr, 0).(*io.LimitedReader)
deltalr := io.LimitReader(deltaBuf, 0).(*io.LimitedReader)
for {
buf := *bufp
cmd, err := deltaBuf.ReadByte()
if err == io.EOF {
return 0, plumbing.ZeroHash, ErrInvalidDelta
}
if err != nil {
return 0, plumbing.ZeroHash, err
}
if isCopyFromSrc(cmd) {
offset, err := decodeOffsetByteReader(cmd, deltaBuf)
if err != nil {
return 0, plumbing.ZeroHash, err
}
sz, err := decodeSizeByteReader(cmd, deltaBuf)
if err != nil {
return 0, plumbing.ZeroHash, err
}
if invalidSize(sz, targetSz) ||
invalidOffsetSize(offset, sz, srcSz) {
return 0, plumbing.ZeroHash, err
}
if _, err := sr.Seek(int64(offset), io.SeekStart); err != nil {
return 0, plumbing.ZeroHash, err
}
baselr.N = int64(sz)
if _, err := io.CopyBuffer(mw, baselr, buf); err != nil {
return 0, plumbing.ZeroHash, err
}
remainingTargetSz -= sz
} else if isCopyFromDelta(cmd) {
sz := uint(cmd) // cmd is the size itself
if invalidSize(sz, targetSz) {
return 0, plumbing.ZeroHash, ErrInvalidDelta
}
deltalr.N = int64(sz)
if _, err := io.CopyBuffer(mw, deltalr, buf); err != nil {
return 0, plumbing.ZeroHash, err
}
remainingTargetSz -= sz
} else {
return 0, plumbing.ZeroHash, err
}
if remainingTargetSz <= 0 {
break
}
}
return targetSz, hasher.Sum(), nil
}
// Decodes a number encoded as an unsigned LEB128 at the start of some
// binary data and returns the decoded number and the rest of the
// stream.
//
// This must be called twice on the delta data buffer, first to get the
// expected source buffer size, and again to get the target buffer size.
func decodeLEB128(input []byte) (uint, []byte) {
if len(input) == 0 {
return 0, input
}
var num, sz uint
var b byte
for {
b = input[sz]
num |= (uint(b) & payload) << (sz * 7) // concats 7 bits chunks
sz++
if uint(b)&continuation == 0 || sz == uint(len(input)) {
break
}
}
return num, input[sz:]
}
func decodeLEB128ByteReader(input io.ByteReader) (uint, error) {
var num, sz uint
for {
b, err := input.ReadByte()
if err != nil {
return 0, err
}
num |= (uint(b) & payload) << (sz * 7) // concats 7 bits chunks
sz++
if uint(b)&continuation == 0 {
break
}
}
return num, nil
}
func isCopyFromSrc(cmd byte) bool {
return (cmd & continuation) != 0
}
func isCopyFromDelta(cmd byte) bool {
return (cmd&continuation) == 0 && cmd != 0
}
func decodeOffsetByteReader(cmd byte, delta io.ByteReader) (uint, error) {
var offset uint
for _, o := range offsets {
if (cmd & o.mask) != 0 {
next, err := delta.ReadByte()
if err != nil {
return 0, err
}
offset |= uint(next) << o.shift
}
}
return offset, nil
}
func decodeOffset(cmd byte, delta []byte) (uint, []byte, error) {
var offset uint
for _, o := range offsets {
if (cmd & o.mask) != 0 {
if len(delta) == 0 {
return 0, nil, ErrInvalidDelta
}
offset |= uint(delta[0]) << o.shift
delta = delta[1:]
}
}
return offset, delta, nil
}
func decodeSizeByteReader(cmd byte, delta io.ByteReader) (uint, error) {
var sz uint
for _, s := range sizes {
if (cmd & s.mask) != 0 {
next, err := delta.ReadByte()
if err != nil {
return 0, err
}
sz |= uint(next) << s.shift
}
}
if sz == 0 {
sz = maxCopySize
}
return sz, nil
}
func decodeSize(cmd byte, delta []byte) (uint, []byte, error) {
var sz uint
for _, s := range sizes {
if (cmd & s.mask) != 0 {
if len(delta) == 0 {
return 0, nil, ErrInvalidDelta
}
sz |= uint(delta[0]) << s.shift
delta = delta[1:]
}
}
if sz == 0 {
sz = maxCopySize
}
return sz, delta, nil
}
func invalidSize(sz, targetSz uint) bool {
return sz > targetSz
}
func invalidOffsetSize(offset, sz, srcSz uint) bool {
return sumOverflows(offset, sz) ||
offset+sz > srcSz
}
func sumOverflows(a, b uint) bool {
return a+b < a
}
go-git-5.13.2/plumbing/format/packfile/patch_delta_test.go 0000664 0000000 0000000 00000002545 14744245500 0023524 0 ustar 00root root 0000000 0000000 package packfile
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestDecodeLEB128(t *testing.T) {
t.Parallel()
tests := []struct {
name string
input []byte
want uint
wantRest []byte
}{
{
name: "single byte, small number",
input: []byte{0x01, 0xFF},
want: 1,
wantRest: []byte{0xFF},
},
{
name: "single byte, max value without continuation",
input: []byte{0x7F, 0xFF},
want: 127,
wantRest: []byte{0xFF},
},
{
name: "two bytes",
input: []byte{0x80, 0x01, 0xFF},
want: 128,
wantRest: []byte{0xFF},
},
{
name: "two bytes, larger number",
input: []byte{0xFF, 0x01, 0xFF},
want: 255,
wantRest: []byte{0xFF},
},
{
name: "three bytes",
input: []byte{0x80, 0x80, 0x01, 0xFF},
want: 16384,
wantRest: []byte{0xFF},
},
{
name: "empty remaining bytes",
input: []byte{0x01},
want: 1,
wantRest: []byte{},
},
{
name: "empty input",
input: []byte{},
want: 0,
wantRest: []byte{},
},
}
for _, tc := range tests {
tc := tc
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
gotNum, gotRest := decodeLEB128(tc.input)
assert.Equal(t, tc.want, gotNum, "decoded number mismatch")
assert.Equal(t, tc.wantRest, gotRest, "remaining bytes mismatch")
})
}
}
go-git-5.13.2/plumbing/format/packfile/scanner.go 0000664 0000000 0000000 00000025704 14744245500 0021650 0 ustar 00root root 0000000 0000000 package packfile
import (
"bufio"
"bytes"
"fmt"
"hash"
"hash/crc32"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/utils/binary"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-git/v5/utils/sync"
)
var (
// ErrEmptyPackfile is returned by ReadHeader when no data is found in the packfile
ErrEmptyPackfile = NewError("empty packfile")
// ErrBadSignature is returned by ReadHeader when the signature in the packfile is incorrect.
ErrBadSignature = NewError("malformed pack file signature")
// ErrUnsupportedVersion is returned by ReadHeader when the packfile version is
// different than VersionSupported.
ErrUnsupportedVersion = NewError("unsupported packfile version")
// ErrSeekNotSupported returned if seek is not support
ErrSeekNotSupported = NewError("not seek support")
)
// ObjectHeader contains the information related to the object, this information
// is collected from the previous bytes to the content of the object.
type ObjectHeader struct {
Type plumbing.ObjectType
Offset int64
Length int64
Reference plumbing.Hash
OffsetReference int64
}
type Scanner struct {
r *scannerReader
crc hash.Hash32
// pendingObject is used to detect if an object has been read, or still
// is waiting to be read
pendingObject *ObjectHeader
version, objects uint32
// lsSeekable says if this scanner can do Seek or not, to have a Scanner
// seekable a r implementing io.Seeker is required
IsSeekable bool
}
// NewScanner returns a new Scanner based on a reader, if the given reader
// implements io.ReadSeeker the Scanner will be also Seekable
func NewScanner(r io.Reader) *Scanner {
_, ok := r.(io.ReadSeeker)
crc := crc32.NewIEEE()
return &Scanner{
r: newScannerReader(r, crc),
crc: crc,
IsSeekable: ok,
}
}
func (s *Scanner) Reset(r io.Reader) {
_, ok := r.(io.ReadSeeker)
s.r.Reset(r)
s.crc.Reset()
s.IsSeekable = ok
s.pendingObject = nil
s.version = 0
s.objects = 0
}
// Header reads the whole packfile header (signature, version and object count).
// It returns the version and the object count and performs checks on the
// validity of the signature and the version fields.
func (s *Scanner) Header() (version, objects uint32, err error) {
if s.version != 0 {
return s.version, s.objects, nil
}
sig, err := s.readSignature()
if err != nil {
if err == io.EOF {
err = ErrEmptyPackfile
}
return
}
if !s.isValidSignature(sig) {
err = ErrBadSignature
return
}
version, err = s.readVersion()
s.version = version
if err != nil {
return
}
if !s.isSupportedVersion(version) {
err = ErrUnsupportedVersion.AddDetails("%d", version)
return
}
objects, err = s.readCount()
s.objects = objects
return
}
// readSignature reads a returns the signature field in the packfile.
func (s *Scanner) readSignature() ([]byte, error) {
var sig = make([]byte, 4)
if _, err := io.ReadFull(s.r, sig); err != nil {
return []byte{}, err
}
return sig, nil
}
// isValidSignature returns if sig is a valid packfile signature.
func (s *Scanner) isValidSignature(sig []byte) bool {
return bytes.Equal(sig, signature)
}
// readVersion reads and returns the version field of a packfile.
func (s *Scanner) readVersion() (uint32, error) {
return binary.ReadUint32(s.r)
}
// isSupportedVersion returns whether version v is supported by the parser.
// The current supported version is VersionSupported, defined above.
func (s *Scanner) isSupportedVersion(v uint32) bool {
return v == VersionSupported
}
// readCount reads and returns the count of objects field of a packfile.
func (s *Scanner) readCount() (uint32, error) {
return binary.ReadUint32(s.r)
}
// SeekObjectHeader seeks to specified offset and returns the ObjectHeader
// for the next object in the reader
func (s *Scanner) SeekObjectHeader(offset int64) (*ObjectHeader, error) {
// if seeking we assume that you are not interested in the header
if s.version == 0 {
s.version = VersionSupported
}
if _, err := s.r.Seek(offset, io.SeekStart); err != nil {
return nil, err
}
h, err := s.nextObjectHeader()
if err != nil {
return nil, err
}
h.Offset = offset
return h, nil
}
// NextObjectHeader returns the ObjectHeader for the next object in the reader
func (s *Scanner) NextObjectHeader() (*ObjectHeader, error) {
if err := s.doPending(); err != nil {
return nil, err
}
offset, err := s.r.Seek(0, io.SeekCurrent)
if err != nil {
return nil, err
}
h, err := s.nextObjectHeader()
if err != nil {
return nil, err
}
h.Offset = offset
return h, nil
}
// nextObjectHeader returns the ObjectHeader for the next object in the reader
// without the Offset field
func (s *Scanner) nextObjectHeader() (*ObjectHeader, error) {
s.r.Flush()
s.crc.Reset()
h := &ObjectHeader{}
s.pendingObject = h
var err error
h.Offset, err = s.r.Seek(0, io.SeekCurrent)
if err != nil {
return nil, err
}
h.Type, h.Length, err = s.readObjectTypeAndLength()
if err != nil {
return nil, err
}
switch h.Type {
case plumbing.OFSDeltaObject:
no, err := binary.ReadVariableWidthInt(s.r)
if err != nil {
return nil, err
}
h.OffsetReference = h.Offset - no
case plumbing.REFDeltaObject:
var err error
h.Reference, err = binary.ReadHash(s.r)
if err != nil {
return nil, err
}
}
return h, nil
}
func (s *Scanner) doPending() error {
if s.version == 0 {
var err error
s.version, s.objects, err = s.Header()
if err != nil {
return err
}
}
return s.discardObjectIfNeeded()
}
func (s *Scanner) discardObjectIfNeeded() error {
if s.pendingObject == nil {
return nil
}
h := s.pendingObject
n, _, err := s.NextObject(io.Discard)
if err != nil {
return err
}
if n != h.Length {
return fmt.Errorf(
"error discarding object, discarded %d, expected %d",
n, h.Length,
)
}
return nil
}
// ReadObjectTypeAndLength reads and returns the object type and the
// length field from an object entry in a packfile.
func (s *Scanner) readObjectTypeAndLength() (plumbing.ObjectType, int64, error) {
t, c, err := s.readType()
if err != nil {
return t, 0, err
}
l, err := s.readLength(c)
return t, l, err
}
func (s *Scanner) readType() (plumbing.ObjectType, byte, error) {
var c byte
var err error
if c, err = s.r.ReadByte(); err != nil {
return plumbing.ObjectType(0), 0, err
}
typ := parseType(c)
return typ, c, nil
}
func parseType(b byte) plumbing.ObjectType {
return plumbing.ObjectType((b & maskType) >> firstLengthBits)
}
// the length is codified in the last 4 bits of the first byte and in
// the last 7 bits of subsequent bytes. Last byte has a 0 MSB.
func (s *Scanner) readLength(first byte) (int64, error) {
length := int64(first & maskFirstLength)
c := first
shift := firstLengthBits
var err error
for c&maskContinue > 0 {
if c, err = s.r.ReadByte(); err != nil {
return 0, err
}
length += int64(c&maskLength) << shift
shift += lengthBits
}
return length, nil
}
// NextObject writes the content of the next object into the reader, returns
// the number of bytes written, the CRC32 of the content and an error, if any
func (s *Scanner) NextObject(w io.Writer) (written int64, crc32 uint32, err error) {
s.pendingObject = nil
written, err = s.copyObject(w)
s.r.Flush()
crc32 = s.crc.Sum32()
s.crc.Reset()
return
}
// ReadObject returns a reader for the object content and an error
func (s *Scanner) ReadObject() (io.ReadCloser, error) {
s.pendingObject = nil
zr, err := sync.GetZlibReader(s.r)
if err != nil {
return nil, fmt.Errorf("zlib reset error: %s", err)
}
return ioutil.NewReadCloserWithCloser(zr.Reader, func() error {
sync.PutZlibReader(zr)
return nil
}), nil
}
// ReadRegularObject reads and write a non-deltified object
// from it zlib stream in an object entry in the packfile.
func (s *Scanner) copyObject(w io.Writer) (n int64, err error) {
zr, err := sync.GetZlibReader(s.r)
defer sync.PutZlibReader(zr)
if err != nil {
return 0, fmt.Errorf("zlib reset error: %s", err)
}
defer ioutil.CheckClose(zr.Reader, &err)
buf := sync.GetByteSlice()
n, err = io.CopyBuffer(w, zr.Reader, *buf)
sync.PutByteSlice(buf)
return
}
// SeekFromStart sets a new offset from start, returns the old position before
// the change.
func (s *Scanner) SeekFromStart(offset int64) (previous int64, err error) {
// if seeking we assume that you are not interested in the header
if s.version == 0 {
s.version = VersionSupported
}
previous, err = s.r.Seek(0, io.SeekCurrent)
if err != nil {
return -1, err
}
_, err = s.r.Seek(offset, io.SeekStart)
return previous, err
}
// Checksum returns the checksum of the packfile
func (s *Scanner) Checksum() (plumbing.Hash, error) {
err := s.discardObjectIfNeeded()
if err != nil {
return plumbing.ZeroHash, err
}
return binary.ReadHash(s.r)
}
// Close reads the reader until io.EOF
func (s *Scanner) Close() error {
buf := sync.GetByteSlice()
_, err := io.CopyBuffer(io.Discard, s.r, *buf)
sync.PutByteSlice(buf)
return err
}
// Flush is a no-op (deprecated)
func (s *Scanner) Flush() error {
return nil
}
// scannerReader has the following characteristics:
// - Provides an io.SeekReader impl for bufio.Reader, when the underlying
// reader supports it.
// - Keeps track of the current read position, for when the underlying reader
// isn't an io.SeekReader, but we still want to know the current offset.
// - Writes to the hash writer what it reads, with the aid of a smaller buffer.
// The buffer helps avoid a performance penalty for performing small writes
// to the crc32 hash writer.
type scannerReader struct {
reader io.Reader
crc io.Writer
rbuf *bufio.Reader
wbuf *bufio.Writer
offset int64
}
func newScannerReader(r io.Reader, h io.Writer) *scannerReader {
sr := &scannerReader{
rbuf: bufio.NewReader(nil),
wbuf: bufio.NewWriterSize(nil, 64),
crc: h,
}
sr.Reset(r)
return sr
}
func (r *scannerReader) Reset(reader io.Reader) {
r.reader = reader
r.rbuf.Reset(r.reader)
r.wbuf.Reset(r.crc)
r.offset = 0
if seeker, ok := r.reader.(io.ReadSeeker); ok {
r.offset, _ = seeker.Seek(0, io.SeekCurrent)
}
}
func (r *scannerReader) Read(p []byte) (n int, err error) {
n, err = r.rbuf.Read(p)
r.offset += int64(n)
if _, err := r.wbuf.Write(p[:n]); err != nil {
return n, err
}
return
}
func (r *scannerReader) ReadByte() (b byte, err error) {
b, err = r.rbuf.ReadByte()
if err == nil {
r.offset++
return b, r.wbuf.WriteByte(b)
}
return
}
func (r *scannerReader) Flush() error {
return r.wbuf.Flush()
}
// Seek seeks to a location. If the underlying reader is not an io.ReadSeeker,
// then only whence=io.SeekCurrent is supported, any other operation fails.
func (r *scannerReader) Seek(offset int64, whence int) (int64, error) {
var err error
if seeker, ok := r.reader.(io.ReadSeeker); !ok {
if whence != io.SeekCurrent || offset != 0 {
return -1, ErrSeekNotSupported
}
} else {
if whence == io.SeekCurrent && offset == 0 {
return r.offset, nil
}
r.offset, err = seeker.Seek(offset, whence)
r.rbuf.Reset(r.reader)
}
return r.offset, err
}
go-git-5.13.2/plumbing/format/packfile/scanner_test.go 0000664 0000000 0000000 00000023451 14744245500 0022704 0 ustar 00root root 0000000 0000000 package packfile
import (
"bytes"
"io"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/hash"
. "gopkg.in/check.v1"
)
type ScannerSuite struct {
fixtures.Suite
}
var _ = Suite(&ScannerSuite{})
func (s *ScannerSuite) TestHeader(c *C) {
r := fixtures.Basic().One().Packfile()
p := NewScanner(r)
version, objects, err := p.Header()
c.Assert(err, IsNil)
c.Assert(version, Equals, VersionSupported)
c.Assert(objects, Equals, uint32(31))
}
func (s *ScannerSuite) TestNextObjectHeaderWithoutHeader(c *C) {
r := fixtures.Basic().One().Packfile()
p := NewScanner(r)
h, err := p.NextObjectHeader()
c.Assert(err, IsNil)
c.Assert(h, DeepEquals, &expectedHeadersOFS[0])
version, objects, err := p.Header()
c.Assert(err, IsNil)
c.Assert(version, Equals, VersionSupported)
c.Assert(objects, Equals, uint32(31))
}
func (s *ScannerSuite) TestNextObjectHeaderREFDelta(c *C) {
s.testNextObjectHeader(c, "ref-delta", expectedHeadersREF, expectedCRCREF)
}
func (s *ScannerSuite) TestNextObjectHeaderOFSDelta(c *C) {
s.testNextObjectHeader(c, "ofs-delta", expectedHeadersOFS, expectedCRCOFS)
}
func (s *ScannerSuite) testNextObjectHeader(c *C, tag string,
expected []ObjectHeader, expectedCRC []uint32) {
r := fixtures.Basic().ByTag(tag).One().Packfile()
p := NewScanner(r)
_, objects, err := p.Header()
c.Assert(err, IsNil)
for i := 0; i < int(objects); i++ {
h, err := p.NextObjectHeader()
c.Assert(err, IsNil)
c.Assert(*h, DeepEquals, expected[i])
buf := bytes.NewBuffer(nil)
n, crcFromScanner, err := p.NextObject(buf)
c.Assert(err, IsNil)
c.Assert(n, Equals, h.Length)
c.Assert(crcFromScanner, Equals, expectedCRC[i])
}
n, err := p.Checksum()
c.Assert(err, IsNil)
c.Assert(n, HasLen, hash.Size)
}
func (s *ScannerSuite) TestNextObjectHeaderWithOutReadObject(c *C) {
f := fixtures.Basic().ByTag("ref-delta").One()
r := f.Packfile()
p := NewScanner(r)
_, objects, err := p.Header()
c.Assert(err, IsNil)
for i := 0; i < int(objects); i++ {
h, _ := p.NextObjectHeader()
c.Assert(err, IsNil)
c.Assert(*h, DeepEquals, expectedHeadersREF[i])
}
err = p.discardObjectIfNeeded()
c.Assert(err, IsNil)
n, err := p.Checksum()
c.Assert(err, IsNil)
c.Assert(n.String(), Equals, f.PackfileHash)
}
func (s *ScannerSuite) TestNextObjectHeaderWithOutReadObjectNonSeekable(c *C) {
f := fixtures.Basic().ByTag("ref-delta").One()
r := io.MultiReader(f.Packfile())
p := NewScanner(r)
_, objects, err := p.Header()
c.Assert(err, IsNil)
for i := 0; i < int(objects); i++ {
h, _ := p.NextObjectHeader()
c.Assert(err, IsNil)
c.Assert(*h, DeepEquals, expectedHeadersREF[i])
}
err = p.discardObjectIfNeeded()
c.Assert(err, IsNil)
n, err := p.Checksum()
c.Assert(err, IsNil)
c.Assert(n.String(), Equals, f.PackfileHash)
}
func (s *ScannerSuite) TestSeekObjectHeader(c *C) {
r := fixtures.Basic().One().Packfile()
p := NewScanner(r)
h, err := p.SeekObjectHeader(expectedHeadersOFS[4].Offset)
c.Assert(err, IsNil)
c.Assert(h, DeepEquals, &expectedHeadersOFS[4])
}
func (s *ScannerSuite) TestSeekObjectHeaderNonSeekable(c *C) {
r := io.MultiReader(fixtures.Basic().One().Packfile())
p := NewScanner(r)
_, err := p.SeekObjectHeader(expectedHeadersOFS[4].Offset)
c.Assert(err, Equals, ErrSeekNotSupported)
}
func (s *ScannerSuite) TestReaderReset(c *C) {
r := fixtures.Basic().One().Packfile()
p := NewScanner(r)
version, objects, err := p.Header()
c.Assert(err, IsNil)
c.Assert(version, Equals, VersionSupported)
c.Assert(objects, Equals, uint32(31))
h, err := p.SeekObjectHeader(expectedHeadersOFS[0].Offset)
c.Assert(err, IsNil)
c.Assert(h, DeepEquals, &expectedHeadersOFS[0])
p.Reset(r)
c.Assert(p.pendingObject, IsNil)
c.Assert(p.version, Equals, uint32(0))
c.Assert(p.objects, Equals, uint32(0))
c.Assert(p.r.reader, Equals, r)
c.Assert(p.r.offset > expectedHeadersOFS[0].Offset, Equals, true)
p.Reset(bytes.NewReader(nil))
c.Assert(p.r.offset, Equals, int64(0))
}
func (s *ScannerSuite) TestReaderResetSeeks(c *C) {
r := fixtures.Basic().One().Packfile()
// seekable
p := NewScanner(r)
c.Assert(p.IsSeekable, Equals, true)
h, err := p.SeekObjectHeader(expectedHeadersOFS[0].Offset)
c.Assert(err, IsNil)
c.Assert(h, DeepEquals, &expectedHeadersOFS[0])
// reset with seekable
p.Reset(r)
c.Assert(p.IsSeekable, Equals, true)
h, err = p.SeekObjectHeader(expectedHeadersOFS[1].Offset)
c.Assert(err, IsNil)
c.Assert(h, DeepEquals, &expectedHeadersOFS[1])
// reset with non-seekable
f := fixtures.Basic().ByTag("ref-delta").One()
p.Reset(io.MultiReader(f.Packfile()))
c.Assert(p.IsSeekable, Equals, false)
_, err = p.SeekObjectHeader(expectedHeadersOFS[4].Offset)
c.Assert(err, Equals, ErrSeekNotSupported)
}
var expectedHeadersOFS = []ObjectHeader{
{Type: plumbing.CommitObject, Offset: 12, Length: 254},
{Type: plumbing.OFSDeltaObject, Offset: 186, Length: 93, OffsetReference: 12},
{Type: plumbing.CommitObject, Offset: 286, Length: 242},
{Type: plumbing.CommitObject, Offset: 449, Length: 242},
{Type: plumbing.CommitObject, Offset: 615, Length: 333},
{Type: plumbing.CommitObject, Offset: 838, Length: 332},
{Type: plumbing.CommitObject, Offset: 1063, Length: 244},
{Type: plumbing.CommitObject, Offset: 1230, Length: 243},
{Type: plumbing.CommitObject, Offset: 1392, Length: 187},
{Type: plumbing.BlobObject, Offset: 1524, Length: 189},
{Type: plumbing.BlobObject, Offset: 1685, Length: 18},
{Type: plumbing.BlobObject, Offset: 1713, Length: 1072},
{Type: plumbing.BlobObject, Offset: 2351, Length: 76110},
{Type: plumbing.BlobObject, Offset: 78050, Length: 2780},
{Type: plumbing.BlobObject, Offset: 78882, Length: 217848},
{Type: plumbing.BlobObject, Offset: 80725, Length: 706},
{Type: plumbing.BlobObject, Offset: 80998, Length: 11488},
{Type: plumbing.BlobObject, Offset: 84032, Length: 78},
{Type: plumbing.TreeObject, Offset: 84115, Length: 272},
{Type: plumbing.OFSDeltaObject, Offset: 84375, Length: 43, OffsetReference: 84115},
{Type: plumbing.TreeObject, Offset: 84430, Length: 38},
{Type: plumbing.TreeObject, Offset: 84479, Length: 75},
{Type: plumbing.TreeObject, Offset: 84559, Length: 38},
{Type: plumbing.TreeObject, Offset: 84608, Length: 34},
{Type: plumbing.BlobObject, Offset: 84653, Length: 9},
{Type: plumbing.OFSDeltaObject, Offset: 84671, Length: 6, OffsetReference: 84375},
{Type: plumbing.OFSDeltaObject, Offset: 84688, Length: 9, OffsetReference: 84375},
{Type: plumbing.OFSDeltaObject, Offset: 84708, Length: 6, OffsetReference: 84375},
{Type: plumbing.OFSDeltaObject, Offset: 84725, Length: 5, OffsetReference: 84115},
{Type: plumbing.OFSDeltaObject, Offset: 84741, Length: 8, OffsetReference: 84375},
{Type: plumbing.OFSDeltaObject, Offset: 84760, Length: 4, OffsetReference: 84741},
}
var expectedCRCOFS = []uint32{
0xaa07ba4b,
0xf706df58,
0x12438846,
0x2905a38c,
0xd9429436,
0xbecfde4e,
0x780e4b3e,
0xdc18344f,
0xcf4e4280,
0x1f08118a,
0xafded7b8,
0xcc1428ed,
0x1631d22f,
0xbfff5850,
0xd108e1d8,
0x8e97ba25,
0x7316ff70,
0xdb4fce56,
0x901cce2c,
0xec4552b0,
0x847905bf,
0x3689459a,
0xe67af94a,
0xc2314a2e,
0xcd987848,
0x8a853a6d,
0x70c6518,
0x4f4108e2,
0xd6fe09e9,
0xf07a2804,
0x1d75d6be,
}
var expectedHeadersREF = []ObjectHeader{
{Type: plumbing.CommitObject, Offset: 12, Length: 254},
{Type: plumbing.REFDeltaObject, Offset: 186, Length: 93,
Reference: plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881")},
{Type: plumbing.CommitObject, Offset: 304, Length: 242},
{Type: plumbing.CommitObject, Offset: 467, Length: 242},
{Type: plumbing.CommitObject, Offset: 633, Length: 333},
{Type: plumbing.CommitObject, Offset: 856, Length: 332},
{Type: plumbing.CommitObject, Offset: 1081, Length: 243},
{Type: plumbing.CommitObject, Offset: 1243, Length: 244},
{Type: plumbing.CommitObject, Offset: 1410, Length: 187},
{Type: plumbing.BlobObject, Offset: 1542, Length: 189},
{Type: plumbing.BlobObject, Offset: 1703, Length: 18},
{Type: plumbing.BlobObject, Offset: 1731, Length: 1072},
{Type: plumbing.BlobObject, Offset: 2369, Length: 76110},
{Type: plumbing.TreeObject, Offset: 78068, Length: 38},
{Type: plumbing.BlobObject, Offset: 78117, Length: 2780},
{Type: plumbing.TreeObject, Offset: 79049, Length: 75},
{Type: plumbing.BlobObject, Offset: 79129, Length: 217848},
{Type: plumbing.BlobObject, Offset: 80972, Length: 706},
{Type: plumbing.TreeObject, Offset: 81265, Length: 38},
{Type: plumbing.BlobObject, Offset: 81314, Length: 11488},
{Type: plumbing.TreeObject, Offset: 84752, Length: 34},
{Type: plumbing.BlobObject, Offset: 84797, Length: 78},
{Type: plumbing.TreeObject, Offset: 84880, Length: 271},
{Type: plumbing.REFDeltaObject, Offset: 85141, Length: 6,
Reference: plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")},
{Type: plumbing.REFDeltaObject, Offset: 85176, Length: 37,
Reference: plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e")},
{Type: plumbing.BlobObject, Offset: 85244, Length: 9},
{Type: plumbing.REFDeltaObject, Offset: 85262, Length: 9,
Reference: plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e")},
{Type: plumbing.REFDeltaObject, Offset: 85300, Length: 6,
Reference: plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e")},
{Type: plumbing.TreeObject, Offset: 85335, Length: 110},
{Type: plumbing.REFDeltaObject, Offset: 85448, Length: 8,
Reference: plumbing.NewHash("eba74343e2f15d62adedfd8c883ee0262b5c8021")},
{Type: plumbing.TreeObject, Offset: 85485, Length: 73},
}
var expectedCRCREF = []uint32{
0xaa07ba4b,
0xfb4725a4,
0x12438846,
0x2905a38c,
0xd9429436,
0xbecfde4e,
0xdc18344f,
0x780e4b3e,
0xcf4e4280,
0x1f08118a,
0xafded7b8,
0xcc1428ed,
0x1631d22f,
0x847905bf,
0x3e20f31d,
0x3689459a,
0xd108e1d8,
0x71143d4a,
0xe67af94a,
0x739fb89f,
0xc2314a2e,
0x87864926,
0x415d752f,
0xf72fb182,
0x3ffa37d4,
0xcd987848,
0x2f20ac8f,
0xf2f0575,
0x7d8726e1,
0x740bf39,
0x26af4735,
}
go-git-5.13.2/plumbing/format/pktline/ 0000775 0000000 0000000 00000000000 14744245500 0017550 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/format/pktline/encoder.go 0000664 0000000 0000000 00000006177 14744245500 0021531 0 ustar 00root root 0000000 0000000 // Package pktline implements reading payloads form pkt-lines and encoding
// pkt-lines from payloads.
package pktline
import (
"bytes"
"errors"
"fmt"
"io"
"github.com/go-git/go-git/v5/utils/trace"
)
// An Encoder writes pkt-lines to an output stream.
type Encoder struct {
w io.Writer
}
const (
// MaxPayloadSize is the maximum payload size of a pkt-line in bytes.
MaxPayloadSize = 65516
// For compatibility with canonical Git implementation, accept longer pkt-lines
OversizePayloadMax = 65520
)
var (
// FlushPkt are the contents of a flush-pkt pkt-line.
FlushPkt = []byte{'0', '0', '0', '0'}
// Flush is the payload to use with the Encode method to encode a flush-pkt.
Flush = []byte{}
// FlushString is the payload to use with the EncodeString method to encode a flush-pkt.
FlushString = ""
// ErrPayloadTooLong is returned by the Encode methods when any of the
// provided payloads is bigger than MaxPayloadSize.
ErrPayloadTooLong = errors.New("payload is too long")
)
// NewEncoder returns a new encoder that writes to w.
func NewEncoder(w io.Writer) *Encoder {
return &Encoder{
w: w,
}
}
// Flush encodes a flush-pkt to the output stream.
func (e *Encoder) Flush() error {
defer trace.Packet.Print("packet: > 0000")
_, err := e.w.Write(FlushPkt)
return err
}
// Encode encodes a pkt-line with the payload specified and write it to
// the output stream. If several payloads are specified, each of them
// will get streamed in their own pkt-lines.
func (e *Encoder) Encode(payloads ...[]byte) error {
for _, p := range payloads {
if err := e.encodeLine(p); err != nil {
return err
}
}
return nil
}
func (e *Encoder) encodeLine(p []byte) error {
if len(p) > MaxPayloadSize {
return ErrPayloadTooLong
}
if bytes.Equal(p, Flush) {
return e.Flush()
}
n := len(p) + 4
defer trace.Packet.Printf("packet: > %04x %s", n, p)
if _, err := e.w.Write(asciiHex16(n)); err != nil {
return err
}
_, err := e.w.Write(p)
return err
}
// Returns the hexadecimal ascii representation of the 16 less
// significant bits of n. The length of the returned slice will always
// be 4. Example: if n is 1234 (0x4d2), the return value will be
// []byte{'0', '4', 'd', '2'}.
func asciiHex16(n int) []byte {
var ret [4]byte
ret[0] = byteToASCIIHex(byte(n & 0xf000 >> 12))
ret[1] = byteToASCIIHex(byte(n & 0x0f00 >> 8))
ret[2] = byteToASCIIHex(byte(n & 0x00f0 >> 4))
ret[3] = byteToASCIIHex(byte(n & 0x000f))
return ret[:]
}
// turns a byte into its hexadecimal ascii representation. Example:
// from 11 (0xb) to 'b'.
func byteToASCIIHex(n byte) byte {
if n < 10 {
return '0' + n
}
return 'a' - 10 + n
}
// EncodeString works similarly as Encode but payloads are specified as strings.
func (e *Encoder) EncodeString(payloads ...string) error {
for _, p := range payloads {
if err := e.Encode([]byte(p)); err != nil {
return err
}
}
return nil
}
// Encodef encodes a single pkt-line with the payload formatted as
// the format specifier. The rest of the arguments will be used in
// the format string.
func (e *Encoder) Encodef(format string, a ...interface{}) error {
return e.EncodeString(
fmt.Sprintf(format, a...),
)
}
go-git-5.13.2/plumbing/format/pktline/encoder_test.go 0000664 0000000 0000000 00000010750 14744245500 0022560 0 ustar 00root root 0000000 0000000 package pktline_test
import (
"bytes"
"strings"
"testing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type SuiteEncoder struct{}
var _ = Suite(&SuiteEncoder{})
func (s *SuiteEncoder) TestFlush(c *C) {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.Flush()
c.Assert(err, IsNil)
obtained := buf.Bytes()
c.Assert(obtained, DeepEquals, pktline.FlushPkt)
}
func (s *SuiteEncoder) TestEncode(c *C) {
for i, test := range [...]struct {
input [][]byte
expected []byte
}{
{
input: [][]byte{
[]byte("hello\n"),
},
expected: []byte("000ahello\n"),
}, {
input: [][]byte{
[]byte("hello\n"),
pktline.Flush,
},
expected: []byte("000ahello\n0000"),
}, {
input: [][]byte{
[]byte("hello\n"),
[]byte("world!\n"),
[]byte("foo"),
},
expected: []byte("000ahello\n000bworld!\n0007foo"),
}, {
input: [][]byte{
[]byte("hello\n"),
pktline.Flush,
[]byte("world!\n"),
[]byte("foo"),
pktline.Flush,
},
expected: []byte("000ahello\n0000000bworld!\n0007foo0000"),
}, {
input: [][]byte{
[]byte(strings.Repeat("a", pktline.MaxPayloadSize)),
},
expected: []byte(
"fff0" + strings.Repeat("a", pktline.MaxPayloadSize)),
}, {
input: [][]byte{
[]byte(strings.Repeat("a", pktline.MaxPayloadSize)),
[]byte(strings.Repeat("b", pktline.MaxPayloadSize)),
},
expected: []byte(
"fff0" + strings.Repeat("a", pktline.MaxPayloadSize) +
"fff0" + strings.Repeat("b", pktline.MaxPayloadSize)),
},
} {
comment := Commentf("input %d = %v\n", i, test.input)
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.Encode(test.input...)
c.Assert(err, IsNil, comment)
c.Assert(buf.Bytes(), DeepEquals, test.expected, comment)
}
}
func (s *SuiteEncoder) TestEncodeErrPayloadTooLong(c *C) {
for i, input := range [...][][]byte{
{
[]byte(strings.Repeat("a", pktline.MaxPayloadSize+1)),
},
{
[]byte("hello world!"),
[]byte(strings.Repeat("a", pktline.MaxPayloadSize+1)),
},
{
[]byte("hello world!"),
[]byte(strings.Repeat("a", pktline.MaxPayloadSize+1)),
[]byte("foo"),
},
} {
comment := Commentf("input %d = %v\n", i, input)
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.Encode(input...)
c.Assert(err, Equals, pktline.ErrPayloadTooLong, comment)
}
}
func (s *SuiteEncoder) TestEncodeStrings(c *C) {
for i, test := range [...]struct {
input []string
expected []byte
}{
{
input: []string{
"hello\n",
},
expected: []byte("000ahello\n"),
}, {
input: []string{
"hello\n",
pktline.FlushString,
},
expected: []byte("000ahello\n0000"),
}, {
input: []string{
"hello\n",
"world!\n",
"foo",
},
expected: []byte("000ahello\n000bworld!\n0007foo"),
}, {
input: []string{
"hello\n",
pktline.FlushString,
"world!\n",
"foo",
pktline.FlushString,
},
expected: []byte("000ahello\n0000000bworld!\n0007foo0000"),
}, {
input: []string{
strings.Repeat("a", pktline.MaxPayloadSize),
},
expected: []byte(
"fff0" + strings.Repeat("a", pktline.MaxPayloadSize)),
}, {
input: []string{
strings.Repeat("a", pktline.MaxPayloadSize),
strings.Repeat("b", pktline.MaxPayloadSize),
},
expected: []byte(
"fff0" + strings.Repeat("a", pktline.MaxPayloadSize) +
"fff0" + strings.Repeat("b", pktline.MaxPayloadSize)),
},
} {
comment := Commentf("input %d = %v\n", i, test.input)
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(test.input...)
c.Assert(err, IsNil, comment)
c.Assert(buf.Bytes(), DeepEquals, test.expected, comment)
}
}
func (s *SuiteEncoder) TestEncodeStringErrPayloadTooLong(c *C) {
for i, input := range [...][]string{
{
strings.Repeat("a", pktline.MaxPayloadSize+1),
},
{
"hello world!",
strings.Repeat("a", pktline.MaxPayloadSize+1),
},
{
"hello world!",
strings.Repeat("a", pktline.MaxPayloadSize+1),
"foo",
},
} {
comment := Commentf("input %d = %v\n", i, input)
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(input...)
c.Assert(err, Equals, pktline.ErrPayloadTooLong, comment)
}
}
func (s *SuiteEncoder) TestEncodef(c *C) {
format := " %s %d\n"
str := "foo"
d := 42
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.Encodef(format, str, d)
c.Assert(err, IsNil)
expected := []byte("000c foo 42\n")
c.Assert(buf.Bytes(), DeepEquals, expected)
}
go-git-5.13.2/plumbing/format/pktline/error.go 0000664 0000000 0000000 00000002110 14744245500 0021222 0 ustar 00root root 0000000 0000000 package pktline
import (
"bytes"
"errors"
"io"
"strings"
)
var (
// ErrInvalidErrorLine is returned by Decode when the packet line is not an
// error line.
ErrInvalidErrorLine = errors.New("expected an error-line")
errPrefix = []byte("ERR ")
)
// ErrorLine is a packet line that contains an error message.
// Once this packet is sent by client or server, the data transfer process is
// terminated.
// See https://git-scm.com/docs/pack-protocol#_pkt_line_format
type ErrorLine struct {
Text string
}
// Error implements the error interface.
func (e *ErrorLine) Error() string {
return e.Text
}
// Encode encodes the ErrorLine into a packet line.
func (e *ErrorLine) Encode(w io.Writer) error {
p := NewEncoder(w)
return p.Encodef("%s%s\n", string(errPrefix), e.Text)
}
// Decode decodes a packet line into an ErrorLine.
func (e *ErrorLine) Decode(r io.Reader) error {
s := NewScanner(r)
if !s.Scan() {
return s.Err()
}
line := s.Bytes()
if !bytes.HasPrefix(line, errPrefix) {
return ErrInvalidErrorLine
}
e.Text = strings.TrimSpace(string(line[4:]))
return nil
}
go-git-5.13.2/plumbing/format/pktline/error_test.go 0000664 0000000 0000000 00000002425 14744245500 0022272 0 ustar 00root root 0000000 0000000 package pktline
import (
"bytes"
"errors"
"io"
"testing"
)
func TestEncodeEmptyErrorLine(t *testing.T) {
e := &ErrorLine{}
err := e.Encode(io.Discard)
if err != nil {
t.Fatal(err)
}
}
func TestEncodeErrorLine(t *testing.T) {
e := &ErrorLine{
Text: "something",
}
var buf bytes.Buffer
err := e.Encode(&buf)
if err != nil {
t.Fatal(err)
}
if buf.String() != "0012ERR something\n" {
t.Fatalf("unexpected encoded error line: %q", buf.String())
}
}
func TestDecodeEmptyErrorLine(t *testing.T) {
var buf bytes.Buffer
e := &ErrorLine{}
err := e.Decode(&buf)
if err != nil {
t.Fatal(err)
}
if e.Text != "" {
t.Fatalf("unexpected error line: %q", e.Text)
}
}
func TestDecodeErrorLine(t *testing.T) {
var buf bytes.Buffer
buf.WriteString("000eERR foobar")
var e *ErrorLine
err := e.Decode(&buf)
if !errors.As(err, &e) {
t.Fatalf("expected error line, got: %T: %v", err, err)
}
if e.Text != "foobar" {
t.Fatalf("unexpected error line: %q", e.Text)
}
}
func TestDecodeErrorLineLn(t *testing.T) {
var buf bytes.Buffer
buf.WriteString("000fERR foobar\n")
var e *ErrorLine
err := e.Decode(&buf)
if !errors.As(err, &e) {
t.Fatalf("expected error line, got: %T: %v", err, err)
}
if e.Text != "foobar" {
t.Fatalf("unexpected error line: %q", e.Text)
}
}
go-git-5.13.2/plumbing/format/pktline/scanner.go 0000664 0000000 0000000 00000007201 14744245500 0021530 0 ustar 00root root 0000000 0000000 package pktline
import (
"bytes"
"errors"
"io"
"strings"
"github.com/go-git/go-git/v5/utils/trace"
)
const (
lenSize = 4
)
// ErrInvalidPktLen is returned by Err() when an invalid pkt-len is found.
var ErrInvalidPktLen = errors.New("invalid pkt-len found")
// Scanner provides a convenient interface for reading the payloads of a
// series of pkt-lines. It takes an io.Reader providing the source,
// which then can be tokenized through repeated calls to the Scan
// method.
//
// After each Scan call, the Bytes method will return the payload of the
// corresponding pkt-line on a shared buffer, which will be 65516 bytes
// or smaller. Flush pkt-lines are represented by empty byte slices.
//
// Scanning stops at EOF or the first I/O error.
type Scanner struct {
r io.Reader // The reader provided by the client
err error // Sticky error
payload []byte // Last pkt-payload
len [lenSize]byte // Last pkt-len
}
// NewScanner returns a new Scanner to read from r.
func NewScanner(r io.Reader) *Scanner {
return &Scanner{
r: r,
}
}
// Err returns the first error encountered by the Scanner.
func (s *Scanner) Err() error {
return s.err
}
// Scan advances the Scanner to the next pkt-line, whose payload will
// then be available through the Bytes method. Scanning stops at EOF
// or the first I/O error. After Scan returns false, the Err method
// will return any error that occurred during scanning, except that if
// it was io.EOF, Err will return nil.
func (s *Scanner) Scan() bool {
var l int
l, s.err = s.readPayloadLen()
if s.err == io.EOF {
s.err = nil
return false
}
if s.err != nil {
return false
}
if cap(s.payload) < l {
s.payload = make([]byte, 0, l)
}
if _, s.err = io.ReadFull(s.r, s.payload[:l]); s.err != nil {
return false
}
s.payload = s.payload[:l]
trace.Packet.Printf("packet: < %04x %s", l, s.payload)
if bytes.HasPrefix(s.payload, errPrefix) {
s.err = &ErrorLine{
Text: strings.TrimSpace(string(s.payload[4:])),
}
return false
}
return true
}
// Bytes returns the most recent payload generated by a call to Scan.
// The underlying array may point to data that will be overwritten by a
// subsequent call to Scan. It does no allocation.
func (s *Scanner) Bytes() []byte {
return s.payload
}
// Method readPayloadLen returns the payload length by reading the
// pkt-len and subtracting the pkt-len size.
func (s *Scanner) readPayloadLen() (int, error) {
if _, err := io.ReadFull(s.r, s.len[:]); err != nil {
if err == io.ErrUnexpectedEOF {
return 0, ErrInvalidPktLen
}
return 0, err
}
n, err := hexDecode(s.len)
if err != nil {
return 0, err
}
switch {
case n == 0:
return 0, nil
case n <= lenSize:
return 0, ErrInvalidPktLen
case n > OversizePayloadMax+lenSize:
return 0, ErrInvalidPktLen
default:
return n - lenSize, nil
}
}
// Turns the hexadecimal representation of a number in a byte slice into
// a number. This function substitute strconv.ParseUint(string(buf), 16,
// 16) and/or hex.Decode, to avoid generating new strings, thus helping the
// GC.
func hexDecode(buf [lenSize]byte) (int, error) {
var ret int
for i := 0; i < lenSize; i++ {
n, err := asciiHexToByte(buf[i])
if err != nil {
return 0, ErrInvalidPktLen
}
ret = 16*ret + int(n)
}
return ret, nil
}
// turns the hexadecimal ascii representation of a byte into its
// numerical value. Example: from 'b' to 11 (0xb).
func asciiHexToByte(b byte) (byte, error) {
switch {
case b >= '0' && b <= '9':
return b - '0', nil
case b >= 'a' && b <= 'f':
return b - 'a' + 10, nil
case b >= 'A' && b <= 'F':
return b - 'A' + 10, nil
default:
return 0, ErrInvalidPktLen
}
}
go-git-5.13.2/plumbing/format/pktline/scanner_test.go 0000664 0000000 0000000 00000012606 14744245500 0022574 0 ustar 00root root 0000000 0000000 package pktline_test
import (
"bytes"
"errors"
"fmt"
"io"
"strings"
"testing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
"github.com/stretchr/testify/assert"
. "gopkg.in/check.v1"
)
type SuiteScanner struct{}
var _ = Suite(&SuiteScanner{})
func (s *SuiteScanner) TestInvalid(c *C) {
for _, test := range [...]string{
"0001", "0002", "0003", "0004",
"0001asdfsadf", "0004foo",
"fff5", "ffff",
"FFF5", "FFFF",
"gorka",
"0", "003",
" 5a", "5 a", "5 \n",
"-001", "-000",
} {
r := strings.NewReader(test)
sc := pktline.NewScanner(r)
_ = sc.Scan()
c.Assert(sc.Err(), ErrorMatches, pktline.ErrInvalidPktLen.Error(),
Commentf("data = %q", test))
}
}
func (s *SuiteScanner) TestDecodeOversizePktLines(c *C) {
for _, test := range [...]string{
"fff1" + strings.Repeat("a", 0xfff1),
"fff2" + strings.Repeat("a", 0xfff2),
"fff3" + strings.Repeat("a", 0xfff3),
"fff4" + strings.Repeat("a", 0xfff4),
} {
r := strings.NewReader(test)
sc := pktline.NewScanner(r)
_ = sc.Scan()
c.Assert(sc.Err(), IsNil)
}
}
func TestValidPktSizes(t *testing.T) {
for _, test := range [...]string{
"01fe" + strings.Repeat("a", 0x01fe-4),
"01FE" + strings.Repeat("a", 0x01fe-4),
"00b5" + strings.Repeat("a", 0x00b5-4),
"00B5" + strings.Repeat("a", 0x00b5-4),
} {
r := strings.NewReader(test)
sc := pktline.NewScanner(r)
hasPayload := sc.Scan()
obtained := sc.Bytes()
assert.True(t, hasPayload)
assert.NoError(t, sc.Err())
assert.Equal(t, []byte(test[4:]), obtained)
}
}
func (s *SuiteScanner) TestEmptyReader(c *C) {
r := strings.NewReader("")
sc := pktline.NewScanner(r)
hasPayload := sc.Scan()
c.Assert(hasPayload, Equals, false)
c.Assert(sc.Err(), Equals, nil)
}
func (s *SuiteScanner) TestFlush(c *C) {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.Flush()
c.Assert(err, IsNil)
sc := pktline.NewScanner(&buf)
c.Assert(sc.Scan(), Equals, true)
payload := sc.Bytes()
c.Assert(len(payload), Equals, 0)
}
func (s *SuiteScanner) TestPktLineTooShort(c *C) {
r := strings.NewReader("010cfoobar")
sc := pktline.NewScanner(r)
c.Assert(sc.Scan(), Equals, false)
c.Assert(sc.Err(), ErrorMatches, "unexpected EOF")
}
func (s *SuiteScanner) TestScanAndPayload(c *C) {
for _, test := range [...]string{
"a",
"a\n",
strings.Repeat("a", 100),
strings.Repeat("a", 100) + "\n",
strings.Repeat("\x00", 100),
strings.Repeat("\x00", 100) + "\n",
strings.Repeat("a", pktline.MaxPayloadSize),
strings.Repeat("a", pktline.MaxPayloadSize-1) + "\n",
} {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(test)
c.Assert(err, IsNil,
Commentf("input len=%x, contents=%.10q\n", len(test), test))
sc := pktline.NewScanner(&buf)
c.Assert(sc.Scan(), Equals, true,
Commentf("test = %.20q...", test))
obtained := sc.Bytes()
c.Assert(obtained, DeepEquals, []byte(test),
Commentf("in = %.20q out = %.20q", test, string(obtained)))
}
}
func (s *SuiteScanner) TestSkip(c *C) {
for _, test := range [...]struct {
input []string
n int
expected []byte
}{
{
input: []string{
"first",
"second",
"third"},
n: 1,
expected: []byte("second"),
},
{
input: []string{
"first",
"second",
"third"},
n: 2,
expected: []byte("third"),
},
} {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(test.input...)
c.Assert(err, IsNil)
sc := pktline.NewScanner(&buf)
for i := 0; i < test.n; i++ {
c.Assert(sc.Scan(), Equals, true,
Commentf("scan error = %s", sc.Err()))
}
c.Assert(sc.Scan(), Equals, true,
Commentf("scan error = %s", sc.Err()))
obtained := sc.Bytes()
c.Assert(obtained, DeepEquals, test.expected,
Commentf("\nin = %.20q\nout = %.20q\nexp = %.20q",
test.input, obtained, test.expected))
}
}
func (s *SuiteScanner) TestEOF(c *C) {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString("first", "second")
c.Assert(err, IsNil)
sc := pktline.NewScanner(&buf)
for sc.Scan() {
}
c.Assert(sc.Err(), IsNil)
}
type mockReader struct{}
func (r *mockReader) Read([]byte) (int, error) { return 0, errors.New("foo") }
func (s *SuiteScanner) TestInternalReadError(c *C) {
sc := pktline.NewScanner(&mockReader{})
c.Assert(sc.Scan(), Equals, false)
c.Assert(sc.Err(), ErrorMatches, "foo")
}
// A section are several non flush-pkt lines followed by a flush-pkt, which
// how the git protocol sends long messages.
func (s *SuiteScanner) TestReadSomeSections(c *C) {
nSections := 2
nLines := 4
data := sectionsExample(c, nSections, nLines)
sc := pktline.NewScanner(data)
sectionCounter := 0
lineCounter := 0
for sc.Scan() {
if len(sc.Bytes()) == 0 {
sectionCounter++
}
lineCounter++
}
c.Assert(sc.Err(), IsNil)
c.Assert(sectionCounter, Equals, nSections)
c.Assert(lineCounter, Equals, (1+nLines)*nSections)
}
// returns nSection sections, each of them with nLines pkt-lines (not
// counting the flush-pkt:
//
// 0009 0.0\n
// 0009 0.1\n
// ...
// 0000
// and so on
func sectionsExample(c *C, nSections, nLines int) io.Reader {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
for section := 0; section < nSections; section++ {
ss := []string{}
for line := 0; line < nLines; line++ {
line := fmt.Sprintf(" %d.%d\n", section, line)
ss = append(ss, line)
}
err := e.EncodeString(ss...)
c.Assert(err, IsNil)
err = e.Flush()
c.Assert(err, IsNil)
}
return &buf
}
go-git-5.13.2/plumbing/hash.go 0000664 0000000 0000000 00000003256 14744245500 0016072 0 ustar 00root root 0000000 0000000 package plumbing
import (
"bytes"
"encoding/hex"
"sort"
"strconv"
"github.com/go-git/go-git/v5/plumbing/hash"
)
// Hash SHA1 hashed content
type Hash [hash.Size]byte
// ZeroHash is Hash with value zero
var ZeroHash Hash
// ComputeHash compute the hash for a given ObjectType and content
func ComputeHash(t ObjectType, content []byte) Hash {
h := NewHasher(t, int64(len(content)))
h.Write(content)
return h.Sum()
}
// NewHash return a new Hash from a hexadecimal hash representation
func NewHash(s string) Hash {
b, _ := hex.DecodeString(s)
var h Hash
copy(h[:], b)
return h
}
func (h Hash) IsZero() bool {
var empty Hash
return h == empty
}
func (h Hash) String() string {
return hex.EncodeToString(h[:])
}
type Hasher struct {
hash.Hash
}
func NewHasher(t ObjectType, size int64) Hasher {
h := Hasher{hash.New(hash.CryptoType)}
h.Write(t.Bytes())
h.Write([]byte(" "))
h.Write([]byte(strconv.FormatInt(size, 10)))
h.Write([]byte{0})
return h
}
func (h Hasher) Sum() (hash Hash) {
copy(hash[:], h.Hash.Sum(nil))
return
}
// HashesSort sorts a slice of Hashes in increasing order.
func HashesSort(a []Hash) {
sort.Sort(HashSlice(a))
}
// HashSlice attaches the methods of sort.Interface to []Hash, sorting in
// increasing order.
type HashSlice []Hash
func (p HashSlice) Len() int { return len(p) }
func (p HashSlice) Less(i, j int) bool { return bytes.Compare(p[i][:], p[j][:]) < 0 }
func (p HashSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
// IsHash returns true if the given string is a valid hash.
func IsHash(s string) bool {
switch len(s) {
case hash.HexSize:
_, err := hex.DecodeString(s)
return err == nil
default:
return false
}
}
go-git-5.13.2/plumbing/hash/ 0000775 0000000 0000000 00000000000 14744245500 0015535 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/hash/hash.go 0000664 0000000 0000000 00000002551 14744245500 0017012 0 ustar 00root root 0000000 0000000 // package hash provides a way for managing the
// underlying hash implementations used across go-git.
package hash
import (
"crypto"
"fmt"
"hash"
"github.com/pjbgf/sha1cd"
)
// algos is a map of hash algorithms.
var algos = map[crypto.Hash]func() hash.Hash{}
func init() {
reset()
}
// reset resets the default algos value. Can be used after running tests
// that registers new algorithms to avoid side effects.
func reset() {
algos[crypto.SHA1] = sha1cd.New
algos[crypto.SHA256] = crypto.SHA256.New
}
// RegisterHash allows for the hash algorithm used to be overridden.
// This ensures the hash selection for go-git must be explicit, when
// overriding the default value.
func RegisterHash(h crypto.Hash, f func() hash.Hash) error {
if f == nil {
return fmt.Errorf("cannot register hash: f is nil")
}
switch h {
case crypto.SHA1:
algos[h] = f
case crypto.SHA256:
algos[h] = f
default:
return fmt.Errorf("unsupported hash function: %v", h)
}
return nil
}
// Hash is the same as hash.Hash. This allows consumers
// to not having to import this package alongside "hash".
type Hash interface {
hash.Hash
}
// New returns a new Hash for the given hash function.
// It panics if the hash function is not registered.
func New(h crypto.Hash) Hash {
hh, ok := algos[h]
if !ok {
panic(fmt.Sprintf("hash algorithm not registered: %v", h))
}
return hh()
}
go-git-5.13.2/plumbing/hash/hash_sha1.go 0000664 0000000 0000000 00000000504 14744245500 0017722 0 ustar 00root root 0000000 0000000 //go:build !sha256
// +build !sha256
package hash
import "crypto"
const (
// CryptoType defines what hash algorithm is being used.
CryptoType = crypto.SHA1
// Size defines the amount of bytes the hash yields.
Size = 20
// HexSize defines the strings size of the hash when represented in hexadecimal.
HexSize = 40
)
go-git-5.13.2/plumbing/hash/hash_sha256.go 0000664 0000000 0000000 00000000504 14744245500 0020076 0 ustar 00root root 0000000 0000000 //go:build sha256
// +build sha256
package hash
import "crypto"
const (
// CryptoType defines what hash algorithm is being used.
CryptoType = crypto.SHA256
// Size defines the amount of bytes the hash yields.
Size = 32
// HexSize defines the strings size of the hash when represented in hexadecimal.
HexSize = 64
)
go-git-5.13.2/plumbing/hash/hash_test.go 0000664 0000000 0000000 00000010744 14744245500 0020054 0 ustar 00root root 0000000 0000000 package hash
import (
"crypto"
"crypto/sha1"
"crypto/sha512"
"encoding/hex"
"hash"
"strings"
"testing"
)
func TestRegisterHash(t *testing.T) {
// Reset default hash to avoid side effects.
defer reset()
tests := []struct {
name string
hash crypto.Hash
new func() hash.Hash
wantErr string
}{
{
name: "sha1",
hash: crypto.SHA1,
new: sha1.New,
},
{
name: "sha1",
hash: crypto.SHA1,
wantErr: "cannot register hash: f is nil",
},
{
name: "sha512",
hash: crypto.SHA512,
new: sha512.New,
wantErr: "unsupported hash function",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := RegisterHash(tt.hash, tt.new)
if tt.wantErr == "" && err != nil {
t.Errorf("unexpected error: %v", err)
} else if tt.wantErr != "" && err == nil {
t.Errorf("expected error: %v got: nil", tt.wantErr)
} else if err != nil && !strings.Contains(err.Error(), tt.wantErr) {
t.Errorf("expected error: %v got: %v", tt.wantErr, err)
}
})
}
}
// Verifies that the SHA1 implementation used is collision-resistant
// by default.
func TestSha1Collision(t *testing.T) {
defer reset()
tests := []struct {
name string
content string
hash string
before func()
}{
{
name: "sha-mbles-1: with collision detection",
content: "99040d047fe81780012000ff4b65792069732070617274206f66206120636f6c6c6973696f6e212049742773206120747261702179c61af0afcc054515d9274e7307624b1dc7fb23988bb8de8b575dba7b9eab31c1674b6d974378a827732ff5851c76a2e60772b5a47ce1eac40bb993c12d8c70e24a4f8d5fcdedc1b32c9cf19e31af2429759d42e4dfdb31719f587623ee552939b6dcdc459fca53553b70f87ede30a247ea3af6c759a2f20b320d760db64ff479084fd3ccb3cdd48362d96a9c430617caff6c36c637e53fde28417f626fec54ed7943a46e5f5730f2bb38fb1df6e0090010d00e24ad78bf92641993608e8d158a789f34c46fe1e6027f35a4cbfb827076c50eca0e8b7cca69bb2c2b790259f9bf9570dd8d4437a3115faff7c3cac09ad25266055c27104755178eaeff825a2caa2acfb5de64ce7641dc59a541a9fc9c756756e2e23dc713c8c24c9790aa6b0e38a7f55f14452a1ca2850ddd9562fd9a18ad42496aa97008f74672f68ef461eb88b09933d626b4f918749cc027fddd6c425fc4216835d0134d15285bab2cb784a4f7cbb4fb514d4bf0f6237cf00a9e9f132b9a066e6fd17f6c42987478586ff651af96747fb426b9872b9a88e4063f59bb334cc00650f83a80c42751b71974d300fc2819a2e8f1e32c1b51cb18e6bfc4db9baef675d4aaf5b1574a047f8f6dd2ec153a93412293974d928f88ced9363cfef97ce2e742bf34c96b8ef3875676fea5cca8e5f7dea0bab2413d4de00ee71ee01f162bdb6d1eafd925e6aebaae6a354ef17cf205a404fbdb12fc454d41fdd95cf2459664a2ad032d1da60a73264075d7f1e0d6c1403ae7a0d861df3fe5707188dd5e07d1589b9f8b6630553f8fc352b3e0c27da80bddba4c64020d",
hash: "4f3d9be4a472c4dae83c6314aa6c36a064c1fd14",
},
{
name: "sha-mbles-1: with default SHA1",
content: "99040d047fe81780012000ff4b65792069732070617274206f66206120636f6c6c6973696f6e212049742773206120747261702179c61af0afcc054515d9274e7307624b1dc7fb23988bb8de8b575dba7b9eab31c1674b6d974378a827732ff5851c76a2e60772b5a47ce1eac40bb993c12d8c70e24a4f8d5fcdedc1b32c9cf19e31af2429759d42e4dfdb31719f587623ee552939b6dcdc459fca53553b70f87ede30a247ea3af6c759a2f20b320d760db64ff479084fd3ccb3cdd48362d96a9c430617caff6c36c637e53fde28417f626fec54ed7943a46e5f5730f2bb38fb1df6e0090010d00e24ad78bf92641993608e8d158a789f34c46fe1e6027f35a4cbfb827076c50eca0e8b7cca69bb2c2b790259f9bf9570dd8d4437a3115faff7c3cac09ad25266055c27104755178eaeff825a2caa2acfb5de64ce7641dc59a541a9fc9c756756e2e23dc713c8c24c9790aa6b0e38a7f55f14452a1ca2850ddd9562fd9a18ad42496aa97008f74672f68ef461eb88b09933d626b4f918749cc027fddd6c425fc4216835d0134d15285bab2cb784a4f7cbb4fb514d4bf0f6237cf00a9e9f132b9a066e6fd17f6c42987478586ff651af96747fb426b9872b9a88e4063f59bb334cc00650f83a80c42751b71974d300fc2819a2e8f1e32c1b51cb18e6bfc4db9baef675d4aaf5b1574a047f8f6dd2ec153a93412293974d928f88ced9363cfef97ce2e742bf34c96b8ef3875676fea5cca8e5f7dea0bab2413d4de00ee71ee01f162bdb6d1eafd925e6aebaae6a354ef17cf205a404fbdb12fc454d41fdd95cf2459664a2ad032d1da60a73264075d7f1e0d6c1403ae7a0d861df3fe5707188dd5e07d1589b9f8b6630553f8fc352b3e0c27da80bddba4c64020d",
hash: "8ac60ba76f1999a1ab70223f225aefdc78d4ddc0",
before: func() {
RegisterHash(crypto.SHA1, sha1.New)
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if tt.before != nil {
tt.before()
}
h := New(crypto.SHA1)
data, err := hex.DecodeString(tt.content)
if err != nil {
t.Fatal(err)
}
h.Reset()
h.Write(data)
sum := h.Sum(nil)
got := hex.EncodeToString(sum)
if tt.hash != got {
t.Errorf("\n got: %q\nwanted: %q", got, tt.hash)
}
})
}
}
go-git-5.13.2/plumbing/hash_test.go 0000664 0000000 0000000 00000003162 14744245500 0017125 0 ustar 00root root 0000000 0000000 package plumbing
import (
"testing"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type HashSuite struct{}
var _ = Suite(&HashSuite{})
func (s *HashSuite) TestComputeHash(c *C) {
hash := ComputeHash(BlobObject, []byte(""))
c.Assert(hash.String(), Equals, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391")
hash = ComputeHash(BlobObject, []byte("Hello, World!\n"))
c.Assert(hash.String(), Equals, "8ab686eafeb1f44702738c8b0f24f2567c36da6d")
}
func (s *HashSuite) TestNewHash(c *C) {
hash := ComputeHash(BlobObject, []byte("Hello, World!\n"))
c.Assert(hash, Equals, NewHash(hash.String()))
}
func (s *HashSuite) TestIsZero(c *C) {
hash := NewHash("foo")
c.Assert(hash.IsZero(), Equals, true)
hash = NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")
c.Assert(hash.IsZero(), Equals, false)
}
func (s *HashSuite) TestNewHasher(c *C) {
content := "hasher test sample"
hasher := NewHasher(BlobObject, int64(len(content)))
hasher.Write([]byte(content))
c.Assert(hasher.Sum().String(), Equals, "dc42c3cc80028d0ec61f0a6b24cadd1c195c4dfc")
}
func (s *HashSuite) TestHashesSort(c *C) {
i := []Hash{
NewHash("2222222222222222222222222222222222222222"),
NewHash("1111111111111111111111111111111111111111"),
}
HashesSort(i)
c.Assert(i[0], Equals, NewHash("1111111111111111111111111111111111111111"))
c.Assert(i[1], Equals, NewHash("2222222222222222222222222222222222222222"))
}
func (s *HashSuite) TestIsHash(c *C) {
c.Assert(IsHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d"), Equals, true)
c.Assert(IsHash("foo"), Equals, false)
c.Assert(IsHash("zab686eafeb1f44702738c8b0f24f2567c36da6d"), Equals, false)
}
go-git-5.13.2/plumbing/memory.go 0000664 0000000 0000000 00000003626 14744245500 0016460 0 ustar 00root root 0000000 0000000 package plumbing
import (
"bytes"
"io"
)
// MemoryObject on memory Object implementation
type MemoryObject struct {
t ObjectType
h Hash
cont []byte
sz int64
}
// Hash returns the object Hash, the hash is calculated on-the-fly the first
// time it's called, in all subsequent calls the same Hash is returned even
// if the type or the content have changed. The Hash is only generated if the
// size of the content is exactly the object size.
func (o *MemoryObject) Hash() Hash {
if o.h == ZeroHash && int64(len(o.cont)) == o.sz {
o.h = ComputeHash(o.t, o.cont)
}
return o.h
}
// Type returns the ObjectType
func (o *MemoryObject) Type() ObjectType { return o.t }
// SetType sets the ObjectType
func (o *MemoryObject) SetType(t ObjectType) { o.t = t }
// Size returns the size of the object
func (o *MemoryObject) Size() int64 { return o.sz }
// SetSize set the object size, a content of the given size should be written
// afterwards
func (o *MemoryObject) SetSize(s int64) { o.sz = s }
// Reader returns an io.ReadCloser used to read the object's content.
//
// For a MemoryObject, this reader is seekable.
func (o *MemoryObject) Reader() (io.ReadCloser, error) {
return nopCloser{bytes.NewReader(o.cont)}, nil
}
// Writer returns a ObjectWriter used to write the object's content.
func (o *MemoryObject) Writer() (io.WriteCloser, error) {
return o, nil
}
func (o *MemoryObject) Write(p []byte) (n int, err error) {
o.cont = append(o.cont, p...)
o.sz = int64(len(o.cont))
return len(p), nil
}
// Close releases any resources consumed by the object when it is acting as a
// ObjectWriter.
func (o *MemoryObject) Close() error { return nil }
// nopCloser exposes the extra methods of bytes.Reader while nopping Close().
//
// This allows clients to attempt seeking in a cached Blob's Reader.
type nopCloser struct {
*bytes.Reader
}
// Close does nothing.
func (nc nopCloser) Close() error { return nil }
go-git-5.13.2/plumbing/memory_test.go 0000664 0000000 0000000 00000004176 14744245500 0017520 0 ustar 00root root 0000000 0000000 package plumbing
import (
"io"
. "gopkg.in/check.v1"
)
type MemoryObjectSuite struct{}
var _ = Suite(&MemoryObjectSuite{})
func (s *MemoryObjectSuite) TestHash(c *C) {
o := &MemoryObject{}
o.SetType(BlobObject)
o.SetSize(14)
_, err := o.Write([]byte("Hello, World!\n"))
c.Assert(err, IsNil)
c.Assert(o.Hash().String(), Equals, "8ab686eafeb1f44702738c8b0f24f2567c36da6d")
o.SetType(CommitObject)
c.Assert(o.Hash().String(), Equals, "8ab686eafeb1f44702738c8b0f24f2567c36da6d")
}
func (s *MemoryObjectSuite) TestHashNotFilled(c *C) {
o := &MemoryObject{}
o.SetType(BlobObject)
o.SetSize(14)
c.Assert(o.Hash(), Equals, ZeroHash)
}
func (s *MemoryObjectSuite) TestType(c *C) {
o := &MemoryObject{}
o.SetType(BlobObject)
c.Assert(o.Type(), Equals, BlobObject)
}
func (s *MemoryObjectSuite) TestSize(c *C) {
o := &MemoryObject{}
o.SetSize(42)
c.Assert(o.Size(), Equals, int64(42))
}
func (s *MemoryObjectSuite) TestReader(c *C) {
o := &MemoryObject{cont: []byte("foo")}
reader, err := o.Reader()
c.Assert(err, IsNil)
defer func() { c.Assert(reader.Close(), IsNil) }()
b, err := io.ReadAll(reader)
c.Assert(err, IsNil)
c.Assert(b, DeepEquals, []byte("foo"))
}
func (s *MemoryObjectSuite) TestSeekableReader(c *C) {
const pageSize = 4096
const payload = "foo"
content := make([]byte, pageSize+len(payload))
copy(content[pageSize:], []byte(payload))
o := &MemoryObject{cont: content}
reader, err := o.Reader()
c.Assert(err, IsNil)
defer func() { c.Assert(reader.Close(), IsNil) }()
rs, ok := reader.(io.ReadSeeker)
c.Assert(ok, Equals, true)
_, err = rs.Seek(pageSize, io.SeekStart)
c.Assert(err, IsNil)
b, err := io.ReadAll(rs)
c.Assert(err, IsNil)
c.Assert(b, DeepEquals, []byte(payload))
// Check that our Reader isn't also accidentally writable
_, ok = reader.(io.WriteSeeker)
c.Assert(ok, Equals, false)
}
func (s *MemoryObjectSuite) TestWriter(c *C) {
o := &MemoryObject{}
writer, err := o.Writer()
c.Assert(err, IsNil)
defer func() { c.Assert(writer.Close(), IsNil) }()
n, err := writer.Write([]byte("foo"))
c.Assert(err, IsNil)
c.Assert(n, Equals, 3)
c.Assert(o.cont, DeepEquals, []byte("foo"))
}
go-git-5.13.2/plumbing/object.go 0000664 0000000 0000000 00000005015 14744245500 0016410 0 ustar 00root root 0000000 0000000 // package plumbing implement the core interfaces and structs used by go-git
package plumbing
import (
"errors"
"io"
)
var (
ErrObjectNotFound = errors.New("object not found")
// ErrInvalidType is returned when an invalid object type is provided.
ErrInvalidType = errors.New("invalid object type")
)
// Object is a generic representation of any git object
type EncodedObject interface {
Hash() Hash
Type() ObjectType
SetType(ObjectType)
Size() int64
SetSize(int64)
Reader() (io.ReadCloser, error)
Writer() (io.WriteCloser, error)
}
// DeltaObject is an EncodedObject representing a delta.
type DeltaObject interface {
EncodedObject
// BaseHash returns the hash of the object used as base for this delta.
BaseHash() Hash
// ActualHash returns the hash of the object after applying the delta.
ActualHash() Hash
// Size returns the size of the object after applying the delta.
ActualSize() int64
}
// ObjectType internal object type
// Integer values from 0 to 7 map to those exposed by git.
// AnyObject is used to represent any from 0 to 7.
type ObjectType int8
const (
InvalidObject ObjectType = 0
CommitObject ObjectType = 1
TreeObject ObjectType = 2
BlobObject ObjectType = 3
TagObject ObjectType = 4
// 5 reserved for future expansion
OFSDeltaObject ObjectType = 6
REFDeltaObject ObjectType = 7
AnyObject ObjectType = -127
)
func (t ObjectType) String() string {
switch t {
case CommitObject:
return "commit"
case TreeObject:
return "tree"
case BlobObject:
return "blob"
case TagObject:
return "tag"
case OFSDeltaObject:
return "ofs-delta"
case REFDeltaObject:
return "ref-delta"
case AnyObject:
return "any"
default:
return "unknown"
}
}
func (t ObjectType) Bytes() []byte {
return []byte(t.String())
}
// Valid returns true if t is a valid ObjectType.
func (t ObjectType) Valid() bool {
return t >= CommitObject && t <= REFDeltaObject
}
// IsDelta returns true for any ObjectType that represents a delta (i.e.
// REFDeltaObject or OFSDeltaObject).
func (t ObjectType) IsDelta() bool {
return t == REFDeltaObject || t == OFSDeltaObject
}
// ParseObjectType parses a string representation of ObjectType. It returns an
// error on parse failure.
func ParseObjectType(value string) (typ ObjectType, err error) {
switch value {
case "commit":
typ = CommitObject
case "tree":
typ = TreeObject
case "blob":
typ = BlobObject
case "tag":
typ = TagObject
case "ofs-delta":
typ = OFSDeltaObject
case "ref-delta":
typ = REFDeltaObject
default:
err = ErrInvalidType
}
return
}
go-git-5.13.2/plumbing/object/ 0000775 0000000 0000000 00000000000 14744245500 0016060 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/object/blob.go 0000664 0000000 0000000 00000006530 14744245500 0017331 0 ustar 00root root 0000000 0000000 package object
import (
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/utils/ioutil"
)
// Blob is used to store arbitrary data - it is generally a file.
type Blob struct {
// Hash of the blob.
Hash plumbing.Hash
// Size of the (uncompressed) blob.
Size int64
obj plumbing.EncodedObject
}
// GetBlob gets a blob from an object storer and decodes it.
func GetBlob(s storer.EncodedObjectStorer, h plumbing.Hash) (*Blob, error) {
o, err := s.EncodedObject(plumbing.BlobObject, h)
if err != nil {
return nil, err
}
return DecodeBlob(o)
}
// DecodeObject decodes an encoded object into a *Blob.
func DecodeBlob(o plumbing.EncodedObject) (*Blob, error) {
b := &Blob{}
if err := b.Decode(o); err != nil {
return nil, err
}
return b, nil
}
// ID returns the object ID of the blob. The returned value will always match
// the current value of Blob.Hash.
//
// ID is present to fulfill the Object interface.
func (b *Blob) ID() plumbing.Hash {
return b.Hash
}
// Type returns the type of object. It always returns plumbing.BlobObject.
//
// Type is present to fulfill the Object interface.
func (b *Blob) Type() plumbing.ObjectType {
return plumbing.BlobObject
}
// Decode transforms a plumbing.EncodedObject into a Blob struct.
func (b *Blob) Decode(o plumbing.EncodedObject) error {
if o.Type() != plumbing.BlobObject {
return ErrUnsupportedObject
}
b.Hash = o.Hash()
b.Size = o.Size()
b.obj = o
return nil
}
// Encode transforms a Blob into a plumbing.EncodedObject.
func (b *Blob) Encode(o plumbing.EncodedObject) (err error) {
o.SetType(plumbing.BlobObject)
w, err := o.Writer()
if err != nil {
return err
}
defer ioutil.CheckClose(w, &err)
r, err := b.Reader()
if err != nil {
return err
}
defer ioutil.CheckClose(r, &err)
_, err = io.Copy(w, r)
return err
}
// Reader returns a reader allow the access to the content of the blob
func (b *Blob) Reader() (io.ReadCloser, error) {
return b.obj.Reader()
}
// BlobIter provides an iterator for a set of blobs.
type BlobIter struct {
storer.EncodedObjectIter
s storer.EncodedObjectStorer
}
// NewBlobIter takes a storer.EncodedObjectStorer and a
// storer.EncodedObjectIter and returns a *BlobIter that iterates over all
// blobs contained in the storer.EncodedObjectIter.
//
// Any non-blob object returned by the storer.EncodedObjectIter is skipped.
func NewBlobIter(s storer.EncodedObjectStorer, iter storer.EncodedObjectIter) *BlobIter {
return &BlobIter{iter, s}
}
// Next moves the iterator to the next blob and returns a pointer to it. If
// there are no more blobs, it returns io.EOF.
func (iter *BlobIter) Next() (*Blob, error) {
for {
obj, err := iter.EncodedObjectIter.Next()
if err != nil {
return nil, err
}
if obj.Type() != plumbing.BlobObject {
continue
}
return DecodeBlob(obj)
}
}
// ForEach call the cb function for each blob contained on this iter until
// an error happens or the end of the iter is reached. If ErrStop is sent
// the iteration is stop but no error is returned. The iterator is closed.
func (iter *BlobIter) ForEach(cb func(*Blob) error) error {
return iter.EncodedObjectIter.ForEach(func(obj plumbing.EncodedObject) error {
if obj.Type() != plumbing.BlobObject {
return nil
}
b, err := DecodeBlob(obj)
if err != nil {
return err
}
return cb(b)
})
}
go-git-5.13.2/plumbing/object/blob_test.go 0000664 0000000 0000000 00000004617 14744245500 0020374 0 ustar 00root root 0000000 0000000 package object
import (
"bytes"
"io"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
type BlobsSuite struct {
BaseObjectsSuite
}
var _ = Suite(&BlobsSuite{})
func (s *BlobsSuite) TestBlobHash(c *C) {
o := &plumbing.MemoryObject{}
o.SetType(plumbing.BlobObject)
o.SetSize(3)
writer, err := o.Writer()
c.Assert(err, IsNil)
defer func() { c.Assert(writer.Close(), IsNil) }()
writer.Write([]byte{'F', 'O', 'O'})
blob := &Blob{}
c.Assert(blob.Decode(o), IsNil)
c.Assert(blob.Size, Equals, int64(3))
c.Assert(blob.Hash.String(), Equals, "d96c7efbfec2814ae0301ad054dc8d9fc416c9b5")
reader, err := blob.Reader()
c.Assert(err, IsNil)
defer func() { c.Assert(reader.Close(), IsNil) }()
data, err := io.ReadAll(reader)
c.Assert(err, IsNil)
c.Assert(string(data), Equals, "FOO")
}
func (s *BlobsSuite) TestBlobDecodeEncodeIdempotent(c *C) {
var objects []*plumbing.MemoryObject
for _, str := range []string{"foo", "foo\n"} {
obj := &plumbing.MemoryObject{}
obj.Write([]byte(str))
obj.SetType(plumbing.BlobObject)
obj.Hash()
objects = append(objects, obj)
}
for _, object := range objects {
blob := &Blob{}
err := blob.Decode(object)
c.Assert(err, IsNil)
newObject := &plumbing.MemoryObject{}
err = blob.Encode(newObject)
c.Assert(err, IsNil)
newObject.Hash() // Ensure Hash is pre-computed before deep comparison
c.Assert(newObject, DeepEquals, object)
}
}
func (s *BlobsSuite) TestBlobIter(c *C) {
encIter, err := s.Storer.IterEncodedObjects(plumbing.BlobObject)
c.Assert(err, IsNil)
iter := NewBlobIter(s.Storer, encIter)
blobs := []*Blob{}
iter.ForEach(func(b *Blob) error {
blobs = append(blobs, b)
return nil
})
c.Assert(len(blobs) > 0, Equals, true)
iter.Close()
encIter, err = s.Storer.IterEncodedObjects(plumbing.BlobObject)
c.Assert(err, IsNil)
iter = NewBlobIter(s.Storer, encIter)
i := 0
for {
b, err := iter.Next()
if err == io.EOF {
break
}
c.Assert(err, IsNil)
c.Assert(b.ID(), Equals, blobs[i].ID())
c.Assert(b.Size, Equals, blobs[i].Size)
c.Assert(b.Type(), Equals, blobs[i].Type())
r1, err := b.Reader()
c.Assert(err, IsNil)
b1, err := io.ReadAll(r1)
c.Assert(err, IsNil)
c.Assert(r1.Close(), IsNil)
r2, err := blobs[i].Reader()
c.Assert(err, IsNil)
b2, err := io.ReadAll(r2)
c.Assert(err, IsNil)
c.Assert(r2.Close(), IsNil)
c.Assert(bytes.Compare(b1, b2), Equals, 0)
i++
}
iter.Close()
}
go-git-5.13.2/plumbing/object/change.go 0000664 0000000 0000000 00000007410 14744245500 0017636 0 ustar 00root root 0000000 0000000 package object
import (
"bytes"
"context"
"fmt"
"strings"
"github.com/go-git/go-git/v5/utils/merkletrie"
)
// Change values represent a detected change between two git trees. For
// modifications, From is the original status of the node and To is its
// final status. For insertions, From is the zero value and for
// deletions To is the zero value.
type Change struct {
From ChangeEntry
To ChangeEntry
}
var empty ChangeEntry
// Action returns the kind of action represented by the change, an
// insertion, a deletion or a modification.
func (c *Change) Action() (merkletrie.Action, error) {
if c.From == empty && c.To == empty {
return merkletrie.Action(0),
fmt.Errorf("malformed change: empty from and to")
}
if c.From == empty {
return merkletrie.Insert, nil
}
if c.To == empty {
return merkletrie.Delete, nil
}
return merkletrie.Modify, nil
}
// Files returns the files before and after a change.
// For insertions from will be nil. For deletions to will be nil.
func (c *Change) Files() (from, to *File, err error) {
action, err := c.Action()
if err != nil {
return
}
if action == merkletrie.Insert || action == merkletrie.Modify {
to, err = c.To.Tree.TreeEntryFile(&c.To.TreeEntry)
if !c.To.TreeEntry.Mode.IsFile() {
return nil, nil, nil
}
if err != nil {
return
}
}
if action == merkletrie.Delete || action == merkletrie.Modify {
from, err = c.From.Tree.TreeEntryFile(&c.From.TreeEntry)
if !c.From.TreeEntry.Mode.IsFile() {
return nil, nil, nil
}
if err != nil {
return
}
}
return
}
func (c *Change) String() string {
action, err := c.Action()
if err != nil {
return "malformed change"
}
return fmt.Sprintf("", action, c.name())
}
// Patch returns a Patch with all the file changes in chunks. This
// representation can be used to create several diff outputs.
func (c *Change) Patch() (*Patch, error) {
return c.PatchContext(context.Background())
}
// Patch returns a Patch with all the file changes in chunks. This
// representation can be used to create several diff outputs.
// If context expires, an non-nil error will be returned
// Provided context must be non-nil
func (c *Change) PatchContext(ctx context.Context) (*Patch, error) {
return getPatchContext(ctx, "", c)
}
func (c *Change) name() string {
if c.From != empty {
return c.From.Name
}
return c.To.Name
}
// ChangeEntry values represent a node that has suffered a change.
type ChangeEntry struct {
// Full path of the node using "/" as separator.
Name string
// Parent tree of the node that has changed.
Tree *Tree
// The entry of the node.
TreeEntry TreeEntry
}
// Changes represents a collection of changes between two git trees.
// Implements sort.Interface lexicographically over the path of the
// changed files.
type Changes []*Change
func (c Changes) Len() int {
return len(c)
}
func (c Changes) Swap(i, j int) {
c[i], c[j] = c[j], c[i]
}
func (c Changes) Less(i, j int) bool {
return strings.Compare(c[i].name(), c[j].name()) < 0
}
func (c Changes) String() string {
var buffer bytes.Buffer
buffer.WriteString("[")
comma := ""
for _, v := range c {
buffer.WriteString(comma)
buffer.WriteString(v.String())
comma = ", "
}
buffer.WriteString("]")
return buffer.String()
}
// Patch returns a Patch with all the changes in chunks. This
// representation can be used to create several diff outputs.
func (c Changes) Patch() (*Patch, error) {
return c.PatchContext(context.Background())
}
// Patch returns a Patch with all the changes in chunks. This
// representation can be used to create several diff outputs.
// If context expires, an non-nil error will be returned
// Provided context must be non-nil
func (c Changes) PatchContext(ctx context.Context) (*Patch, error) {
return getPatchContext(ctx, "", c...)
}
go-git-5.13.2/plumbing/object/change_adaptor.go 0000664 0000000 0000000 00000002351 14744245500 0021347 0 ustar 00root root 0000000 0000000 package object
import (
"errors"
"fmt"
"github.com/go-git/go-git/v5/utils/merkletrie"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
// The following functions transform changes types form the merkletrie
// package to changes types from this package.
func newChange(c merkletrie.Change) (*Change, error) {
ret := &Change{}
var err error
if ret.From, err = newChangeEntry(c.From); err != nil {
return nil, fmt.Errorf("from field: %s", err)
}
if ret.To, err = newChangeEntry(c.To); err != nil {
return nil, fmt.Errorf("to field: %s", err)
}
return ret, nil
}
func newChangeEntry(p noder.Path) (ChangeEntry, error) {
if p == nil {
return empty, nil
}
asTreeNoder, ok := p.Last().(*treeNoder)
if !ok {
return ChangeEntry{}, errors.New("cannot transform non-TreeNoders")
}
return ChangeEntry{
Name: p.String(),
Tree: asTreeNoder.parent,
TreeEntry: TreeEntry{
Name: asTreeNoder.name,
Mode: asTreeNoder.mode,
Hash: asTreeNoder.hash,
},
}, nil
}
func newChanges(src merkletrie.Changes) (Changes, error) {
ret := make(Changes, len(src))
var err error
for i, e := range src {
ret[i], err = newChange(e)
if err != nil {
return nil, fmt.Errorf("change #%d: %s", i, err)
}
}
return ret, nil
}
go-git-5.13.2/plumbing/object/change_adaptor_test.go 0000664 0000000 0000000 00000024761 14744245500 0022417 0 ustar 00root root 0000000 0000000 package object
import (
"sort"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-git/v5/utils/merkletrie"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type ChangeAdaptorSuite struct {
fixtures.Suite
Storer storer.EncodedObjectStorer
Fixture *fixtures.Fixture
}
func (s *ChangeAdaptorSuite) SetUpSuite(c *C) {
s.Fixture = fixtures.Basic().One()
sto := filesystem.NewStorage(s.Fixture.DotGit(), cache.NewObjectLRUDefault())
s.Storer = sto
}
func (s *ChangeAdaptorSuite) tree(c *C, h plumbing.Hash) *Tree {
t, err := GetTree(s.Storer, h)
c.Assert(err, IsNil)
return t
}
var _ = Suite(&ChangeAdaptorSuite{})
// utility function to build Noders from a tree and an tree entry.
func newNoder(t *Tree, e TreeEntry) noder.Noder {
return &treeNoder{
parent: t,
name: e.Name,
mode: e.Mode,
hash: e.Hash,
}
}
// utility function to build Paths
func newPath(nn ...noder.Noder) noder.Path { return noder.Path(nn) }
func (s *ChangeAdaptorSuite) TestTreeNoderHashHasMode(c *C) {
hash := plumbing.NewHash("aaaa")
mode := filemode.Regular
treeNoder := &treeNoder{
hash: hash,
mode: mode,
}
expected := []byte{
0xaa, 0xaa, 0x00, 0x00, // original hash is aaaa and 16 zeros
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
}
expected = append(expected, filemode.Regular.Bytes()...)
c.Assert(treeNoder.Hash(), DeepEquals, expected)
}
func (s *ChangeAdaptorSuite) TestNewChangeInsert(c *C) {
tree := &Tree{}
entry := TreeEntry{
Name: "name",
Mode: filemode.FileMode(42),
Hash: plumbing.NewHash("aaaaa"),
}
path := newPath(newNoder(tree, entry))
expectedTo, err := newChangeEntry(path)
c.Assert(err, IsNil)
src := merkletrie.Change{
From: nil,
To: path,
}
obtained, err := newChange(src)
c.Assert(err, IsNil)
action, err := obtained.Action()
c.Assert(err, IsNil)
c.Assert(action, Equals, merkletrie.Insert)
c.Assert(obtained.From, Equals, ChangeEntry{})
c.Assert(obtained.To, Equals, expectedTo)
}
func (s *ChangeAdaptorSuite) TestNewChangeDelete(c *C) {
tree := &Tree{}
entry := TreeEntry{
Name: "name",
Mode: filemode.FileMode(42),
Hash: plumbing.NewHash("aaaaa"),
}
path := newPath(newNoder(tree, entry))
expectedFrom, err := newChangeEntry(path)
c.Assert(err, IsNil)
src := merkletrie.Change{
From: path,
To: nil,
}
obtained, err := newChange(src)
c.Assert(err, IsNil)
action, err := obtained.Action()
c.Assert(err, IsNil)
c.Assert(action, Equals, merkletrie.Delete)
c.Assert(obtained.From, Equals, expectedFrom)
c.Assert(obtained.To, Equals, ChangeEntry{})
}
func (s *ChangeAdaptorSuite) TestNewChangeModify(c *C) {
treeA := &Tree{}
entryA := TreeEntry{
Name: "name",
Mode: filemode.FileMode(42),
Hash: plumbing.NewHash("aaaaa"),
}
pathA := newPath(newNoder(treeA, entryA))
expectedFrom, err := newChangeEntry(pathA)
c.Assert(err, IsNil)
treeB := &Tree{}
entryB := TreeEntry{
Name: "name",
Mode: filemode.FileMode(42),
Hash: plumbing.NewHash("bbbb"),
}
pathB := newPath(newNoder(treeB, entryB))
expectedTo, err := newChangeEntry(pathB)
c.Assert(err, IsNil)
src := merkletrie.Change{
From: pathA,
To: pathB,
}
obtained, err := newChange(src)
c.Assert(err, IsNil)
action, err := obtained.Action()
c.Assert(err, IsNil)
c.Assert(action, Equals, merkletrie.Modify)
c.Assert(obtained.From, Equals, expectedFrom)
c.Assert(obtained.To, Equals, expectedTo)
}
func (s *ChangeAdaptorSuite) TestEmptyChangeFails(c *C) {
change := &Change{
From: empty,
To: empty,
}
_, err := change.Action()
c.Assert(err, ErrorMatches, "malformed change.*")
_, _, err = change.Files()
c.Assert(err, ErrorMatches, "malformed change.*")
str := change.String()
c.Assert(str, Equals, "malformed change")
}
type noderMock struct{ noder.Noder }
func (s *ChangeAdaptorSuite) TestNewChangeFailsWithChangesFromOtherNoders(c *C) {
src := merkletrie.Change{
From: newPath(noderMock{}),
To: nil,
}
_, err := newChange(src)
c.Assert(err, Not(IsNil))
src = merkletrie.Change{
From: nil,
To: newPath(noderMock{}),
}
_, err = newChange(src)
c.Assert(err, Not(IsNil))
}
func (s *ChangeAdaptorSuite) TestChangeStringFrom(c *C) {
expected := ""
change := Change{}
change.From.Name = "foo"
obtained := change.String()
c.Assert(obtained, Equals, expected)
}
func (s *ChangeAdaptorSuite) TestChangeStringTo(c *C) {
expected := ""
change := Change{}
change.To.Name = "foo"
obtained := change.String()
c.Assert(obtained, Equals, expected)
}
func (s *ChangeAdaptorSuite) TestChangeFilesInsert(c *C) {
tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"))
change := Change{}
change.To.Name = "json/long.json"
change.To.Tree = tree
change.To.TreeEntry.Mode = filemode.Regular
change.To.TreeEntry.Hash = plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9")
from, to, err := change.Files()
c.Assert(err, IsNil)
c.Assert(from, IsNil)
c.Assert(to.ID(), Equals, change.To.TreeEntry.Hash)
}
func (s *ChangeAdaptorSuite) TestChangeFilesInsertNotFound(c *C) {
tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"))
change := Change{}
change.To.Name = "json/long.json"
change.To.Tree = tree
change.To.TreeEntry.Mode = filemode.Regular
// there is no object for this hash
change.To.TreeEntry.Hash = plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
_, _, err := change.Files()
c.Assert(err, Not(IsNil))
}
func (s *ChangeAdaptorSuite) TestChangeFilesDelete(c *C) {
tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"))
change := Change{}
change.From.Name = "json/long.json"
change.From.Tree = tree
change.From.TreeEntry.Mode = filemode.Regular
change.From.TreeEntry.Hash = plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9")
from, to, err := change.Files()
c.Assert(err, IsNil)
c.Assert(to, IsNil)
c.Assert(from.ID(), Equals, change.From.TreeEntry.Hash)
}
func (s *ChangeAdaptorSuite) TestChangeFilesDeleteNotFound(c *C) {
tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"))
change := Change{}
change.From.Name = "json/long.json"
change.From.Tree = tree
change.From.TreeEntry.Mode = filemode.Regular
// there is no object for this hash
change.From.TreeEntry.Hash = plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
_, _, err := change.Files()
c.Assert(err, Not(IsNil))
}
func (s *ChangeAdaptorSuite) TestChangeFilesModify(c *C) {
tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"))
change := Change{}
change.To.Name = "json/long.json"
change.To.Tree = tree
change.To.TreeEntry.Mode = filemode.Regular
change.To.TreeEntry.Hash = plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9")
change.From.Name = "json/long.json"
change.From.Tree = tree
change.From.TreeEntry.Mode = filemode.Regular
change.From.TreeEntry.Hash = plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492")
from, to, err := change.Files()
c.Assert(err, IsNil)
c.Assert(to.ID(), Equals, change.To.TreeEntry.Hash)
c.Assert(from.ID(), Equals, change.From.TreeEntry.Hash)
}
func (s *ChangeAdaptorSuite) TestChangeEntryFailsWithOtherNoders(c *C) {
path := noder.Path{noderMock{}}
_, err := newChangeEntry(path)
c.Assert(err, Not(IsNil))
}
func (s *ChangeAdaptorSuite) TestChangeEntryFromNilIsZero(c *C) {
obtained, err := newChangeEntry(nil)
c.Assert(err, IsNil)
c.Assert(obtained, Equals, ChangeEntry{})
}
func (s *ChangeAdaptorSuite) TestChangeEntryFromSortPath(c *C) {
tree := &Tree{}
entry := TreeEntry{
Name: "name",
Mode: filemode.FileMode(42),
Hash: plumbing.NewHash("aaaaa"),
}
path := newPath(newNoder(tree, entry))
obtained, err := newChangeEntry(path)
c.Assert(err, IsNil)
c.Assert(obtained.Name, Equals, entry.Name)
c.Assert(obtained.Tree, Equals, tree)
c.Assert(obtained.TreeEntry, DeepEquals, entry)
}
func (s *ChangeAdaptorSuite) TestChangeEntryFromLongPath(c *C) {
treeA := &Tree{}
entryA := TreeEntry{
Name: "nameA",
Mode: filemode.FileMode(42),
Hash: plumbing.NewHash("aaaa"),
}
treeB := &Tree{}
entryB := TreeEntry{
Name: "nameB",
Mode: filemode.FileMode(24),
Hash: plumbing.NewHash("bbbb"),
}
path := newPath(
newNoder(treeA, entryA),
newNoder(treeB, entryB),
)
obtained, err := newChangeEntry(path)
c.Assert(err, IsNil)
c.Assert(obtained.Name, Equals, entryA.Name+"/"+entryB.Name)
c.Assert(obtained.Tree, Equals, treeB)
c.Assert(obtained.TreeEntry, Equals, entryB)
}
func (s *ChangeAdaptorSuite) TestNewChangesEmpty(c *C) {
expected := "[]"
changes, err := newChanges(nil)
c.Assert(err, IsNil)
obtained := changes.String()
c.Assert(obtained, Equals, expected)
expected = "[]"
changes, err = newChanges(merkletrie.Changes{})
c.Assert(err, IsNil)
obtained = changes.String()
c.Assert(obtained, Equals, expected)
}
func (s *ChangeAdaptorSuite) TestNewChanges(c *C) {
treeA := &Tree{}
entryA := TreeEntry{Name: "nameA"}
pathA := newPath(newNoder(treeA, entryA))
changeA := merkletrie.Change{
From: nil,
To: pathA,
}
treeB := &Tree{}
entryB := TreeEntry{Name: "nameB"}
pathB := newPath(newNoder(treeB, entryB))
changeB := merkletrie.Change{
From: pathB,
To: nil,
}
src := merkletrie.Changes{changeA, changeB}
changes, err := newChanges(src)
c.Assert(err, IsNil)
c.Assert(len(changes), Equals, 2)
action, err := changes[0].Action()
c.Assert(err, IsNil)
c.Assert(action, Equals, merkletrie.Insert)
c.Assert(changes[0].To.Name, Equals, "nameA")
action, err = changes[1].Action()
c.Assert(err, IsNil)
c.Assert(action, Equals, merkletrie.Delete)
c.Assert(changes[1].From.Name, Equals, "nameB")
}
func (s *ChangeAdaptorSuite) TestNewChangesFailsWithOtherNoders(c *C) {
change := merkletrie.Change{
From: nil,
To: newPath(noderMock{}),
}
src := merkletrie.Changes{change}
_, err := newChanges(src)
c.Assert(err, Not(IsNil))
}
func (s *ChangeAdaptorSuite) TestSortChanges(c *C) {
c1 := &Change{}
c1.To.Name = "1"
c2 := &Change{}
c2.From.Name = "2"
c2.To.Name = "2"
c3 := &Change{}
c3.From.Name = "3"
changes := Changes{c3, c1, c2}
sort.Sort(changes)
c.Assert(changes[0].String(), Equals, "")
c.Assert(changes[1].String(), Equals, "")
c.Assert(changes[2].String(), Equals, "")
}
go-git-5.13.2/plumbing/object/change_test.go 0000664 0000000 0000000 00000027421 14744245500 0020701 0 ustar 00root root 0000000 0000000 package object
import (
"context"
"sort"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/format/diff"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-git/v5/utils/merkletrie"
. "gopkg.in/check.v1"
)
type ChangeSuite struct {
fixtures.Suite
Storer storer.EncodedObjectStorer
Fixture *fixtures.Fixture
}
func (s *ChangeSuite) SetUpSuite(c *C) {
s.Fixture = fixtures.ByURL("https://github.com/src-d/go-git.git").
ByTag(".git").One()
sto := filesystem.NewStorage(s.Fixture.DotGit(), cache.NewObjectLRUDefault())
s.Storer = sto
}
func (s *ChangeSuite) tree(c *C, h plumbing.Hash) *Tree {
t, err := GetTree(s.Storer, h)
c.Assert(err, IsNil)
return t
}
var _ = Suite(&ChangeSuite{})
func (s *ChangeSuite) TestInsert(c *C) {
// Commit a5078b19f08f63e7948abd0a5e2fb7d319d3a565 of the go-git
// fixture inserted "examples/clone/main.go".
//
// On that commit, the "examples/clone" tree is
// 6efca3ff41cab651332f9ebc0c96bb26be809615
//
// and the "examples/colone/main.go" is
// f95dc8f7923add1a8b9f72ecb1e8db1402de601a
path := "examples/clone/main.go"
name := "main.go"
mode := filemode.Regular
blob := plumbing.NewHash("f95dc8f7923add1a8b9f72ecb1e8db1402de601a")
tree := plumbing.NewHash("6efca3ff41cab651332f9ebc0c96bb26be809615")
change := &Change{
From: empty,
To: ChangeEntry{
Name: path,
Tree: s.tree(c, tree),
TreeEntry: TreeEntry{
Name: name,
Mode: mode,
Hash: blob,
},
},
}
action, err := change.Action()
c.Assert(err, IsNil)
c.Assert(action, Equals, merkletrie.Insert)
from, to, err := change.Files()
c.Assert(err, IsNil)
c.Assert(from, IsNil)
c.Assert(to.Name, Equals, name)
c.Assert(to.Blob.Hash, Equals, blob)
p, err := change.Patch()
c.Assert(err, IsNil)
c.Assert(len(p.FilePatches()), Equals, 1)
c.Assert(len(p.FilePatches()[0].Chunks()), Equals, 1)
c.Assert(p.FilePatches()[0].Chunks()[0].Type(), Equals, diff.Add)
p, err = change.PatchContext(context.Background())
c.Assert(err, IsNil)
c.Assert(len(p.FilePatches()), Equals, 1)
c.Assert(len(p.FilePatches()[0].Chunks()), Equals, 1)
c.Assert(p.FilePatches()[0].Chunks()[0].Type(), Equals, diff.Add)
str := change.String()
c.Assert(str, Equals, "")
}
func (s *ChangeSuite) TestDelete(c *C) {
// Commit f6011d65d57c2a866e231fc21a39cb618f86f9ea of the go-git
// fixture deleted "utils/difftree/difftree.go".
//
// The parent of that commit is
// 9b4a386db3d98a4362516a00ef3d04d4698c9bcd.
//
// On that parent commit, the "utils/difftree" tree is
// f3d11566401ce4b0808aab9dd6fad3d5abf1481a.
//
// and the "utils/difftree/difftree.go" is
// e2cb9a5719daf634d45a063112b4044ee81da13ea.
path := "utils/difftree/difftree.go"
name := "difftree.go"
mode := filemode.Regular
blob := plumbing.NewHash("e2cb9a5719daf634d45a063112b4044ee81da13e")
tree := plumbing.NewHash("f3d11566401ce4b0808aab9dd6fad3d5abf1481a")
change := &Change{
From: ChangeEntry{
Name: path,
Tree: s.tree(c, tree),
TreeEntry: TreeEntry{
Name: name,
Mode: mode,
Hash: blob,
},
},
To: empty,
}
action, err := change.Action()
c.Assert(err, IsNil)
c.Assert(action, Equals, merkletrie.Delete)
from, to, err := change.Files()
c.Assert(err, IsNil)
c.Assert(to, IsNil)
c.Assert(from.Name, Equals, name)
c.Assert(from.Blob.Hash, Equals, blob)
p, err := change.Patch()
c.Assert(err, IsNil)
c.Assert(len(p.FilePatches()), Equals, 1)
c.Assert(len(p.FilePatches()[0].Chunks()), Equals, 1)
c.Assert(p.FilePatches()[0].Chunks()[0].Type(), Equals, diff.Delete)
p, err = change.PatchContext(context.Background())
c.Assert(err, IsNil)
c.Assert(len(p.FilePatches()), Equals, 1)
c.Assert(len(p.FilePatches()[0].Chunks()), Equals, 1)
c.Assert(p.FilePatches()[0].Chunks()[0].Type(), Equals, diff.Delete)
str := change.String()
c.Assert(str, Equals, "")
}
func (s *ChangeSuite) TestModify(c *C) {
// Commit 7beaad711378a4daafccc2c04bc46d36df2a0fd1 of the go-git
// fixture modified "examples/latest/latest.go".
// the "examples/latest" tree is
// b1f01b730b855c82431918cb338ad47ed558999b.
// and "examples/latest/latest.go" is blob
// 05f583ace3a9a078d8150905a53a4d82567f125f.
//
// The parent of that commit is
// 337148ef6d751477796922ac127b416b8478fcc4.
// the "examples/latest" tree is
// 8b0af31d2544acb5c4f3816a602f11418cbd126e.
// and "examples/latest/latest.go" is blob
// de927fad935d172929aacf20e71f3bf0b91dd6f9.
path := "utils/difftree/difftree.go"
name := "difftree.go"
mode := filemode.Regular
fromBlob := plumbing.NewHash("05f583ace3a9a078d8150905a53a4d82567f125f")
fromTree := plumbing.NewHash("b1f01b730b855c82431918cb338ad47ed558999b")
toBlob := plumbing.NewHash("de927fad935d172929aacf20e71f3bf0b91dd6f9")
toTree := plumbing.NewHash("8b0af31d2544acb5c4f3816a602f11418cbd126e")
change := &Change{
From: ChangeEntry{
Name: path,
Tree: s.tree(c, fromTree),
TreeEntry: TreeEntry{
Name: name,
Mode: mode,
Hash: fromBlob,
},
},
To: ChangeEntry{
Name: path,
Tree: s.tree(c, toTree),
TreeEntry: TreeEntry{
Name: name,
Mode: mode,
Hash: toBlob,
},
},
}
action, err := change.Action()
c.Assert(err, IsNil)
c.Assert(action, Equals, merkletrie.Modify)
from, to, err := change.Files()
c.Assert(err, IsNil)
c.Assert(from.Name, Equals, name)
c.Assert(from.Blob.Hash, Equals, fromBlob)
c.Assert(to.Name, Equals, name)
c.Assert(to.Blob.Hash, Equals, toBlob)
p, err := change.Patch()
c.Assert(err, IsNil)
c.Assert(len(p.FilePatches()), Equals, 1)
c.Assert(len(p.FilePatches()[0].Chunks()), Equals, 7)
c.Assert(p.FilePatches()[0].Chunks()[0].Type(), Equals, diff.Equal)
c.Assert(p.FilePatches()[0].Chunks()[1].Type(), Equals, diff.Delete)
c.Assert(p.FilePatches()[0].Chunks()[2].Type(), Equals, diff.Add)
c.Assert(p.FilePatches()[0].Chunks()[3].Type(), Equals, diff.Equal)
c.Assert(p.FilePatches()[0].Chunks()[4].Type(), Equals, diff.Delete)
c.Assert(p.FilePatches()[0].Chunks()[5].Type(), Equals, diff.Add)
c.Assert(p.FilePatches()[0].Chunks()[6].Type(), Equals, diff.Equal)
p, err = change.PatchContext(context.Background())
c.Assert(err, IsNil)
c.Assert(len(p.FilePatches()), Equals, 1)
c.Assert(len(p.FilePatches()[0].Chunks()), Equals, 7)
c.Assert(p.FilePatches()[0].Chunks()[0].Type(), Equals, diff.Equal)
c.Assert(p.FilePatches()[0].Chunks()[1].Type(), Equals, diff.Delete)
c.Assert(p.FilePatches()[0].Chunks()[2].Type(), Equals, diff.Add)
c.Assert(p.FilePatches()[0].Chunks()[3].Type(), Equals, diff.Equal)
c.Assert(p.FilePatches()[0].Chunks()[4].Type(), Equals, diff.Delete)
c.Assert(p.FilePatches()[0].Chunks()[5].Type(), Equals, diff.Add)
c.Assert(p.FilePatches()[0].Chunks()[6].Type(), Equals, diff.Equal)
str := change.String()
c.Assert(str, Equals, "")
}
func (s *ChangeSuite) TestEmptyChangeFails(c *C) {
change := &Change{}
_, err := change.Action()
c.Assert(err, ErrorMatches, "malformed.*")
_, _, err = change.Files()
c.Assert(err, ErrorMatches, "malformed.*")
str := change.String()
c.Assert(str, Equals, "malformed change")
}
// test reproducing bug #317
func (s *ChangeSuite) TestNoFileFilemodes(c *C) {
f := fixtures.ByURL("https://github.com/git-fixtures/submodule.git").One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
iter, err := sto.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
var commits []*Commit
iter.ForEach(func(o plumbing.EncodedObject) error {
if o.Type() == plumbing.CommitObject {
commit, err := GetCommit(sto, o.Hash())
c.Assert(err, IsNil)
commits = append(commits, commit)
}
return nil
})
c.Assert(len(commits), Not(Equals), 0)
var prev *Commit
for _, commit := range commits {
if prev == nil {
prev = commit
continue
}
tree, err := commit.Tree()
c.Assert(err, IsNil)
prevTree, err := prev.Tree()
c.Assert(err, IsNil)
changes, err := DiffTree(tree, prevTree)
c.Assert(err, IsNil)
for _, change := range changes {
_, _, err := change.Files()
c.Assert(err, IsNil)
}
prev = commit
}
}
func (s *ChangeSuite) TestErrorsFindingChildsAreDetected(c *C) {
// Commit 7beaad711378a4daafccc2c04bc46d36df2a0fd1 of the go-git
// fixture modified "examples/latest/latest.go".
// the "examples/latest" tree is
// b1f01b730b855c82431918cb338ad47ed558999b.
// and "examples/latest/latest.go" is blob
// 05f583ace3a9a078d8150905a53a4d82567f125f.
//
// The parent of that commit is
// 337148ef6d751477796922ac127b416b8478fcc4.
// the "examples/latest" tree is
// 8b0af31d2544acb5c4f3816a602f11418cbd126e.
// and "examples/latest/latest.go" is blob
// de927fad935d172929aacf20e71f3bf0b91dd6f9.
path := "utils/difftree/difftree.go"
name := "difftree.go"
mode := filemode.Regular
fromBlob := plumbing.NewHash("aaaa") // does not exists
fromTree := plumbing.NewHash("b1f01b730b855c82431918cb338ad47ed558999b")
toBlob := plumbing.NewHash("bbbb") // does not exists
toTree := plumbing.NewHash("8b0af31d2544acb5c4f3816a602f11418cbd126e")
change := &Change{
From: ChangeEntry{
Name: path,
Tree: s.tree(c, fromTree),
TreeEntry: TreeEntry{
Name: name,
Mode: mode,
Hash: fromBlob,
},
},
To: ChangeEntry{},
}
_, _, err := change.Files()
c.Assert(err, ErrorMatches, "object not found")
change = &Change{
From: empty,
To: ChangeEntry{
Name: path,
Tree: s.tree(c, toTree),
TreeEntry: TreeEntry{
Name: name,
Mode: mode,
Hash: toBlob,
},
},
}
_, _, err = change.Files()
c.Assert(err, ErrorMatches, "object not found")
}
func (s *ChangeSuite) TestChangesString(c *C) {
expected := "[]"
changes := Changes{}
obtained := changes.String()
c.Assert(obtained, Equals, expected)
expected = "[]"
changes = make([]*Change, 1)
changes[0] = &Change{}
changes[0].From.Name = "bla"
changes[0].To.Name = "bla"
obtained = changes.String()
c.Assert(obtained, Equals, expected)
expected = "[, ]"
changes = make([]*Change, 2)
changes[0] = &Change{}
changes[0].From.Name = "bla"
changes[0].To.Name = "bla"
changes[1] = &Change{}
changes[1].From.Name = "foo/bar"
obtained = changes.String()
c.Assert(obtained, Equals, expected)
}
func (s *ChangeSuite) TestChangesSort(c *C) {
changes := make(Changes, 3)
changes[0] = &Change{}
changes[0].From.Name = "z"
changes[0].To.Name = "z"
changes[1] = &Change{}
changes[1].From.Name = "b/b"
changes[2] = &Change{}
changes[2].To.Name = "b/a"
expected := "[, " +
", " +
"]"
sort.Sort(changes)
c.Assert(changes.String(), Equals, expected)
}
func (s *ChangeSuite) TestCancel(c *C) {
// Commit a5078b19f08f63e7948abd0a5e2fb7d319d3a565 of the go-git
// fixture inserted "examples/clone/main.go".
//
// On that commit, the "examples/clone" tree is
// 6efca3ff41cab651332f9ebc0c96bb26be809615
//
// and the "examples/clone/main.go" is
// f95dc8f7923add1a8b9f72ecb1e8db1402de601a
path := "examples/clone/main.go"
name := "main.go"
mode := filemode.Regular
blob := plumbing.NewHash("f95dc8f7923add1a8b9f72ecb1e8db1402de601a")
tree := plumbing.NewHash("6efca3ff41cab651332f9ebc0c96bb26be809615")
change := &Change{
From: empty,
To: ChangeEntry{
Name: path,
Tree: s.tree(c, tree),
TreeEntry: TreeEntry{
Name: name,
Mode: mode,
Hash: blob,
},
},
}
ctx, cancel := context.WithCancel(context.Background())
cancel()
p, err := change.PatchContext(ctx)
c.Assert(p, IsNil)
c.Assert(err, ErrorMatches, "operation canceled")
}
go-git-5.13.2/plumbing/object/commit.go 0000664 0000000 0000000 00000032636 14744245500 0017711 0 ustar 00root root 0000000 0000000 package object
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"strings"
"github.com/ProtonMail/go-crypto/openpgp"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-git/v5/utils/sync"
)
const (
beginpgp string = "-----BEGIN PGP SIGNATURE-----"
endpgp string = "-----END PGP SIGNATURE-----"
headerpgp string = "gpgsig"
headerencoding string = "encoding"
// https://github.com/git/git/blob/bcb6cae2966cc407ca1afc77413b3ef11103c175/Documentation/gitformat-signature.txt#L153
// When a merge commit is created from a signed tag, the tag is embedded in
// the commit with the "mergetag" header.
headermergetag string = "mergetag"
defaultUtf8CommitMessageEncoding MessageEncoding = "UTF-8"
)
// Hash represents the hash of an object
type Hash plumbing.Hash
// MessageEncoding represents the encoding of a commit
type MessageEncoding string
// Commit points to a single tree, marking it as what the project looked like
// at a certain point in time. It contains meta-information about that point
// in time, such as a timestamp, the author of the changes since the last
// commit, a pointer to the previous commit(s), etc.
// http://shafiulazam.com/gitbook/1_the_git_object_model.html
type Commit struct {
// Hash of the commit object.
Hash plumbing.Hash
// Author is the original author of the commit.
Author Signature
// Committer is the one performing the commit, might be different from
// Author.
Committer Signature
// MergeTag is the embedded tag object when a merge commit is created by
// merging a signed tag.
MergeTag string
// PGPSignature is the PGP signature of the commit.
PGPSignature string
// Message is the commit message, contains arbitrary text.
Message string
// TreeHash is the hash of the root tree of the commit.
TreeHash plumbing.Hash
// ParentHashes are the hashes of the parent commits of the commit.
ParentHashes []plumbing.Hash
// Encoding is the encoding of the commit.
Encoding MessageEncoding
s storer.EncodedObjectStorer
}
// GetCommit gets a commit from an object storer and decodes it.
func GetCommit(s storer.EncodedObjectStorer, h plumbing.Hash) (*Commit, error) {
o, err := s.EncodedObject(plumbing.CommitObject, h)
if err != nil {
return nil, err
}
return DecodeCommit(s, o)
}
// DecodeCommit decodes an encoded object into a *Commit and associates it to
// the given object storer.
func DecodeCommit(s storer.EncodedObjectStorer, o plumbing.EncodedObject) (*Commit, error) {
c := &Commit{s: s}
if err := c.Decode(o); err != nil {
return nil, err
}
return c, nil
}
// Tree returns the Tree from the commit.
func (c *Commit) Tree() (*Tree, error) {
return GetTree(c.s, c.TreeHash)
}
// PatchContext returns the Patch between the actual commit and the provided one.
// Error will be return if context expires. Provided context must be non-nil.
//
// NOTE: Since version 5.1.0 the renames are correctly handled, the settings
// used are the recommended options DefaultDiffTreeOptions.
func (c *Commit) PatchContext(ctx context.Context, to *Commit) (*Patch, error) {
fromTree, err := c.Tree()
if err != nil {
return nil, err
}
var toTree *Tree
if to != nil {
toTree, err = to.Tree()
if err != nil {
return nil, err
}
}
return fromTree.PatchContext(ctx, toTree)
}
// Patch returns the Patch between the actual commit and the provided one.
//
// NOTE: Since version 5.1.0 the renames are correctly handled, the settings
// used are the recommended options DefaultDiffTreeOptions.
func (c *Commit) Patch(to *Commit) (*Patch, error) {
return c.PatchContext(context.Background(), to)
}
// Parents return a CommitIter to the parent Commits.
func (c *Commit) Parents() CommitIter {
return NewCommitIter(c.s,
storer.NewEncodedObjectLookupIter(c.s, plumbing.CommitObject, c.ParentHashes),
)
}
// NumParents returns the number of parents in a commit.
func (c *Commit) NumParents() int {
return len(c.ParentHashes)
}
var ErrParentNotFound = errors.New("commit parent not found")
// Parent returns the ith parent of a commit.
func (c *Commit) Parent(i int) (*Commit, error) {
if len(c.ParentHashes) == 0 || i > len(c.ParentHashes)-1 {
return nil, ErrParentNotFound
}
return GetCommit(c.s, c.ParentHashes[i])
}
// File returns the file with the specified "path" in the commit and a
// nil error if the file exists. If the file does not exist, it returns
// a nil file and the ErrFileNotFound error.
func (c *Commit) File(path string) (*File, error) {
tree, err := c.Tree()
if err != nil {
return nil, err
}
return tree.File(path)
}
// Files returns a FileIter allowing to iterate over the Tree
func (c *Commit) Files() (*FileIter, error) {
tree, err := c.Tree()
if err != nil {
return nil, err
}
return tree.Files(), nil
}
// ID returns the object ID of the commit. The returned value will always match
// the current value of Commit.Hash.
//
// ID is present to fulfill the Object interface.
func (c *Commit) ID() plumbing.Hash {
return c.Hash
}
// Type returns the type of object. It always returns plumbing.CommitObject.
//
// Type is present to fulfill the Object interface.
func (c *Commit) Type() plumbing.ObjectType {
return plumbing.CommitObject
}
// Decode transforms a plumbing.EncodedObject into a Commit struct.
func (c *Commit) Decode(o plumbing.EncodedObject) (err error) {
if o.Type() != plumbing.CommitObject {
return ErrUnsupportedObject
}
c.Hash = o.Hash()
c.Encoding = defaultUtf8CommitMessageEncoding
reader, err := o.Reader()
if err != nil {
return err
}
defer ioutil.CheckClose(reader, &err)
r := sync.GetBufioReader(reader)
defer sync.PutBufioReader(r)
var message bool
var mergetag bool
var pgpsig bool
var msgbuf bytes.Buffer
for {
line, err := r.ReadBytes('\n')
if err != nil && err != io.EOF {
return err
}
if mergetag {
if len(line) > 0 && line[0] == ' ' {
line = bytes.TrimLeft(line, " ")
c.MergeTag += string(line)
continue
} else {
mergetag = false
}
}
if pgpsig {
if len(line) > 0 && line[0] == ' ' {
line = bytes.TrimLeft(line, " ")
c.PGPSignature += string(line)
continue
} else {
pgpsig = false
}
}
if !message {
line = bytes.TrimSpace(line)
if len(line) == 0 {
message = true
continue
}
split := bytes.SplitN(line, []byte{' '}, 2)
var data []byte
if len(split) == 2 {
data = split[1]
}
switch string(split[0]) {
case "tree":
c.TreeHash = plumbing.NewHash(string(data))
case "parent":
c.ParentHashes = append(c.ParentHashes, plumbing.NewHash(string(data)))
case "author":
c.Author.Decode(data)
case "committer":
c.Committer.Decode(data)
case headermergetag:
c.MergeTag += string(data) + "\n"
mergetag = true
case headerencoding:
c.Encoding = MessageEncoding(data)
case headerpgp:
c.PGPSignature += string(data) + "\n"
pgpsig = true
}
} else {
msgbuf.Write(line)
}
if err == io.EOF {
break
}
}
c.Message = msgbuf.String()
return nil
}
// Encode transforms a Commit into a plumbing.EncodedObject.
func (c *Commit) Encode(o plumbing.EncodedObject) error {
return c.encode(o, true)
}
// EncodeWithoutSignature export a Commit into a plumbing.EncodedObject without the signature (correspond to the payload of the PGP signature).
func (c *Commit) EncodeWithoutSignature(o plumbing.EncodedObject) error {
return c.encode(o, false)
}
func (c *Commit) encode(o plumbing.EncodedObject, includeSig bool) (err error) {
o.SetType(plumbing.CommitObject)
w, err := o.Writer()
if err != nil {
return err
}
defer ioutil.CheckClose(w, &err)
if _, err = fmt.Fprintf(w, "tree %s\n", c.TreeHash.String()); err != nil {
return err
}
for _, parent := range c.ParentHashes {
if _, err = fmt.Fprintf(w, "parent %s\n", parent.String()); err != nil {
return err
}
}
if _, err = fmt.Fprint(w, "author "); err != nil {
return err
}
if err = c.Author.Encode(w); err != nil {
return err
}
if _, err = fmt.Fprint(w, "\ncommitter "); err != nil {
return err
}
if err = c.Committer.Encode(w); err != nil {
return err
}
if c.MergeTag != "" {
if _, err = fmt.Fprint(w, "\n"+headermergetag+" "); err != nil {
return err
}
// Split tag information lines and re-write with a left padding and
// newline. Use join for this so it's clear that a newline should not be
// added after this section. The newline will be added either as part of
// the PGP signature or the commit message.
mergetag := strings.TrimSuffix(c.MergeTag, "\n")
lines := strings.Split(mergetag, "\n")
if _, err = fmt.Fprint(w, strings.Join(lines, "\n ")); err != nil {
return err
}
}
if string(c.Encoding) != "" && c.Encoding != defaultUtf8CommitMessageEncoding {
if _, err = fmt.Fprintf(w, "\n%s %s", headerencoding, c.Encoding); err != nil {
return err
}
}
if c.PGPSignature != "" && includeSig {
if _, err = fmt.Fprint(w, "\n"+headerpgp+" "); err != nil {
return err
}
// Split all the signature lines and re-write with a left padding and
// newline. Use join for this so it's clear that a newline should not be
// added after this section, as it will be added when the message is
// printed.
signature := strings.TrimSuffix(c.PGPSignature, "\n")
lines := strings.Split(signature, "\n")
if _, err = fmt.Fprint(w, strings.Join(lines, "\n ")); err != nil {
return err
}
}
if _, err = fmt.Fprintf(w, "\n\n%s", c.Message); err != nil {
return err
}
return err
}
// Stats returns the stats of a commit.
func (c *Commit) Stats() (FileStats, error) {
return c.StatsContext(context.Background())
}
// StatsContext returns the stats of a commit. Error will be return if context
// expires. Provided context must be non-nil.
func (c *Commit) StatsContext(ctx context.Context) (FileStats, error) {
fromTree, err := c.Tree()
if err != nil {
return nil, err
}
toTree := &Tree{}
if c.NumParents() != 0 {
firstParent, err := c.Parents().Next()
if err != nil {
return nil, err
}
toTree, err = firstParent.Tree()
if err != nil {
return nil, err
}
}
patch, err := toTree.PatchContext(ctx, fromTree)
if err != nil {
return nil, err
}
return getFileStatsFromFilePatches(patch.FilePatches()), nil
}
func (c *Commit) String() string {
return fmt.Sprintf(
"%s %s\nAuthor: %s\nDate: %s\n\n%s\n",
plumbing.CommitObject, c.Hash, c.Author.String(),
c.Author.When.Format(DateFormat), indent(c.Message),
)
}
// Verify performs PGP verification of the commit with a provided armored
// keyring and returns openpgp.Entity associated with verifying key on success.
func (c *Commit) Verify(armoredKeyRing string) (*openpgp.Entity, error) {
keyRingReader := strings.NewReader(armoredKeyRing)
keyring, err := openpgp.ReadArmoredKeyRing(keyRingReader)
if err != nil {
return nil, err
}
// Extract signature.
signature := strings.NewReader(c.PGPSignature)
encoded := &plumbing.MemoryObject{}
// Encode commit components, excluding signature and get a reader object.
if err := c.EncodeWithoutSignature(encoded); err != nil {
return nil, err
}
er, err := encoded.Reader()
if err != nil {
return nil, err
}
return openpgp.CheckArmoredDetachedSignature(keyring, er, signature, nil)
}
// Less defines a compare function to determine which commit is 'earlier' by:
// - First use Committer.When
// - If Committer.When are equal then use Author.When
// - If Author.When also equal then compare the string value of the hash
func (c *Commit) Less(rhs *Commit) bool {
return c.Committer.When.Before(rhs.Committer.When) ||
(c.Committer.When.Equal(rhs.Committer.When) &&
(c.Author.When.Before(rhs.Author.When) ||
(c.Author.When.Equal(rhs.Author.When) && bytes.Compare(c.Hash[:], rhs.Hash[:]) < 0)))
}
func indent(t string) string {
var output []string
for _, line := range strings.Split(t, "\n") {
if len(line) != 0 {
line = " " + line
}
output = append(output, line)
}
return strings.Join(output, "\n")
}
// CommitIter is a generic closable interface for iterating over commits.
type CommitIter interface {
Next() (*Commit, error)
ForEach(func(*Commit) error) error
Close()
}
// storerCommitIter provides an iterator from commits in an EncodedObjectStorer.
type storerCommitIter struct {
storer.EncodedObjectIter
s storer.EncodedObjectStorer
}
// NewCommitIter takes a storer.EncodedObjectStorer and a
// storer.EncodedObjectIter and returns a CommitIter that iterates over all
// commits contained in the storer.EncodedObjectIter.
//
// Any non-commit object returned by the storer.EncodedObjectIter is skipped.
func NewCommitIter(s storer.EncodedObjectStorer, iter storer.EncodedObjectIter) CommitIter {
return &storerCommitIter{iter, s}
}
// Next moves the iterator to the next commit and returns a pointer to it. If
// there are no more commits, it returns io.EOF.
func (iter *storerCommitIter) Next() (*Commit, error) {
obj, err := iter.EncodedObjectIter.Next()
if err != nil {
return nil, err
}
return DecodeCommit(iter.s, obj)
}
// ForEach call the cb function for each commit contained on this iter until
// an error appends or the end of the iter is reached. If ErrStop is sent
// the iteration is stopped but no error is returned. The iterator is closed.
func (iter *storerCommitIter) ForEach(cb func(*Commit) error) error {
return iter.EncodedObjectIter.ForEach(func(obj plumbing.EncodedObject) error {
c, err := DecodeCommit(iter.s, obj)
if err != nil {
return err
}
return cb(c)
})
}
func (iter *storerCommitIter) Close() {
iter.EncodedObjectIter.Close()
}
go-git-5.13.2/plumbing/object/commit_stats_test.go 0000664 0000000 0000000 00000004515 14744245500 0022161 0 ustar 00root root 0000000 0000000 package object_test
import (
"context"
"time"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/storage/memory"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-billy/v5/util"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type CommitStatsSuite struct {
fixtures.Suite
}
var _ = Suite(&CommitStatsSuite{})
func (s *CommitStatsSuite) TestStats(c *C) {
r, hash := s.writeHistory(c, []byte("foo\n"), []byte("foo\nbar\n"))
aCommit, err := r.CommitObject(hash)
c.Assert(err, IsNil)
fileStats, err := aCommit.StatsContext(context.Background())
c.Assert(err, IsNil)
c.Assert(fileStats[0].Name, Equals, "foo")
c.Assert(fileStats[0].Addition, Equals, 1)
c.Assert(fileStats[0].Deletion, Equals, 0)
c.Assert(fileStats[0].String(), Equals, " foo | 1 +\n")
}
func (s *CommitStatsSuite) TestStats_RootCommit(c *C) {
r, hash := s.writeHistory(c, []byte("foo\n"))
aCommit, err := r.CommitObject(hash)
c.Assert(err, IsNil)
fileStats, err := aCommit.Stats()
c.Assert(err, IsNil)
c.Assert(fileStats, HasLen, 1)
c.Assert(fileStats[0].Name, Equals, "foo")
c.Assert(fileStats[0].Addition, Equals, 1)
c.Assert(fileStats[0].Deletion, Equals, 0)
c.Assert(fileStats[0].String(), Equals, " foo | 1 +\n")
}
func (s *CommitStatsSuite) TestStats_WithoutNewLine(c *C) {
r, hash := s.writeHistory(c, []byte("foo\nbar"), []byte("foo\nbar\n"))
aCommit, err := r.CommitObject(hash)
c.Assert(err, IsNil)
fileStats, err := aCommit.Stats()
c.Assert(err, IsNil)
c.Assert(fileStats[0].Name, Equals, "foo")
c.Assert(fileStats[0].Addition, Equals, 1)
c.Assert(fileStats[0].Deletion, Equals, 1)
c.Assert(fileStats[0].String(), Equals, " foo | 2 +-\n")
}
func (s *CommitStatsSuite) writeHistory(c *C, files ...[]byte) (*git.Repository, plumbing.Hash) {
cm := &git.CommitOptions{
Author: &object.Signature{Name: "Foo", Email: "foo@example.local", When: time.Now()},
}
fs := memfs.New()
r, err := git.Init(memory.NewStorage(), fs)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
var hash plumbing.Hash
for _, content := range files {
util.WriteFile(fs, "foo", content, 0644)
_, err = w.Add("foo")
c.Assert(err, IsNil)
hash, err = w.Commit("foo\n", cm)
c.Assert(err, IsNil)
}
return r, hash
}
go-git-5.13.2/plumbing/object/commit_test.go 0000664 0000000 0000000 00000045622 14744245500 0020747 0 ustar 00root root 0000000 0000000 package object
import (
"bytes"
"context"
"fmt"
"io"
"strings"
"time"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/storage/filesystem"
. "gopkg.in/check.v1"
)
type SuiteCommit struct {
BaseObjectsSuite
Commit *Commit
}
var _ = Suite(&SuiteCommit{})
func (s *SuiteCommit) SetUpSuite(c *C) {
s.BaseObjectsSuite.SetUpSuite(c)
hash := plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea")
s.Commit = s.commit(c, hash)
}
func (s *SuiteCommit) TestDecodeNonCommit(c *C) {
hash := plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492")
blob, err := s.Storer.EncodedObject(plumbing.AnyObject, hash)
c.Assert(err, IsNil)
commit := &Commit{}
err = commit.Decode(blob)
c.Assert(err, Equals, ErrUnsupportedObject)
}
func (s *SuiteCommit) TestType(c *C) {
c.Assert(s.Commit.Type(), Equals, plumbing.CommitObject)
}
func (s *SuiteCommit) TestTree(c *C) {
tree, err := s.Commit.Tree()
c.Assert(err, IsNil)
c.Assert(tree.ID().String(), Equals, "eba74343e2f15d62adedfd8c883ee0262b5c8021")
}
func (s *SuiteCommit) TestParents(c *C) {
expected := []string{
"35e85108805c84807bc66a02d91535e1e24b38b9",
"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
}
var output []string
i := s.Commit.Parents()
err := i.ForEach(func(commit *Commit) error {
output = append(output, commit.ID().String())
return nil
})
c.Assert(err, IsNil)
c.Assert(output, DeepEquals, expected)
i.Close()
}
func (s *SuiteCommit) TestParent(c *C) {
commit, err := s.Commit.Parent(1)
c.Assert(err, IsNil)
c.Assert(commit.Hash.String(), Equals, "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69")
}
func (s *SuiteCommit) TestParentNotFound(c *C) {
commit, err := s.Commit.Parent(42)
c.Assert(err, Equals, ErrParentNotFound)
c.Assert(commit, IsNil)
}
func (s *SuiteCommit) TestPatch(c *C) {
from := s.commit(c, plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"))
to := s.commit(c, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
patch, err := from.Patch(to)
c.Assert(err, IsNil)
buf := bytes.NewBuffer(nil)
err = patch.Encode(buf)
c.Assert(err, IsNil)
c.Assert(buf.String(), Equals, `diff --git a/vendor/foo.go b/vendor/foo.go
new file mode 100644
index 0000000000000000000000000000000000000000..9dea2395f5403188298c1dabe8bdafe562c491e3
--- /dev/null
+++ b/vendor/foo.go
@@ -0,0 +1,7 @@
+package main
+
+import "fmt"
+
+func main() {
+ fmt.Println("Hello, playground")
+}
`)
c.Assert(buf.String(), Equals, patch.String())
from = s.commit(c, plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"))
to = s.commit(c, plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"))
patch, err = from.Patch(to)
c.Assert(err, IsNil)
buf.Reset()
err = patch.Encode(buf)
c.Assert(err, IsNil)
c.Assert(buf.String(), Equals, `diff --git a/CHANGELOG b/CHANGELOG
deleted file mode 100644
index d3ff53e0564a9f87d8e84b6e28e5060e517008aa..0000000000000000000000000000000000000000
--- a/CHANGELOG
+++ /dev/null
@@ -1 +0,0 @@
-Initial changelog
diff --git a/binary.jpg b/binary.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..d5c0f4ab811897cadf03aec358ae60d21f91c50d
Binary files /dev/null and b/binary.jpg differ
`)
c.Assert(buf.String(), Equals, patch.String())
}
func (s *SuiteCommit) TestPatchContext(c *C) {
from := s.commit(c, plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"))
to := s.commit(c, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
patch, err := from.PatchContext(context.Background(), to)
c.Assert(err, IsNil)
buf := bytes.NewBuffer(nil)
err = patch.Encode(buf)
c.Assert(err, IsNil)
c.Assert(buf.String(), Equals, `diff --git a/vendor/foo.go b/vendor/foo.go
new file mode 100644
index 0000000000000000000000000000000000000000..9dea2395f5403188298c1dabe8bdafe562c491e3
--- /dev/null
+++ b/vendor/foo.go
@@ -0,0 +1,7 @@
+package main
+
+import "fmt"
+
+func main() {
+ fmt.Println("Hello, playground")
+}
`)
c.Assert(buf.String(), Equals, patch.String())
from = s.commit(c, plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"))
to = s.commit(c, plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"))
patch, err = from.PatchContext(context.Background(), to)
c.Assert(err, IsNil)
buf.Reset()
err = patch.Encode(buf)
c.Assert(err, IsNil)
c.Assert(buf.String(), Equals, `diff --git a/CHANGELOG b/CHANGELOG
deleted file mode 100644
index d3ff53e0564a9f87d8e84b6e28e5060e517008aa..0000000000000000000000000000000000000000
--- a/CHANGELOG
+++ /dev/null
@@ -1 +0,0 @@
-Initial changelog
diff --git a/binary.jpg b/binary.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..d5c0f4ab811897cadf03aec358ae60d21f91c50d
Binary files /dev/null and b/binary.jpg differ
`)
c.Assert(buf.String(), Equals, patch.String())
}
func (s *SuiteCommit) TestPatchContext_ToNil(c *C) {
from := s.commit(c, plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"))
patch, err := from.PatchContext(context.Background(), nil)
c.Assert(err, IsNil)
c.Assert(len(patch.String()), Equals, 242679)
}
func (s *SuiteCommit) TestCommitEncodeDecodeIdempotent(c *C) {
pgpsignature := `-----BEGIN PGP SIGNATURE-----
iQEcBAABAgAGBQJTZbQlAAoJEF0+sviABDDrZbQH/09PfE51KPVPlanr6q1v4/Ut
LQxfojUWiLQdg2ESJItkcuweYg+kc3HCyFejeDIBw9dpXt00rY26p05qrpnG+85b
hM1/PswpPLuBSr+oCIDj5GMC2r2iEKsfv2fJbNW8iWAXVLoWZRF8B0MfqX/YTMbm
ecorc4iXzQu7tupRihslbNkfvfciMnSDeSvzCpWAHl7h8Wj6hhqePmLm9lAYqnKp
8S5B/1SSQuEAjRZgI4IexpZoeKGVDptPHxLLS38fozsyi0QyDyzEgJxcJQVMXxVi
RUysgqjcpT8+iQM1PblGfHR4XAhuOqN5Fx06PSaFZhqvWFezJ28/CLyX5q+oIVk=
=EFTF
-----END PGP SIGNATURE-----
`
tag := fmt.Sprintf(`object f000000000000000000000000000000000000000
type commit
tag change
tagger Foo 1695827841 -0400
change
%s
`, pgpsignature)
ts, err := time.Parse(time.RFC3339, "2006-01-02T15:04:05-07:00")
c.Assert(err, IsNil)
commits := []*Commit{
{
Author: Signature{Name: "Foo", Email: "foo@example.local", When: ts},
Committer: Signature{Name: "Bar", Email: "bar@example.local", When: ts},
Message: "Message\n\nFoo\nBar\nWith trailing blank lines\n\n",
TreeHash: plumbing.NewHash("f000000000000000000000000000000000000001"),
ParentHashes: []plumbing.Hash{plumbing.NewHash("f000000000000000000000000000000000000002")},
Encoding: defaultUtf8CommitMessageEncoding,
},
{
Author: Signature{Name: "Foo", Email: "foo@example.local", When: ts},
Committer: Signature{Name: "Bar", Email: "bar@example.local", When: ts},
Message: "Message\n\nFoo\nBar\nWith no trailing blank lines",
TreeHash: plumbing.NewHash("0000000000000000000000000000000000000003"),
ParentHashes: []plumbing.Hash{
plumbing.NewHash("f000000000000000000000000000000000000004"),
plumbing.NewHash("f000000000000000000000000000000000000005"),
plumbing.NewHash("f000000000000000000000000000000000000006"),
plumbing.NewHash("f000000000000000000000000000000000000007"),
},
Encoding: MessageEncoding("ISO-8859-1"),
},
{
Author: Signature{Name: "Foo", Email: "foo@example.local", When: ts},
Committer: Signature{Name: "Bar", Email: "bar@example.local", When: ts},
Message: "Testing mergetag\n\nHere, commit is not signed",
TreeHash: plumbing.NewHash("f000000000000000000000000000000000000001"),
ParentHashes: []plumbing.Hash{
plumbing.NewHash("f000000000000000000000000000000000000002"),
plumbing.NewHash("f000000000000000000000000000000000000003"),
},
MergeTag: tag,
Encoding: defaultUtf8CommitMessageEncoding,
},
{
Author: Signature{Name: "Foo", Email: "foo@example.local", When: ts},
Committer: Signature{Name: "Bar", Email: "bar@example.local", When: ts},
Message: "Testing mergetag\n\nHere, commit is also signed",
TreeHash: plumbing.NewHash("f000000000000000000000000000000000000001"),
ParentHashes: []plumbing.Hash{
plumbing.NewHash("f000000000000000000000000000000000000002"),
plumbing.NewHash("f000000000000000000000000000000000000003"),
},
MergeTag: tag,
PGPSignature: pgpsignature,
Encoding: defaultUtf8CommitMessageEncoding,
},
}
for _, commit := range commits {
obj := &plumbing.MemoryObject{}
err = commit.Encode(obj)
c.Assert(err, IsNil)
newCommit := &Commit{}
err = newCommit.Decode(obj)
c.Assert(err, IsNil)
commit.Hash = obj.Hash()
c.Assert(newCommit, DeepEquals, commit)
}
}
func (s *SuiteCommit) TestFile(c *C) {
file, err := s.Commit.File("CHANGELOG")
c.Assert(err, IsNil)
c.Assert(file.Name, Equals, "CHANGELOG")
}
func (s *SuiteCommit) TestNumParents(c *C) {
c.Assert(s.Commit.NumParents(), Equals, 2)
}
func (s *SuiteCommit) TestString(c *C) {
c.Assert(s.Commit.String(), Equals, ""+
"commit 1669dce138d9b841a518c64b10914d88f5e488ea\n"+
"Author: Máximo Cuadros Ortiz \n"+
"Date: Tue Mar 31 13:48:14 2015 +0200\n"+
"\n"+
" Merge branch 'master' of github.com:tyba/git-fixture\n"+
"\n",
)
}
func (s *SuiteCommit) TestStringMultiLine(c *C) {
hash := plumbing.NewHash("e7d896db87294e33ca3202e536d4d9bb16023db3")
f := fixtures.ByURL("https://github.com/src-d/go-git.git").One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
o, err := sto.EncodedObject(plumbing.CommitObject, hash)
c.Assert(err, IsNil)
commit, err := DecodeCommit(sto, o)
c.Assert(err, IsNil)
c.Assert(commit.String(), Equals, ""+
"commit e7d896db87294e33ca3202e536d4d9bb16023db3\n"+
"Author: Alberto Cortés \n"+
"Date: Wed Jan 27 11:13:49 2016 +0100\n"+
"\n"+
" fix zlib invalid header error\n"+
"\n"+
" The return value of reads to the packfile were being ignored, so zlib\n"+
" was getting invalid data on it read buffers.\n"+
"\n",
)
}
func (s *SuiteCommit) TestCommitIterNext(c *C) {
i := s.Commit.Parents()
commit, err := i.Next()
c.Assert(err, IsNil)
c.Assert(commit.ID().String(), Equals, "35e85108805c84807bc66a02d91535e1e24b38b9")
commit, err = i.Next()
c.Assert(err, IsNil)
c.Assert(commit.ID().String(), Equals, "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69")
commit, err = i.Next()
c.Assert(err, Equals, io.EOF)
c.Assert(commit, IsNil)
}
func (s *SuiteCommit) TestLongCommitMessageSerialization(c *C) {
encoded := &plumbing.MemoryObject{}
decoded := &Commit{}
commit := *s.Commit
longMessage := "my message: message\n\n" + strings.Repeat("test", 4096) + "\nOK"
commit.Message = longMessage
err := commit.Encode(encoded)
c.Assert(err, IsNil)
err = decoded.Decode(encoded)
c.Assert(err, IsNil)
c.Assert(decoded.Message, Equals, longMessage)
}
func (s *SuiteCommit) TestPGPSignatureSerialization(c *C) {
encoded := &plumbing.MemoryObject{}
decoded := &Commit{}
commit := *s.Commit
pgpsignature := `-----BEGIN PGP SIGNATURE-----
iQEcBAABAgAGBQJTZbQlAAoJEF0+sviABDDrZbQH/09PfE51KPVPlanr6q1v4/Ut
LQxfojUWiLQdg2ESJItkcuweYg+kc3HCyFejeDIBw9dpXt00rY26p05qrpnG+85b
hM1/PswpPLuBSr+oCIDj5GMC2r2iEKsfv2fJbNW8iWAXVLoWZRF8B0MfqX/YTMbm
ecorc4iXzQu7tupRihslbNkfvfciMnSDeSvzCpWAHl7h8Wj6hhqePmLm9lAYqnKp
8S5B/1SSQuEAjRZgI4IexpZoeKGVDptPHxLLS38fozsyi0QyDyzEgJxcJQVMXxVi
RUysgqjcpT8+iQM1PblGfHR4XAhuOqN5Fx06PSaFZhqvWFezJ28/CLyX5q+oIVk=
=EFTF
-----END PGP SIGNATURE-----
`
commit.PGPSignature = pgpsignature
err := commit.Encode(encoded)
c.Assert(err, IsNil)
err = decoded.Decode(encoded)
c.Assert(err, IsNil)
c.Assert(decoded.PGPSignature, Equals, pgpsignature)
// signature with extra empty line, it caused "index out of range" when
// parsing it
pgpsignature2 := "\n" + pgpsignature
commit.PGPSignature = pgpsignature2
encoded = &plumbing.MemoryObject{}
decoded = &Commit{}
err = commit.Encode(encoded)
c.Assert(err, IsNil)
err = decoded.Decode(encoded)
c.Assert(err, IsNil)
c.Assert(decoded.PGPSignature, Equals, pgpsignature2)
// signature in author name
commit.PGPSignature = ""
commit.Author.Name = beginpgp
encoded = &plumbing.MemoryObject{}
decoded = &Commit{}
err = commit.Encode(encoded)
c.Assert(err, IsNil)
err = decoded.Decode(encoded)
c.Assert(err, IsNil)
c.Assert(decoded.PGPSignature, Equals, "")
c.Assert(decoded.Author.Name, Equals, beginpgp)
// broken signature
commit.PGPSignature = beginpgp + "\n" +
"some\n" +
"trash\n" +
endpgp +
"text\n"
encoded = &plumbing.MemoryObject{}
decoded = &Commit{}
err = commit.Encode(encoded)
c.Assert(err, IsNil)
err = decoded.Decode(encoded)
c.Assert(err, IsNil)
c.Assert(decoded.PGPSignature, Equals, commit.PGPSignature)
}
func (s *SuiteCommit) TestStat(c *C) {
aCommit := s.commit(c, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
fileStats, err := aCommit.Stats()
c.Assert(err, IsNil)
c.Assert(fileStats[0].Name, Equals, "vendor/foo.go")
c.Assert(fileStats[0].Addition, Equals, 7)
c.Assert(fileStats[0].Deletion, Equals, 0)
c.Assert(fileStats[0].String(), Equals, " vendor/foo.go | 7 +++++++\n")
// Stats for another commit.
aCommit = s.commit(c, plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"))
fileStats, err = aCommit.Stats()
c.Assert(err, IsNil)
c.Assert(fileStats[0].Name, Equals, "go/example.go")
c.Assert(fileStats[0].Addition, Equals, 142)
c.Assert(fileStats[0].Deletion, Equals, 0)
c.Assert(fileStats[0].String(), Equals, " go/example.go | 142 +++++++++++++++++++++++++++++++++++++++++++++++++++++\n")
c.Assert(fileStats[1].Name, Equals, "php/crappy.php")
c.Assert(fileStats[1].Addition, Equals, 259)
c.Assert(fileStats[1].Deletion, Equals, 0)
c.Assert(fileStats[1].String(), Equals, " php/crappy.php | 259 +++++++++++++++++++++++++++++++++++++++++++++++++++++\n")
}
func (s *SuiteCommit) TestVerify(c *C) {
ts := time.Unix(1617402711, 0)
loc, _ := time.LoadLocation("UTC")
commit := &Commit{
Hash: plumbing.NewHash("1eca38290a3131d0c90709496a9b2207a872631e"),
Author: Signature{Name: "go-git", Email: "go-git@example.com", When: ts.In(loc)},
Committer: Signature{Name: "go-git", Email: "go-git@example.com", When: ts.In(loc)},
Message: `test
`,
TreeHash: plumbing.NewHash("52a266a58f2c028ad7de4dfd3a72fdf76b0d4e24"),
ParentHashes: []plumbing.Hash{plumbing.NewHash("e4fbb611cd14149c7a78e9c08425f59f4b736a9a")},
PGPSignature: `
-----BEGIN PGP SIGNATURE-----
iHUEABYKAB0WIQTMqU0ycQ3f6g3PMoWMmmmF4LuV8QUCYGebVwAKCRCMmmmF4LuV
8VtyAP9LbuXAhtK6FQqOjKybBwlV70rLcXVP24ubDuz88VVwSgD+LuObsasWq6/U
TssDKHUR2taa53bQYjkZQBpvvwOrLgc=
=YQUf
-----END PGP SIGNATURE-----
`,
}
armoredKeyRing := `
-----BEGIN PGP PUBLIC KEY BLOCK-----
mDMEYGeSihYJKwYBBAHaRw8BAQdAIs9A3YD/EghhAOkHDkxlUkpqYrXUXebLfmmX
+pdEK6C0D2dvLWdpdCB0ZXN0IGtleYiPBBMWCgA3FiEEzKlNMnEN3+oNzzKFjJpp
heC7lfEFAmBnkooCGyMECwkIBwUVCgkICwUWAwIBAAIeAQIXgAAKCRCMmmmF4LuV
8a3jAQCi4hSqjj6J3ch290FvQaYPGwR+EMQTMBG54t+NN6sDfgD/aZy41+0dnFKl
qM/wLW5Wr9XvwH+1zXXbuSvfxasHowq4OARgZ5KKEgorBgEEAZdVAQUBAQdAXoQz
VTYug16SisAoSrxFnOmxmFu6efYgCAwXu0ZuvzsDAQgHiHgEGBYKACAWIQTMqU0y
cQ3f6g3PMoWMmmmF4LuV8QUCYGeSigIbDAAKCRCMmmmF4LuV8Q4QAQCKW5FnEdWW
lHYKeByw3JugnlZ0U3V/R20bCwDglst5UQEAtkN2iZkHtkPly9xapsfNqnrt2gTt
YIefGtzXfldDxg4=
=Psht
-----END PGP PUBLIC KEY BLOCK-----
`
e, err := commit.Verify(armoredKeyRing)
c.Assert(err, IsNil)
_, ok := e.Identities["go-git test key"]
c.Assert(ok, Equals, true)
}
func (s *SuiteCommit) TestPatchCancel(c *C) {
from := s.commit(c, plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"))
to := s.commit(c, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
ctx, cancel := context.WithCancel(context.Background())
cancel()
patch, err := from.PatchContext(ctx, to)
c.Assert(patch, IsNil)
c.Assert(err, ErrorMatches, "operation canceled")
}
func (s *SuiteCommit) TestMalformedHeader(c *C) {
encoded := &plumbing.MemoryObject{}
decoded := &Commit{}
commit := *s.Commit
commit.PGPSignature = "\n"
commit.Author.Name = "\n"
commit.Author.Email = "\n"
commit.Committer.Name = "\n"
commit.Committer.Email = "\n"
err := commit.Encode(encoded)
c.Assert(err, IsNil)
err = decoded.Decode(encoded)
c.Assert(err, IsNil)
}
func (s *SuiteCommit) TestEncodeWithoutSignature(c *C) {
// Similar to TestString since no signature
encoded := &plumbing.MemoryObject{}
err := s.Commit.EncodeWithoutSignature(encoded)
c.Assert(err, IsNil)
er, err := encoded.Reader()
c.Assert(err, IsNil)
payload, err := io.ReadAll(er)
c.Assert(err, IsNil)
c.Assert(string(payload), Equals, ""+
"tree eba74343e2f15d62adedfd8c883ee0262b5c8021\n"+
"parent 35e85108805c84807bc66a02d91535e1e24b38b9\n"+
"parent a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69\n"+
"author Máximo Cuadros Ortiz 1427802494 +0200\n"+
"committer Máximo Cuadros Ortiz 1427802494 +0200\n"+
"\n"+
"Merge branch 'master' of github.com:tyba/git-fixture\n")
}
func (s *SuiteCommit) TestLess(c *C) {
when1 := time.Now()
when2 := when1.Add(time.Hour)
hash1 := plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea")
hash2 := plumbing.NewHash("2669dce138d9b841a518c64b10914d88f5e488ea")
commitLessTests := []struct {
Committer1When, Committer2When time.Time
Author1When, Author2When time.Time
Hash1, Hash2 plumbing.Hash
Exp bool
}{
{when1, when1, when1, when1, hash1, hash2, true},
{when1, when1, when1, when1, hash2, hash1, false},
{when1, when1, when1, when2, hash1, hash2, true},
{when1, when1, when1, when2, hash2, hash1, true},
{when1, when1, when2, when1, hash1, hash2, false},
{when1, when1, when2, when1, hash2, hash1, false},
{when1, when1, when2, when2, hash1, hash2, true},
{when1, when1, when2, when2, hash2, hash1, false},
{when1, when2, when1, when1, hash1, hash2, true},
{when1, when2, when1, when1, hash2, hash1, true},
{when1, when2, when1, when2, hash1, hash2, true},
{when1, when2, when1, when2, hash2, hash1, true},
{when1, when2, when2, when1, hash1, hash2, true},
{when1, when2, when2, when1, hash2, hash1, true},
{when1, when2, when2, when2, hash1, hash2, true},
{when1, when2, when2, when2, hash2, hash1, true},
{when2, when1, when1, when1, hash1, hash2, false},
{when2, when1, when1, when1, hash2, hash1, false},
{when2, when1, when1, when2, hash1, hash2, false},
{when2, when1, when1, when2, hash2, hash1, false},
{when2, when1, when2, when1, hash1, hash2, false},
{when2, when1, when2, when1, hash2, hash1, false},
{when2, when1, when2, when2, hash1, hash2, false},
{when2, when1, when2, when2, hash2, hash1, false},
{when2, when2, when1, when1, hash1, hash2, true},
{when2, when2, when1, when1, hash2, hash1, false},
{when2, when2, when1, when2, hash1, hash2, true},
{when2, when2, when1, when2, hash2, hash1, true},
{when2, when2, when2, when1, hash1, hash2, false},
{when2, when2, when2, when1, hash2, hash1, false},
{when2, when2, when2, when2, hash1, hash2, true},
{when2, when2, when2, when2, hash2, hash1, false},
}
for _, t := range commitLessTests {
commit1 := &Commit{
Hash: t.Hash1,
Author: Signature{
When: t.Author1When,
},
Committer: Signature{
When: t.Committer1When,
},
}
commit2 := &Commit{
Hash: t.Hash2,
Author: Signature{
When: t.Author2When,
},
Committer: Signature{
When: t.Committer2When,
},
}
c.Assert(commit1.Less(commit2), Equals, t.Exp)
}
}
go-git-5.13.2/plumbing/object/commit_walker.go 0000664 0000000 0000000 00000015505 14744245500 0021252 0 ustar 00root root 0000000 0000000 package object
import (
"container/list"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage"
)
type commitPreIterator struct {
seenExternal map[plumbing.Hash]bool
seen map[plumbing.Hash]bool
stack []CommitIter
start *Commit
}
// NewCommitPreorderIter returns a CommitIter that walks the commit history,
// starting at the given commit and visiting its parents in pre-order.
// The given callback will be called for each visited commit. Each commit will
// be visited only once. If the callback returns an error, walking will stop
// and will return the error. Other errors might be returned if the history
// cannot be traversed (e.g. missing objects). Ignore allows to skip some
// commits from being iterated.
func NewCommitPreorderIter(
c *Commit,
seenExternal map[plumbing.Hash]bool,
ignore []plumbing.Hash,
) CommitIter {
seen := make(map[plumbing.Hash]bool)
for _, h := range ignore {
seen[h] = true
}
return &commitPreIterator{
seenExternal: seenExternal,
seen: seen,
stack: make([]CommitIter, 0),
start: c,
}
}
func (w *commitPreIterator) Next() (*Commit, error) {
var c *Commit
for {
if w.start != nil {
c = w.start
w.start = nil
} else {
current := len(w.stack) - 1
if current < 0 {
return nil, io.EOF
}
var err error
c, err = w.stack[current].Next()
if err == io.EOF {
w.stack = w.stack[:current]
continue
}
if err != nil {
return nil, err
}
}
if w.seen[c.Hash] || w.seenExternal[c.Hash] {
continue
}
w.seen[c.Hash] = true
if c.NumParents() > 0 {
w.stack = append(w.stack, filteredParentIter(c, w.seen))
}
return c, nil
}
}
func filteredParentIter(c *Commit, seen map[plumbing.Hash]bool) CommitIter {
var hashes []plumbing.Hash
for _, h := range c.ParentHashes {
if !seen[h] {
hashes = append(hashes, h)
}
}
return NewCommitIter(c.s,
storer.NewEncodedObjectLookupIter(c.s, plumbing.CommitObject, hashes),
)
}
func (w *commitPreIterator) ForEach(cb func(*Commit) error) error {
for {
c, err := w.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
err = cb(c)
if err == storer.ErrStop {
break
}
if err != nil {
return err
}
}
return nil
}
func (w *commitPreIterator) Close() {}
type commitPostIterator struct {
stack []*Commit
seen map[plumbing.Hash]bool
}
// NewCommitPostorderIter returns a CommitIter that walks the commit
// history like WalkCommitHistory but in post-order. This means that after
// walking a merge commit, the merged commit will be walked before the base
// it was merged on. This can be useful if you wish to see the history in
// chronological order. Ignore allows to skip some commits from being iterated.
func NewCommitPostorderIter(c *Commit, ignore []plumbing.Hash) CommitIter {
seen := make(map[plumbing.Hash]bool)
for _, h := range ignore {
seen[h] = true
}
return &commitPostIterator{
stack: []*Commit{c},
seen: seen,
}
}
func (w *commitPostIterator) Next() (*Commit, error) {
for {
if len(w.stack) == 0 {
return nil, io.EOF
}
c := w.stack[len(w.stack)-1]
w.stack = w.stack[:len(w.stack)-1]
if w.seen[c.Hash] {
continue
}
w.seen[c.Hash] = true
return c, c.Parents().ForEach(func(p *Commit) error {
w.stack = append(w.stack, p)
return nil
})
}
}
func (w *commitPostIterator) ForEach(cb func(*Commit) error) error {
for {
c, err := w.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
err = cb(c)
if err == storer.ErrStop {
break
}
if err != nil {
return err
}
}
return nil
}
func (w *commitPostIterator) Close() {}
// commitAllIterator stands for commit iterator for all refs.
type commitAllIterator struct {
// currCommit points to the current commit.
currCommit *list.Element
}
// NewCommitAllIter returns a new commit iterator for all refs.
// repoStorer is a repo Storer used to get commits and references.
// commitIterFunc is a commit iterator function, used to iterate through ref commits in chosen order
func NewCommitAllIter(repoStorer storage.Storer, commitIterFunc func(*Commit) CommitIter) (CommitIter, error) {
commitsPath := list.New()
commitsLookup := make(map[plumbing.Hash]*list.Element)
head, err := storer.ResolveReference(repoStorer, plumbing.HEAD)
if err == nil {
err = addReference(repoStorer, commitIterFunc, head, commitsPath, commitsLookup)
}
if err != nil && err != plumbing.ErrReferenceNotFound {
return nil, err
}
// add all references along with the HEAD
refIter, err := repoStorer.IterReferences()
if err != nil {
return nil, err
}
defer refIter.Close()
for {
ref, err := refIter.Next()
if err == io.EOF {
break
}
if err == plumbing.ErrReferenceNotFound {
continue
}
if err != nil {
return nil, err
}
if err = addReference(repoStorer, commitIterFunc, ref, commitsPath, commitsLookup); err != nil {
return nil, err
}
}
return &commitAllIterator{commitsPath.Front()}, nil
}
func addReference(
repoStorer storage.Storer,
commitIterFunc func(*Commit) CommitIter,
ref *plumbing.Reference,
commitsPath *list.List,
commitsLookup map[plumbing.Hash]*list.Element) error {
_, exists := commitsLookup[ref.Hash()]
if exists {
// we already have it - skip the reference.
return nil
}
refCommit, _ := GetCommit(repoStorer, ref.Hash())
if refCommit == nil {
// if it's not a commit - skip it.
return nil
}
var (
refCommits []*Commit
parent *list.Element
)
// collect all ref commits to add
commitIter := commitIterFunc(refCommit)
for c, e := commitIter.Next(); e == nil; {
parent, exists = commitsLookup[c.Hash]
if exists {
break
}
refCommits = append(refCommits, c)
c, e = commitIter.Next()
}
commitIter.Close()
if parent == nil {
// common parent - not found
// add all commits to the path from this ref (maybe it's a HEAD and we don't have anything, yet)
for _, c := range refCommits {
parent = commitsPath.PushBack(c)
commitsLookup[c.Hash] = parent
}
} else {
// add ref's commits to the path in reverse order (from the latest)
for i := len(refCommits) - 1; i >= 0; i-- {
c := refCommits[i]
// insert before found common parent
parent = commitsPath.InsertBefore(c, parent)
commitsLookup[c.Hash] = parent
}
}
return nil
}
func (it *commitAllIterator) Next() (*Commit, error) {
if it.currCommit == nil {
return nil, io.EOF
}
c := it.currCommit.Value.(*Commit)
it.currCommit = it.currCommit.Next()
return c, nil
}
func (it *commitAllIterator) ForEach(cb func(*Commit) error) error {
for {
c, err := it.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
err = cb(c)
if err == storer.ErrStop {
break
}
if err != nil {
return err
}
}
return nil
}
func (it *commitAllIterator) Close() {
it.currCommit = nil
}
go-git-5.13.2/plumbing/object/commit_walker_bfs.go 0000664 0000000 0000000 00000003753 14744245500 0022106 0 ustar 00root root 0000000 0000000 package object
import (
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
)
type bfsCommitIterator struct {
seenExternal map[plumbing.Hash]bool
seen map[plumbing.Hash]bool
queue []*Commit
}
// NewCommitIterBSF returns a CommitIter that walks the commit history,
// starting at the given commit and visiting its parents in pre-order.
// The given callback will be called for each visited commit. Each commit will
// be visited only once. If the callback returns an error, walking will stop
// and will return the error. Other errors might be returned if the history
// cannot be traversed (e.g. missing objects). Ignore allows to skip some
// commits from being iterated.
func NewCommitIterBSF(
c *Commit,
seenExternal map[plumbing.Hash]bool,
ignore []plumbing.Hash,
) CommitIter {
seen := make(map[plumbing.Hash]bool)
for _, h := range ignore {
seen[h] = true
}
return &bfsCommitIterator{
seenExternal: seenExternal,
seen: seen,
queue: []*Commit{c},
}
}
func (w *bfsCommitIterator) appendHash(store storer.EncodedObjectStorer, h plumbing.Hash) error {
if w.seen[h] || w.seenExternal[h] {
return nil
}
c, err := GetCommit(store, h)
if err != nil {
return err
}
w.queue = append(w.queue, c)
return nil
}
func (w *bfsCommitIterator) Next() (*Commit, error) {
var c *Commit
for {
if len(w.queue) == 0 {
return nil, io.EOF
}
c = w.queue[0]
w.queue = w.queue[1:]
if w.seen[c.Hash] || w.seenExternal[c.Hash] {
continue
}
w.seen[c.Hash] = true
for _, h := range c.ParentHashes {
err := w.appendHash(c.s, h)
if err != nil {
return nil, err
}
}
return c, nil
}
}
func (w *bfsCommitIterator) ForEach(cb func(*Commit) error) error {
for {
c, err := w.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
err = cb(c)
if err == storer.ErrStop {
break
}
if err != nil {
return err
}
}
return nil
}
func (w *bfsCommitIterator) Close() {}
go-git-5.13.2/plumbing/object/commit_walker_bfs_filtered.go 0000664 0000000 0000000 00000007701 14744245500 0023761 0 ustar 00root root 0000000 0000000 package object
import (
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
)
// NewFilterCommitIter returns a CommitIter that walks the commit history,
// starting at the passed commit and visiting its parents in Breadth-first order.
// The commits returned by the CommitIter will validate the passed CommitFilter.
// The history won't be transversed beyond a commit if isLimit is true for it.
// Each commit will be visited only once.
// If the commit history can not be traversed, or the Close() method is called,
// the CommitIter won't return more commits.
// If no isValid is passed, all ancestors of from commit will be valid.
// If no isLimit is limit, all ancestors of all commits will be visited.
func NewFilterCommitIter(
from *Commit,
isValid *CommitFilter,
isLimit *CommitFilter,
) CommitIter {
var validFilter CommitFilter
if isValid == nil {
validFilter = func(_ *Commit) bool {
return true
}
} else {
validFilter = *isValid
}
var limitFilter CommitFilter
if isLimit == nil {
limitFilter = func(_ *Commit) bool {
return false
}
} else {
limitFilter = *isLimit
}
return &filterCommitIter{
isValid: validFilter,
isLimit: limitFilter,
visited: map[plumbing.Hash]struct{}{},
queue: []*Commit{from},
}
}
// CommitFilter returns a boolean for the passed Commit
type CommitFilter func(*Commit) bool
// filterCommitIter implements CommitIter
type filterCommitIter struct {
isValid CommitFilter
isLimit CommitFilter
visited map[plumbing.Hash]struct{}
queue []*Commit
lastErr error
}
// Next returns the next commit of the CommitIter.
// It will return io.EOF if there are no more commits to visit,
// or an error if the history could not be traversed.
func (w *filterCommitIter) Next() (*Commit, error) {
var commit *Commit
var err error
for {
commit, err = w.popNewFromQueue()
if err != nil {
return nil, w.close(err)
}
w.visited[commit.Hash] = struct{}{}
if !w.isLimit(commit) {
err = w.addToQueue(commit.s, commit.ParentHashes...)
if err != nil {
return nil, w.close(err)
}
}
if w.isValid(commit) {
return commit, nil
}
}
}
// ForEach runs the passed callback over each Commit returned by the CommitIter
// until the callback returns an error or there is no more commits to traverse.
func (w *filterCommitIter) ForEach(cb func(*Commit) error) error {
for {
commit, err := w.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
if err := cb(commit); err == storer.ErrStop {
break
} else if err != nil {
return err
}
}
return nil
}
// Error returns the error that caused that the CommitIter is no longer returning commits
func (w *filterCommitIter) Error() error {
return w.lastErr
}
// Close closes the CommitIter
func (w *filterCommitIter) Close() {
w.visited = map[plumbing.Hash]struct{}{}
w.queue = []*Commit{}
w.isLimit = nil
w.isValid = nil
}
// close closes the CommitIter with an error
func (w *filterCommitIter) close(err error) error {
w.Close()
w.lastErr = err
return err
}
// popNewFromQueue returns the first new commit from the internal fifo queue,
// or an io.EOF error if the queue is empty
func (w *filterCommitIter) popNewFromQueue() (*Commit, error) {
var first *Commit
for {
if len(w.queue) == 0 {
if w.lastErr != nil {
return nil, w.lastErr
}
return nil, io.EOF
}
first = w.queue[0]
w.queue = w.queue[1:]
if _, ok := w.visited[first.Hash]; ok {
continue
}
return first, nil
}
}
// addToQueue adds the passed commits to the internal fifo queue if they weren't seen
// or returns an error if the passed hashes could not be used to get valid commits
func (w *filterCommitIter) addToQueue(
store storer.EncodedObjectStorer,
hashes ...plumbing.Hash,
) error {
for _, hash := range hashes {
if _, ok := w.visited[hash]; ok {
continue
}
commit, err := GetCommit(store, hash)
if err != nil {
return err
}
w.queue = append(w.queue, commit)
}
return nil
}
go-git-5.13.2/plumbing/object/commit_walker_bfs_filtered_test.go 0000664 0000000 0000000 00000017604 14744245500 0025023 0 ustar 00root root 0000000 0000000 package object
import (
"fmt"
"strings"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
. "gopkg.in/check.v1"
)
var _ = Suite(&filterCommitIterSuite{})
type filterCommitIterSuite struct {
BaseObjectsSuite
}
func commitsFromIter(iter CommitIter) ([]*Commit, error) {
var commits []*Commit
err := iter.ForEach(func(c *Commit) error {
commits = append(commits, c)
return nil
})
return commits, err
}
func assertHashes(c *C, commits []*Commit, hashes []string) {
if len(commits) != len(hashes) {
var expected []string
expected = append(expected, hashes...)
fmt.Println("expected:", strings.Join(expected, ", "))
var got []string
for _, c := range commits {
got = append(got, c.Hash.String())
}
fmt.Println(" got:", strings.Join(got, ", "))
}
c.Assert(commits, HasLen, len(hashes))
for i, commit := range commits {
c.Assert(hashes[i], Equals, commit.Hash.String())
}
}
func validIfCommit(ignored plumbing.Hash) CommitFilter {
return func(c *Commit) bool {
return c.Hash == ignored
}
}
func not(filter CommitFilter) CommitFilter {
return func(c *Commit) bool {
return !filter(c)
}
}
/*
// TestCase history
* 6ecf0ef2c2dffb796033e5a02219af86ec6584e5 <- HEAD
|
| * e8d3ffab552895c19b9fcf7aa264d277cde33881
|/
* 918c48b83bd081e863dbe1b80f8998f058cd8294
|
* af2d6a6954d532f8ffb47615169c8fdf9d383a1a
|
* 1669dce138d9b841a518c64b10914d88f5e488ea
|\
| * a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69 // isLimit
| |\
| | * b8e471f58bcbca63b07bda20e428190409c2db47 // ignored if isLimit is passed
| |/
* | 35e85108805c84807bc66a02d91535e1e24b38b9 // isValid; ignored if passed as !isValid
|/
* b029517f6300c2da0f4b651b8642506cd6aaf45d
*/
// TestFilterCommitIter asserts that FilterCommitIter returns all commits from
// history, but e8d3ffab552895c19b9fcf7aa264d277cde33881, that is not reachable
// from HEAD
func (s *filterCommitIterSuite) TestFilterCommitIter(c *C) {
from := s.commit(c, plumbing.NewHash(s.Fixture.Head))
commits, err := commitsFromIter(NewFilterCommitIter(from, nil, nil))
c.Assert(err, IsNil)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"918c48b83bd081e863dbe1b80f8998f058cd8294",
"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
"1669dce138d9b841a518c64b10914d88f5e488ea",
"35e85108805c84807bc66a02d91535e1e24b38b9",
"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
"b8e471f58bcbca63b07bda20e428190409c2db47",
}
assertHashes(c, commits, expected)
}
// TestFilterCommitIterWithValid asserts that FilterCommitIter returns only commits
// that matches the passed isValid filter; in this testcase, it was filtered out
// all commits but one from history
func (s *filterCommitIterSuite) TestFilterCommitIterWithValid(c *C) {
from := s.commit(c, plumbing.NewHash(s.Fixture.Head))
validIf := validIfCommit(plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"))
commits, err := commitsFromIter(NewFilterCommitIter(from, &validIf, nil))
c.Assert(err, IsNil)
expected := []string{
"35e85108805c84807bc66a02d91535e1e24b38b9",
}
assertHashes(c, commits, expected)
}
// that matches the passed isValid filter; in this testcase, it was filtered out
// only one commit from history
func (s *filterCommitIterSuite) TestFilterCommitIterWithInvalid(c *C) {
from := s.commit(c, plumbing.NewHash(s.Fixture.Head))
validIf := validIfCommit(plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"))
validIfNot := not(validIf)
commits, err := commitsFromIter(NewFilterCommitIter(from, &validIfNot, nil))
c.Assert(err, IsNil)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"918c48b83bd081e863dbe1b80f8998f058cd8294",
"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
"1669dce138d9b841a518c64b10914d88f5e488ea",
"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
"b8e471f58bcbca63b07bda20e428190409c2db47",
}
assertHashes(c, commits, expected)
}
// TestFilterCommitIterWithNoValidCommits asserts that FilterCommitIter returns
// no commits if the passed isValid filter does not allow any commit
func (s *filterCommitIterSuite) TestFilterCommitIterWithNoValidCommits(c *C) {
from := s.commit(c, plumbing.NewHash(s.Fixture.Head))
validIf := validIfCommit(plumbing.NewHash("THIS_COMMIT_DOES_NOT_EXIST"))
commits, err := commitsFromIter(NewFilterCommitIter(from, &validIf, nil))
c.Assert(err, IsNil)
c.Assert(commits, HasLen, 0)
}
// TestFilterCommitIterWithStopAt asserts that FilterCommitIter returns only commits
// are not beyond a isLimit filter
func (s *filterCommitIterSuite) TestFilterCommitIterWithStopAt(c *C) {
from := s.commit(c, plumbing.NewHash(s.Fixture.Head))
stopAtRule := validIfCommit(plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"))
commits, err := commitsFromIter(NewFilterCommitIter(from, nil, &stopAtRule))
c.Assert(err, IsNil)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"918c48b83bd081e863dbe1b80f8998f058cd8294",
"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
"1669dce138d9b841a518c64b10914d88f5e488ea",
"35e85108805c84807bc66a02d91535e1e24b38b9",
"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
}
assertHashes(c, commits, expected)
}
// TestFilterCommitIterWithStopAt asserts that FilterCommitIter works properly
// with isValid and isLimit filters
func (s *filterCommitIterSuite) TestFilterCommitIterWithInvalidAndStopAt(c *C) {
from := s.commit(c, plumbing.NewHash(s.Fixture.Head))
stopAtRule := validIfCommit(plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"))
validIf := validIfCommit(plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"))
validIfNot := not(validIf)
commits, err := commitsFromIter(NewFilterCommitIter(from, &validIfNot, &stopAtRule))
c.Assert(err, IsNil)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"918c48b83bd081e863dbe1b80f8998f058cd8294",
"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
"1669dce138d9b841a518c64b10914d88f5e488ea",
"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
}
assertHashes(c, commits, expected)
}
// TestIteratorForEachCallbackReturn that ForEach callback does not cause
// the ForEach to return an error if it returned an ErrStop
//
// - 6ecf0ef2c2dffb796033e5a02219af86ec6584e5
// - 918c48b83bd081e863dbe1b80f8998f058cd8294 //<- stop
// - af2d6a6954d532f8ffb47615169c8fdf9d383a1a
// - 1669dce138d9b841a518c64b10914d88f5e488ea //<- err
// - 35e85108805c84807bc66a02d91535e1e24b38b9
// - a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69
// - b029517f6300c2da0f4b651b8642506cd6aaf45d
// - b8e471f58bcbca63b07bda20e428190409c2db47
func (s *filterCommitIterSuite) TestIteratorForEachCallbackReturn(c *C) {
var visited []*Commit
errUnexpected := fmt.Errorf("Could not continue")
cb := func(c *Commit) error {
switch c.Hash {
case plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"):
return storer.ErrStop
case plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"):
return errUnexpected
}
visited = append(visited, c)
return nil
}
from := s.commit(c, plumbing.NewHash(s.Fixture.Head))
iter := NewFilterCommitIter(from, nil, nil)
err := iter.ForEach(cb)
c.Assert(err, IsNil)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
}
assertHashes(c, visited, expected)
err = iter.ForEach(cb)
c.Assert(err, Equals, errUnexpected)
expected = []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
}
assertHashes(c, visited, expected)
err = iter.ForEach(cb)
c.Assert(err, IsNil)
expected = []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
"35e85108805c84807bc66a02d91535e1e24b38b9",
"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
"b8e471f58bcbca63b07bda20e428190409c2db47",
}
assertHashes(c, visited, expected)
}
go-git-5.13.2/plumbing/object/commit_walker_ctime.go 0000664 0000000 0000000 00000004154 14744245500 0022431 0 ustar 00root root 0000000 0000000 package object
import (
"io"
"github.com/emirpasic/gods/trees/binaryheap"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
)
type commitIteratorByCTime struct {
seenExternal map[plumbing.Hash]bool
seen map[plumbing.Hash]bool
heap *binaryheap.Heap
}
// NewCommitIterCTime returns a CommitIter that walks the commit history,
// starting at the given commit and visiting its parents while preserving Committer Time order.
// this appears to be the closest order to `git log`
// The given callback will be called for each visited commit. Each commit will
// be visited only once. If the callback returns an error, walking will stop
// and will return the error. Other errors might be returned if the history
// cannot be traversed (e.g. missing objects). Ignore allows to skip some
// commits from being iterated.
func NewCommitIterCTime(
c *Commit,
seenExternal map[plumbing.Hash]bool,
ignore []plumbing.Hash,
) CommitIter {
seen := make(map[plumbing.Hash]bool)
for _, h := range ignore {
seen[h] = true
}
heap := binaryheap.NewWith(func(a, b interface{}) int {
if a.(*Commit).Committer.When.Before(b.(*Commit).Committer.When) {
return 1
}
return -1
})
heap.Push(c)
return &commitIteratorByCTime{
seenExternal: seenExternal,
seen: seen,
heap: heap,
}
}
func (w *commitIteratorByCTime) Next() (*Commit, error) {
var c *Commit
for {
cIn, ok := w.heap.Pop()
if !ok {
return nil, io.EOF
}
c = cIn.(*Commit)
if w.seen[c.Hash] || w.seenExternal[c.Hash] {
continue
}
w.seen[c.Hash] = true
for _, h := range c.ParentHashes {
if w.seen[h] || w.seenExternal[h] {
continue
}
pc, err := GetCommit(c.s, h)
if err != nil {
return nil, err
}
w.heap.Push(pc)
}
return c, nil
}
}
func (w *commitIteratorByCTime) ForEach(cb func(*Commit) error) error {
for {
c, err := w.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
err = cb(c)
if err == storer.ErrStop {
break
}
if err != nil {
return err
}
}
return nil
}
func (w *commitIteratorByCTime) Close() {}
go-git-5.13.2/plumbing/object/commit_walker_limit.go 0000664 0000000 0000000 00000002300 14744245500 0022435 0 ustar 00root root 0000000 0000000 package object
import (
"io"
"time"
"github.com/go-git/go-git/v5/plumbing/storer"
)
type commitLimitIter struct {
sourceIter CommitIter
limitOptions LogLimitOptions
}
type LogLimitOptions struct {
Since *time.Time
Until *time.Time
}
func NewCommitLimitIterFromIter(commitIter CommitIter, limitOptions LogLimitOptions) CommitIter {
iterator := new(commitLimitIter)
iterator.sourceIter = commitIter
iterator.limitOptions = limitOptions
return iterator
}
func (c *commitLimitIter) Next() (*Commit, error) {
for {
commit, err := c.sourceIter.Next()
if err != nil {
return nil, err
}
if c.limitOptions.Since != nil && commit.Committer.When.Before(*c.limitOptions.Since) {
continue
}
if c.limitOptions.Until != nil && commit.Committer.When.After(*c.limitOptions.Until) {
continue
}
return commit, nil
}
}
func (c *commitLimitIter) ForEach(cb func(*Commit) error) error {
for {
commit, nextErr := c.Next()
if nextErr == io.EOF {
break
}
if nextErr != nil {
return nextErr
}
err := cb(commit)
if err == storer.ErrStop {
return nil
} else if err != nil {
return err
}
}
return nil
}
func (c *commitLimitIter) Close() {
c.sourceIter.Close()
}
go-git-5.13.2/plumbing/object/commit_walker_path.go 0000664 0000000 0000000 00000010154 14744245500 0022261 0 ustar 00root root 0000000 0000000 package object
import (
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
)
type commitPathIter struct {
pathFilter func(string) bool
sourceIter CommitIter
currentCommit *Commit
checkParent bool
}
// NewCommitPathIterFromIter returns a commit iterator which performs diffTree between
// successive trees returned from the commit iterator from the argument. The purpose of this is
// to find the commits that explain how the files that match the path came to be.
// If checkParent is true then the function double checks if potential parent (next commit in a path)
// is one of the parents in the tree (it's used by `git log --all`).
// pathFilter is a function that takes path of file as argument and returns true if we want it
func NewCommitPathIterFromIter(pathFilter func(string) bool, commitIter CommitIter, checkParent bool) CommitIter {
iterator := new(commitPathIter)
iterator.sourceIter = commitIter
iterator.pathFilter = pathFilter
iterator.checkParent = checkParent
return iterator
}
// NewCommitFileIterFromIter is kept for compatibility, can be replaced with NewCommitPathIterFromIter
func NewCommitFileIterFromIter(fileName string, commitIter CommitIter, checkParent bool) CommitIter {
return NewCommitPathIterFromIter(
func(path string) bool {
return path == fileName
},
commitIter,
checkParent,
)
}
func (c *commitPathIter) Next() (*Commit, error) {
if c.currentCommit == nil {
var err error
c.currentCommit, err = c.sourceIter.Next()
if err != nil {
return nil, err
}
}
commit, commitErr := c.getNextFileCommit()
// Setting current-commit to nil to prevent unwanted states when errors are raised
if commitErr != nil {
c.currentCommit = nil
}
return commit, commitErr
}
func (c *commitPathIter) getNextFileCommit() (*Commit, error) {
var parentTree, currentTree *Tree
for {
// Parent-commit can be nil if the current-commit is the initial commit
parentCommit, parentCommitErr := c.sourceIter.Next()
if parentCommitErr != nil {
// If the parent-commit is beyond the initial commit, keep it nil
if parentCommitErr != io.EOF {
return nil, parentCommitErr
}
parentCommit = nil
}
if parentTree == nil {
var currTreeErr error
currentTree, currTreeErr = c.currentCommit.Tree()
if currTreeErr != nil {
return nil, currTreeErr
}
} else {
currentTree = parentTree
parentTree = nil
}
if parentCommit != nil {
var parentTreeErr error
parentTree, parentTreeErr = parentCommit.Tree()
if parentTreeErr != nil {
return nil, parentTreeErr
}
}
// Find diff between current and parent trees
changes, diffErr := DiffTree(currentTree, parentTree)
if diffErr != nil {
return nil, diffErr
}
found := c.hasFileChange(changes, parentCommit)
// Storing the current-commit in-case a change is found, and
// Updating the current-commit for the next-iteration
prevCommit := c.currentCommit
c.currentCommit = parentCommit
if found {
return prevCommit, nil
}
// If not matches found and if parent-commit is beyond the initial commit, then return with EOF
if parentCommit == nil {
return nil, io.EOF
}
}
}
func (c *commitPathIter) hasFileChange(changes Changes, parent *Commit) bool {
for _, change := range changes {
if !c.pathFilter(change.name()) {
continue
}
// filename matches, now check if source iterator contains all commits (from all refs)
if c.checkParent {
// Check if parent is beyond the initial commit
if parent == nil || isParentHash(parent.Hash, c.currentCommit) {
return true
}
continue
}
return true
}
return false
}
func isParentHash(hash plumbing.Hash, commit *Commit) bool {
for _, h := range commit.ParentHashes {
if h == hash {
return true
}
}
return false
}
func (c *commitPathIter) ForEach(cb func(*Commit) error) error {
for {
commit, nextErr := c.Next()
if nextErr == io.EOF {
break
}
if nextErr != nil {
return nextErr
}
err := cb(commit)
if err == storer.ErrStop {
return nil
} else if err != nil {
return err
}
}
return nil
}
func (c *commitPathIter) Close() {
c.sourceIter.Close()
}
go-git-5.13.2/plumbing/object/commit_walker_test.go 0000664 0000000 0000000 00000015746 14744245500 0022320 0 ustar 00root root 0000000 0000000 package object
import (
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
type CommitWalkerSuite struct {
BaseObjectsSuite
}
var _ = Suite(&CommitWalkerSuite{})
func (s *CommitWalkerSuite) TestCommitPreIterator(c *C) {
commit := s.commit(c, plumbing.NewHash(s.Fixture.Head))
var commits []*Commit
NewCommitPreorderIter(commit, nil, nil).ForEach(func(c *Commit) error {
commits = append(commits, c)
return nil
})
c.Assert(commits, HasLen, 8)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"918c48b83bd081e863dbe1b80f8998f058cd8294",
"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
"1669dce138d9b841a518c64b10914d88f5e488ea",
"35e85108805c84807bc66a02d91535e1e24b38b9",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
"b8e471f58bcbca63b07bda20e428190409c2db47",
}
for i, commit := range commits {
c.Assert(commit.Hash.String(), Equals, expected[i])
}
}
func (s *CommitWalkerSuite) TestCommitPreIteratorWithIgnore(c *C) {
commit := s.commit(c, plumbing.NewHash(s.Fixture.Head))
var commits []*Commit
NewCommitPreorderIter(commit, nil, []plumbing.Hash{
plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"),
}).ForEach(func(c *Commit) error {
commits = append(commits, c)
return nil
})
c.Assert(commits, HasLen, 2)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"918c48b83bd081e863dbe1b80f8998f058cd8294",
}
for i, commit := range commits {
c.Assert(commit.Hash.String(), Equals, expected[i])
}
}
func (s *CommitWalkerSuite) TestCommitPreIteratorWithSeenExternal(c *C) {
commit := s.commit(c, plumbing.NewHash(s.Fixture.Head))
var commits []*Commit
seenExternal := map[plumbing.Hash]bool{
plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"): true,
}
NewCommitPreorderIter(commit, seenExternal, nil).
ForEach(func(c *Commit) error {
commits = append(commits, c)
return nil
})
c.Assert(commits, HasLen, 2)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"918c48b83bd081e863dbe1b80f8998f058cd8294",
}
for i, commit := range commits {
c.Assert(commit.Hash.String(), Equals, expected[i])
}
}
func (s *CommitWalkerSuite) TestCommitPostIterator(c *C) {
commit := s.commit(c, plumbing.NewHash(s.Fixture.Head))
var commits []*Commit
NewCommitPostorderIter(commit, nil).ForEach(func(c *Commit) error {
commits = append(commits, c)
return nil
})
c.Assert(commits, HasLen, 8)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"918c48b83bd081e863dbe1b80f8998f058cd8294",
"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
"1669dce138d9b841a518c64b10914d88f5e488ea",
"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
"b8e471f58bcbca63b07bda20e428190409c2db47",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
"35e85108805c84807bc66a02d91535e1e24b38b9",
}
for i, commit := range commits {
c.Assert(commit.Hash.String(), Equals, expected[i])
}
}
func (s *CommitWalkerSuite) TestCommitPostIteratorWithIgnore(c *C) {
commit := s.commit(c, plumbing.NewHash(s.Fixture.Head))
var commits []*Commit
NewCommitPostorderIter(commit, []plumbing.Hash{
plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"),
}).ForEach(func(c *Commit) error {
commits = append(commits, c)
return nil
})
c.Assert(commits, HasLen, 2)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"918c48b83bd081e863dbe1b80f8998f058cd8294",
}
for i, commit := range commits {
c.Assert(commit.Hash.String(), Equals, expected[i])
}
}
func (s *CommitWalkerSuite) TestCommitCTimeIterator(c *C) {
commit := s.commit(c, plumbing.NewHash(s.Fixture.Head))
var commits []*Commit
NewCommitIterCTime(commit, nil, nil).ForEach(func(c *Commit) error {
commits = append(commits, c)
return nil
})
c.Assert(commits, HasLen, 8)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5", // 2015-04-05T23:30:47+02:00
"918c48b83bd081e863dbe1b80f8998f058cd8294", // 2015-03-31T13:56:18+02:00
"af2d6a6954d532f8ffb47615169c8fdf9d383a1a", // 2015-03-31T13:51:51+02:00
"1669dce138d9b841a518c64b10914d88f5e488ea", // 2015-03-31T13:48:14+02:00
"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69", // 2015-03-31T13:47:14+02:00
"35e85108805c84807bc66a02d91535e1e24b38b9", // 2015-03-31T13:46:24+02:00
"b8e471f58bcbca63b07bda20e428190409c2db47", // 2015-03-31T13:44:52+02:00
"b029517f6300c2da0f4b651b8642506cd6aaf45d", // 2015-03-31T13:42:21+02:00
}
for i, commit := range commits {
c.Assert(commit.Hash.String(), Equals, expected[i])
}
}
func (s *CommitWalkerSuite) TestCommitCTimeIteratorWithIgnore(c *C) {
commit := s.commit(c, plumbing.NewHash(s.Fixture.Head))
var commits []*Commit
NewCommitIterCTime(commit, nil, []plumbing.Hash{
plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"),
}).ForEach(func(c *Commit) error {
commits = append(commits, c)
return nil
})
c.Assert(commits, HasLen, 2)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"918c48b83bd081e863dbe1b80f8998f058cd8294",
}
for i, commit := range commits {
c.Assert(commit.Hash.String(), Equals, expected[i])
}
}
func (s *CommitWalkerSuite) TestCommitBSFIterator(c *C) {
commit := s.commit(c, plumbing.NewHash(s.Fixture.Head))
var commits []*Commit
NewCommitIterBSF(commit, nil, nil).ForEach(func(c *Commit) error {
commits = append(commits, c)
return nil
})
c.Assert(commits, HasLen, 8)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"918c48b83bd081e863dbe1b80f8998f058cd8294",
"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
"1669dce138d9b841a518c64b10914d88f5e488ea",
"35e85108805c84807bc66a02d91535e1e24b38b9",
"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
"b8e471f58bcbca63b07bda20e428190409c2db47",
}
for i, commit := range commits {
c.Assert(commit.Hash.String(), Equals, expected[i])
}
}
func (s *CommitWalkerSuite) TestCommitBSFIteratorWithIgnore(c *C) {
commit := s.commit(c, plumbing.NewHash(s.Fixture.Head))
var commits []*Commit
NewCommitIterBSF(commit, nil, []plumbing.Hash{
plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"),
}).ForEach(func(c *Commit) error {
commits = append(commits, c)
return nil
})
c.Assert(commits, HasLen, 2)
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"918c48b83bd081e863dbe1b80f8998f058cd8294",
}
for i, commit := range commits {
c.Assert(commit.Hash.String(), Equals, expected[i])
}
}
func (s *CommitWalkerSuite) TestCommitPathIteratorInitialCommit(c *C) {
commit := s.commit(c, plumbing.NewHash(s.Fixture.Head))
fileName := "LICENSE"
var commits []*Commit
NewCommitPathIterFromIter(
func(path string) bool { return path == fileName },
NewCommitIterCTime(commit, nil, nil),
true,
).ForEach(func(c *Commit) error {
commits = append(commits, c)
return nil
})
expected := []string{
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
}
c.Assert(commits, HasLen, len(expected))
for i, commit := range commits {
c.Assert(commit.Hash.String(), Equals, expected[i])
}
}
go-git-5.13.2/plumbing/object/commitgraph/ 0000775 0000000 0000000 00000000000 14744245500 0020372 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/object/commitgraph/commitnode.go 0000664 0000000 0000000 00000006041 14744245500 0023060 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"io"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/storer"
)
// CommitNode is generic interface encapsulating a lightweight commit object retrieved
// from CommitNodeIndex
type CommitNode interface {
// ID returns the Commit object id referenced by the commit graph node.
ID() plumbing.Hash
// Tree returns the Tree referenced by the commit graph node.
Tree() (*object.Tree, error)
// CommitTime returns the Committer.When time of the Commit referenced by the commit graph node.
CommitTime() time.Time
// NumParents returns the number of parents in a commit.
NumParents() int
// ParentNodes return a CommitNodeIter for parents of specified node.
ParentNodes() CommitNodeIter
// ParentNode returns the ith parent of a commit.
ParentNode(i int) (CommitNode, error)
// ParentHashes returns hashes of the parent commits for a specified node
ParentHashes() []plumbing.Hash
// Generation returns the generation of the commit for reachability analysis.
// Objects with newer generation are not reachable from objects of older generation.
Generation() uint64
// GenerationV2 stores the corrected commit date for the commits
// It combines the contents of the GDA2 and GDO2 sections of the commit-graph
// with the commit time portion of the CDAT section.
GenerationV2() uint64
// Commit returns the full commit object from the node
Commit() (*object.Commit, error)
}
// CommitNodeIndex is generic interface encapsulating an index of CommitNode objects
type CommitNodeIndex interface {
// Get returns a commit node from a commit hash
Get(hash plumbing.Hash) (CommitNode, error)
}
// CommitNodeIter is a generic closable interface for iterating over commit nodes.
type CommitNodeIter interface {
Next() (CommitNode, error)
ForEach(func(CommitNode) error) error
Close()
}
// parentCommitNodeIter provides an iterator for parent commits from associated CommitNodeIndex.
type parentCommitNodeIter struct {
node CommitNode
i int
}
func newParentgraphCommitNodeIter(node CommitNode) CommitNodeIter {
return &parentCommitNodeIter{node, 0}
}
// Next moves the iterator to the next commit and returns a pointer to it. If
// there are no more commits, it returns io.EOF.
func (iter *parentCommitNodeIter) Next() (CommitNode, error) {
obj, err := iter.node.ParentNode(iter.i)
if err == object.ErrParentNotFound {
return nil, io.EOF
}
if err == nil {
iter.i++
}
return obj, err
}
// ForEach call the cb function for each commit contained on this iter until
// an error appends or the end of the iter is reached. If ErrStop is sent
// the iteration is stopped but no error is returned. The iterator is closed.
func (iter *parentCommitNodeIter) ForEach(cb func(CommitNode) error) error {
for {
obj, err := iter.Next()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
if err := cb(obj); err != nil {
if err == storer.ErrStop {
return nil
}
return err
}
}
}
func (iter *parentCommitNodeIter) Close() {
}
go-git-5.13.2/plumbing/object/commitgraph/commitnode_graph.go 0000664 0000000 0000000 00000007413 14744245500 0024245 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"fmt"
"time"
"github.com/go-git/go-git/v5/plumbing"
commitgraph "github.com/go-git/go-git/v5/plumbing/format/commitgraph/v2"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/storer"
)
// graphCommitNode is a reduced representation of Commit as presented in the commit
// graph file (commitgraph.Node). It is merely useful as an optimization for walking
// the commit graphs.
//
// graphCommitNode implements the CommitNode interface.
type graphCommitNode struct {
// Hash for the Commit object
hash plumbing.Hash
// Index of the node in the commit graph file
index uint32
commitData *commitgraph.CommitData
gci *graphCommitNodeIndex
}
// graphCommitNodeIndex is an index that can load CommitNode objects from both the commit
// graph files and the object store.
//
// graphCommitNodeIndex implements the CommitNodeIndex interface
type graphCommitNodeIndex struct {
commitGraph commitgraph.Index
s storer.EncodedObjectStorer
}
// NewGraphCommitNodeIndex returns CommitNodeIndex implementation that uses commit-graph
// files as backing storage and falls back to object storage when necessary
func NewGraphCommitNodeIndex(commitGraph commitgraph.Index, s storer.EncodedObjectStorer) CommitNodeIndex {
return &graphCommitNodeIndex{commitGraph, s}
}
func (gci *graphCommitNodeIndex) Get(hash plumbing.Hash) (CommitNode, error) {
if gci.commitGraph != nil {
// Check the commit graph first
parentIndex, err := gci.commitGraph.GetIndexByHash(hash)
if err == nil {
parent, err := gci.commitGraph.GetCommitDataByIndex(parentIndex)
if err != nil {
return nil, err
}
return &graphCommitNode{
hash: hash,
index: parentIndex,
commitData: parent,
gci: gci,
}, nil
}
}
// Fallback to loading full commit object
commit, err := object.GetCommit(gci.s, hash)
if err != nil {
return nil, err
}
return &objectCommitNode{
nodeIndex: gci,
commit: commit,
}, nil
}
func (c *graphCommitNode) ID() plumbing.Hash {
return c.hash
}
func (c *graphCommitNode) Tree() (*object.Tree, error) {
return object.GetTree(c.gci.s, c.commitData.TreeHash)
}
func (c *graphCommitNode) CommitTime() time.Time {
return c.commitData.When
}
func (c *graphCommitNode) NumParents() int {
return len(c.commitData.ParentIndexes)
}
func (c *graphCommitNode) ParentNodes() CommitNodeIter {
return newParentgraphCommitNodeIter(c)
}
func (c *graphCommitNode) ParentNode(i int) (CommitNode, error) {
if i < 0 || i >= len(c.commitData.ParentIndexes) {
return nil, object.ErrParentNotFound
}
parent, err := c.gci.commitGraph.GetCommitDataByIndex(c.commitData.ParentIndexes[i])
if err != nil {
return nil, err
}
return &graphCommitNode{
hash: c.commitData.ParentHashes[i],
index: c.commitData.ParentIndexes[i],
commitData: parent,
gci: c.gci,
}, nil
}
func (c *graphCommitNode) ParentHashes() []plumbing.Hash {
return c.commitData.ParentHashes
}
func (c *graphCommitNode) Generation() uint64 {
// If the commit-graph file was generated with older Git version that
// set the generation to zero for every commit the generation assumption
// is still valid. It is just less useful.
return c.commitData.Generation
}
func (c *graphCommitNode) GenerationV2() uint64 {
// If the commit-graph file was generated with older Git version that
// set the generation to zero for every commit the generation assumption
// is still valid. It is just less useful.
return c.commitData.GenerationV2
}
func (c *graphCommitNode) Commit() (*object.Commit, error) {
return object.GetCommit(c.gci.s, c.hash)
}
func (c *graphCommitNode) String() string {
return fmt.Sprintf(
"%s %s\nDate: %s",
plumbing.CommitObject, c.ID(),
c.CommitTime().Format(object.DateFormat),
)
}
go-git-5.13.2/plumbing/object/commitgraph/commitnode_object.go 0000664 0000000 0000000 00000005103 14744245500 0024404 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"math"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/storer"
)
// objectCommitNode is a representation of Commit as presented in the GIT object format.
//
// objectCommitNode implements the CommitNode interface.
type objectCommitNode struct {
nodeIndex CommitNodeIndex
commit *object.Commit
}
// NewObjectCommitNodeIndex returns CommitNodeIndex implementation that uses
// only object storage to load the nodes
func NewObjectCommitNodeIndex(s storer.EncodedObjectStorer) CommitNodeIndex {
return &objectCommitNodeIndex{s}
}
func (oci *objectCommitNodeIndex) Get(hash plumbing.Hash) (CommitNode, error) {
commit, err := object.GetCommit(oci.s, hash)
if err != nil {
return nil, err
}
return &objectCommitNode{
nodeIndex: oci,
commit: commit,
}, nil
}
// objectCommitNodeIndex is an index that can load CommitNode objects only from the
// object store.
//
// objectCommitNodeIndex implements the CommitNodeIndex interface
type objectCommitNodeIndex struct {
s storer.EncodedObjectStorer
}
func (c *objectCommitNode) CommitTime() time.Time {
return c.commit.Committer.When
}
func (c *objectCommitNode) ID() plumbing.Hash {
return c.commit.ID()
}
func (c *objectCommitNode) Tree() (*object.Tree, error) {
return c.commit.Tree()
}
func (c *objectCommitNode) NumParents() int {
return c.commit.NumParents()
}
func (c *objectCommitNode) ParentNodes() CommitNodeIter {
return newParentgraphCommitNodeIter(c)
}
func (c *objectCommitNode) ParentNode(i int) (CommitNode, error) {
if i < 0 || i >= len(c.commit.ParentHashes) {
return nil, object.ErrParentNotFound
}
// Note: It's necessary to go through CommitNodeIndex here to ensure
// that if the commit-graph file covers only part of the history we
// start using it when that part is reached.
return c.nodeIndex.Get(c.commit.ParentHashes[i])
}
func (c *objectCommitNode) ParentHashes() []plumbing.Hash {
return c.commit.ParentHashes
}
func (c *objectCommitNode) Generation() uint64 {
// Commit nodes representing objects outside of the commit graph can never
// be reached by objects from the commit-graph thus we return the highest
// possible value.
return math.MaxUint64
}
func (c *objectCommitNode) GenerationV2() uint64 {
// Commit nodes representing objects outside of the commit graph can never
// be reached by objects from the commit-graph thus we return the highest
// possible value.
return math.MaxUint64
}
func (c *objectCommitNode) Commit() (*object.Commit, error) {
return c.commit, nil
}
go-git-5.13.2/plumbing/object/commitgraph/commitnode_test.go 0000664 0000000 0000000 00000010343 14744245500 0024117 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"path"
"testing"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
commitgraph "github.com/go-git/go-git/v5/plumbing/format/commitgraph/v2"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/storage/filesystem"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type CommitNodeSuite struct {
fixtures.Suite
}
var _ = Suite(&CommitNodeSuite{})
func unpackRepository(f *fixtures.Fixture) *filesystem.Storage {
storer := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
p := f.Packfile()
defer p.Close()
packfile.UpdateObjectStorage(storer, p)
return storer
}
func testWalker(c *C, nodeIndex CommitNodeIndex) {
head, err := nodeIndex.Get(plumbing.NewHash("b9d69064b190e7aedccf84731ca1d917871f8a1c"))
c.Assert(err, IsNil)
iter := NewCommitNodeIterCTime(
head,
nil,
nil,
)
var commits []CommitNode
iter.ForEach(func(c CommitNode) error {
commits = append(commits, c)
return nil
})
c.Assert(commits, HasLen, 9)
expected := []string{
"b9d69064b190e7aedccf84731ca1d917871f8a1c",
"6f6c5d2be7852c782be1dd13e36496dd7ad39560",
"a45273fe2d63300e1962a9e26a6b15c276cd7082",
"c0edf780dd0da6a65a7a49a86032fcf8a0c2d467",
"bb13916df33ed23004c3ce9ed3b8487528e655c1",
"03d2c021ff68954cf3ef0a36825e194a4b98f981",
"ce275064ad67d51e99f026084e20827901a8361c",
"e713b52d7e13807e87a002e812041f248db3f643",
"347c91919944a68e9413581a1bc15519550a3afe",
}
for i, commit := range commits {
c.Assert(commit.ID().String(), Equals, expected[i])
}
}
func testParents(c *C, nodeIndex CommitNodeIndex) {
merge3, err := nodeIndex.Get(plumbing.NewHash("6f6c5d2be7852c782be1dd13e36496dd7ad39560"))
c.Assert(err, IsNil)
var parents []CommitNode
merge3.ParentNodes().ForEach(func(c CommitNode) error {
parents = append(parents, c)
return nil
})
c.Assert(parents, HasLen, 3)
expected := []string{
"ce275064ad67d51e99f026084e20827901a8361c",
"bb13916df33ed23004c3ce9ed3b8487528e655c1",
"a45273fe2d63300e1962a9e26a6b15c276cd7082",
}
for i, parent := range parents {
c.Assert(parent.ID().String(), Equals, expected[i])
}
}
func testCommitAndTree(c *C, nodeIndex CommitNodeIndex) {
merge3node, err := nodeIndex.Get(plumbing.NewHash("6f6c5d2be7852c782be1dd13e36496dd7ad39560"))
c.Assert(err, IsNil)
merge3commit, err := merge3node.Commit()
c.Assert(err, IsNil)
c.Assert(merge3node.ID().String(), Equals, merge3commit.ID().String())
tree, err := merge3node.Tree()
c.Assert(err, IsNil)
c.Assert(tree.ID().String(), Equals, merge3commit.TreeHash.String())
}
func (s *CommitNodeSuite) TestObjectGraph(c *C) {
f := fixtures.ByTag("commit-graph").One()
storer := unpackRepository(f)
nodeIndex := NewObjectCommitNodeIndex(storer)
testWalker(c, nodeIndex)
testParents(c, nodeIndex)
testCommitAndTree(c, nodeIndex)
}
func (s *CommitNodeSuite) TestCommitGraph(c *C) {
f := fixtures.ByTag("commit-graph").One()
storer := unpackRepository(f)
reader, err := storer.Filesystem().Open(path.Join("objects", "info", "commit-graph"))
c.Assert(err, IsNil)
defer reader.Close()
index, err := commitgraph.OpenFileIndex(reader)
c.Assert(err, IsNil)
defer index.Close()
nodeIndex := NewGraphCommitNodeIndex(index, storer)
testWalker(c, nodeIndex)
testParents(c, nodeIndex)
testCommitAndTree(c, nodeIndex)
}
func (s *CommitNodeSuite) TestMixedGraph(c *C) {
f := fixtures.ByTag("commit-graph").One()
storer := unpackRepository(f)
// Take the commit-graph file and copy it to memory index without the last commit
reader, err := storer.Filesystem().Open(path.Join("objects", "info", "commit-graph"))
c.Assert(err, IsNil)
defer reader.Close()
fileIndex, err := commitgraph.OpenFileIndex(reader)
c.Assert(err, IsNil)
defer fileIndex.Close()
memoryIndex := commitgraph.NewMemoryIndex()
defer memoryIndex.Close()
for i, hash := range fileIndex.Hashes() {
if hash.String() != "b9d69064b190e7aedccf84731ca1d917871f8a1c" {
node, err := fileIndex.GetCommitDataByIndex(uint32(i))
c.Assert(err, IsNil)
memoryIndex.Add(hash, node)
}
}
nodeIndex := NewGraphCommitNodeIndex(memoryIndex, storer)
testWalker(c, nodeIndex)
testParents(c, nodeIndex)
testCommitAndTree(c, nodeIndex)
}
go-git-5.13.2/plumbing/object/commitgraph/commitnode_walker_author_order.go 0000664 0000000 0000000 00000003137 14744245500 0027205 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/emirpasic/gods/trees/binaryheap"
)
// NewCommitNodeIterAuthorDateOrder returns a CommitNodeIter that walks the commit history,
// starting at the given commit and visiting its parents in Author Time order but with the
// constraint that no parent is emitted before its children are emitted.
//
// This matches `git log --author-order`
//
// This ordering requires that commit objects need to be loaded into memory - thus this
// ordering is likely to be slower than other orderings.
func NewCommitNodeIterAuthorDateOrder(c CommitNode,
seenExternal map[plumbing.Hash]bool,
ignore []plumbing.Hash,
) CommitNodeIter {
seen := make(map[plumbing.Hash]struct{})
for _, h := range ignore {
seen[h] = struct{}{}
}
for h, ext := range seenExternal {
if ext {
seen[h] = struct{}{}
}
}
inCounts := make(map[plumbing.Hash]int)
exploreHeap := &commitNodeHeap{binaryheap.NewWith(generationAndDateOrderComparator)}
exploreHeap.Push(c)
visitHeap := &commitNodeHeap{binaryheap.NewWith(func(left, right interface{}) int {
leftCommit, err := left.(CommitNode).Commit()
if err != nil {
return -1
}
rightCommit, err := right.(CommitNode).Commit()
if err != nil {
return -1
}
switch {
case rightCommit.Author.When.Before(leftCommit.Author.When):
return -1
case leftCommit.Author.When.Before(rightCommit.Author.When):
return 1
}
return 0
})}
visitHeap.Push(c)
return &commitNodeIteratorTopological{
exploreStack: exploreHeap,
visitStack: visitHeap,
inCounts: inCounts,
ignore: seen,
}
}
go-git-5.13.2/plumbing/object/commitgraph/commitnode_walker_ctime.go 0000664 0000000 0000000 00000004374 14744245500 0025615 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/emirpasic/gods/trees/binaryheap"
)
type commitNodeIteratorByCTime struct {
heap *binaryheap.Heap
seenExternal map[plumbing.Hash]bool
seen map[plumbing.Hash]bool
}
// NewCommitNodeIterCTime returns a CommitNodeIter that walks the commit history,
// starting at the given commit and visiting its parents while preserving Committer Time order.
// this is close in order to `git log` but does not guarantee topological order and will
// order things incorrectly occasionally.
// The given callback will be called for each visited commit. Each commit will
// be visited only once. If the callback returns an error, walking will stop
// and will return the error. Other errors might be returned if the history
// cannot be traversed (e.g. missing objects). Ignore allows to skip some
// commits from being iterated.
func NewCommitNodeIterCTime(
c CommitNode,
seenExternal map[plumbing.Hash]bool,
ignore []plumbing.Hash,
) CommitNodeIter {
seen := make(map[plumbing.Hash]bool)
for _, h := range ignore {
seen[h] = true
}
heap := binaryheap.NewWith(func(a, b interface{}) int {
if a.(CommitNode).CommitTime().Before(b.(CommitNode).CommitTime()) {
return 1
}
return -1
})
heap.Push(c)
return &commitNodeIteratorByCTime{
heap: heap,
seenExternal: seenExternal,
seen: seen,
}
}
func (w *commitNodeIteratorByCTime) Next() (CommitNode, error) {
var c CommitNode
for {
cIn, ok := w.heap.Pop()
if !ok {
return nil, io.EOF
}
c = cIn.(CommitNode)
cID := c.ID()
if w.seen[cID] || w.seenExternal[cID] {
continue
}
w.seen[cID] = true
for i, h := range c.ParentHashes() {
if w.seen[h] || w.seenExternal[h] {
continue
}
pc, err := c.ParentNode(i)
if err != nil {
return nil, err
}
w.heap.Push(pc)
}
return c, nil
}
}
func (w *commitNodeIteratorByCTime) ForEach(cb func(CommitNode) error) error {
for {
c, err := w.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
err = cb(c)
if err == storer.ErrStop {
break
}
if err != nil {
return err
}
}
return nil
}
func (w *commitNodeIteratorByCTime) Close() {}
go-git-5.13.2/plumbing/object/commitgraph/commitnode_walker_date_order.go 0000664 0000000 0000000 00000002161 14744245500 0026614 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/emirpasic/gods/trees/binaryheap"
)
// NewCommitNodeIterDateOrder returns a CommitNodeIter that walks the commit history,
// starting at the given commit and visiting its parents in Committer Time and Generation order,
// but with the constraint that no parent is emitted before its children are emitted.
//
// This matches `git log --date-order`
func NewCommitNodeIterDateOrder(c CommitNode,
seenExternal map[plumbing.Hash]bool,
ignore []plumbing.Hash,
) CommitNodeIter {
seen := make(map[plumbing.Hash]struct{})
for _, h := range ignore {
seen[h] = struct{}{}
}
for h, ext := range seenExternal {
if ext {
seen[h] = struct{}{}
}
}
inCounts := make(map[plumbing.Hash]int)
exploreHeap := &commitNodeHeap{binaryheap.NewWith(generationAndDateOrderComparator)}
exploreHeap.Push(c)
visitHeap := &commitNodeHeap{binaryheap.NewWith(generationAndDateOrderComparator)}
visitHeap.Push(c)
return &commitNodeIteratorTopological{
exploreStack: exploreHeap,
visitStack: visitHeap,
inCounts: inCounts,
ignore: seen,
}
}
go-git-5.13.2/plumbing/object/commitgraph/commitnode_walker_helper.go 0000664 0000000 0000000 00000010457 14744245500 0025772 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"math"
"github.com/go-git/go-git/v5/plumbing"
"github.com/emirpasic/gods/trees/binaryheap"
)
// commitNodeStackable represents a common interface between heaps and stacks
type commitNodeStackable interface {
Push(c CommitNode)
Pop() (CommitNode, bool)
Peek() (CommitNode, bool)
Size() int
}
// commitNodeLifo is a stack implementation using an underlying slice
type commitNodeLifo struct {
l []CommitNode
}
// Push pushes a new CommitNode to the stack
func (l *commitNodeLifo) Push(c CommitNode) {
l.l = append(l.l, c)
}
// Pop pops the most recently added CommitNode from the stack
func (l *commitNodeLifo) Pop() (CommitNode, bool) {
if len(l.l) == 0 {
return nil, false
}
c := l.l[len(l.l)-1]
l.l = l.l[:len(l.l)-1]
return c, true
}
// Peek returns the most recently added CommitNode from the stack without removing it
func (l *commitNodeLifo) Peek() (CommitNode, bool) {
if len(l.l) == 0 {
return nil, false
}
return l.l[len(l.l)-1], true
}
// Size returns the number of CommitNodes in the stack
func (l *commitNodeLifo) Size() int {
return len(l.l)
}
// commitNodeHeap is a stack implementation using an underlying binary heap
type commitNodeHeap struct {
*binaryheap.Heap
}
// Push pushes a new CommitNode to the heap
func (h *commitNodeHeap) Push(c CommitNode) {
h.Heap.Push(c)
}
// Pop removes top element on heap and returns it, or nil if heap is empty.
// Second return parameter is true, unless the heap was empty and there was nothing to pop.
func (h *commitNodeHeap) Pop() (CommitNode, bool) {
c, ok := h.Heap.Pop()
if !ok {
return nil, false
}
return c.(CommitNode), true
}
// Peek returns top element on the heap without removing it, or nil if heap is empty.
// Second return parameter is true, unless the heap was empty and there was nothing to peek.
func (h *commitNodeHeap) Peek() (CommitNode, bool) {
c, ok := h.Heap.Peek()
if !ok {
return nil, false
}
return c.(CommitNode), true
}
// Size returns number of elements within the heap.
func (h *commitNodeHeap) Size() int {
return h.Heap.Size()
}
// generationAndDateOrderComparator compares two CommitNode objects based on their generation and commit time.
// If the left CommitNode object is in a higher generation or is newer than the right one, it returns a -1.
// If the left CommitNode object is in a lower generation or is older than the right one, it returns a 1.
// If the two CommitNode objects have the same commit time and generation, it returns 0.
func generationAndDateOrderComparator(left, right interface{}) int {
leftCommit := left.(CommitNode)
rightCommit := right.(CommitNode)
// if GenerationV2 is MaxUint64, then the node is not in the graph
if leftCommit.GenerationV2() == math.MaxUint64 {
if rightCommit.GenerationV2() == math.MaxUint64 {
switch {
case rightCommit.CommitTime().Before(leftCommit.CommitTime()):
return -1
case leftCommit.CommitTime().Before(rightCommit.CommitTime()):
return 1
}
return 0
}
// left is not in the graph, but right is, so it is newer than the right
return -1
}
if rightCommit.GenerationV2() == math.MaxInt64 {
// the right is not in the graph, therefore the left is before the right
return 1
}
if leftCommit.GenerationV2() == 0 || rightCommit.GenerationV2() == 0 {
// We need to assess generation and date
if leftCommit.Generation() < rightCommit.Generation() {
return 1
}
if leftCommit.Generation() > rightCommit.Generation() {
return -1
}
switch {
case rightCommit.CommitTime().Before(leftCommit.CommitTime()):
return -1
case leftCommit.CommitTime().Before(rightCommit.CommitTime()):
return 1
}
return 0
}
if leftCommit.GenerationV2() < rightCommit.GenerationV2() {
return 1
}
if leftCommit.GenerationV2() > rightCommit.GenerationV2() {
return -1
}
return 0
}
// composeIgnores composes the ignore list with the provided seenExternal list
func composeIgnores(ignore []plumbing.Hash, seenExternal map[plumbing.Hash]bool) map[plumbing.Hash]struct{} {
if len(ignore) == 0 {
seen := make(map[plumbing.Hash]struct{})
for h, ext := range seenExternal {
if ext {
seen[h] = struct{}{}
}
}
return seen
}
seen := make(map[plumbing.Hash]struct{})
for _, h := range ignore {
seen[h] = struct{}{}
}
for h, ext := range seenExternal {
if ext {
seen[h] = struct{}{}
}
}
return seen
}
go-git-5.13.2/plumbing/object/commitgraph/commitnode_walker_test.go 0000664 0000000 0000000 00000014172 14744245500 0025470 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"strings"
"github.com/go-git/go-git/v5/plumbing"
commitgraph "github.com/go-git/go-git/v5/plumbing/format/commitgraph/v2"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func (s *CommitNodeSuite) TestCommitNodeIter(c *C) {
f := fixtures.ByTag("commit-graph-chain-2").One()
storer := unpackRepository(f)
index, err := commitgraph.OpenChainOrFileIndex(storer.Filesystem())
c.Assert(err, IsNil)
nodeIndex := NewGraphCommitNodeIndex(index, storer)
head, err := nodeIndex.Get(plumbing.NewHash("ec6f456c0e8c7058a29611429965aa05c190b54b"))
c.Assert(err, IsNil)
testTopoOrder(c, head)
testDateOrder(c, head)
testAuthorDateOrder(c, head)
}
func testTopoOrder(c *C, head CommitNode) {
iter := NewCommitNodeIterTopoOrder(
head,
nil,
nil,
)
var commits []string
iter.ForEach(func(c CommitNode) error {
commits = append(commits, c.ID().String())
return nil
})
c.Assert(commits, DeepEquals, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b
d82f291cde9987322c8a0c81a325e1ba6159684c
3048d280d2d5b258d9e582a226ff4bbed34fd5c9
27aa8cdd2431068606741a589383c02c149ea625
fa058d42fa3bc53f39108a56dad67157169b2191
6c629843a1750a27c9af01ed2985f362f619c47a
d10a0e7c1f340a6cfc14540a5f8c508ce7e2eabf
d0a18ccd8eea3bdabc76d6dc5420af1ea30aae9f
cf2874632223220e0445abf0a7806dc772c0b37a
758ac33217f092bfcded4ad4774954ac054c9609
214e1dca024fb6da5ed65564d2de734df5dc2127
70923099e61fa33f0bc5256d2f938fa44c4df10e
bcaa1ac5644b16f1febb72f31e204720b7bb8934
e1d8866ffa78fa16d2f39b0ba5344a7269ee5371
2275fa7d0c75d20103f90b0e1616937d5a9fc5e6
bdd9a92789d4a86b20a8d3df462df373f41acf23
b359f11ea09e642695edcd114b463da4395b10c1
6f43e8933ba3c04072d5d104acc6118aac3e52ee
ccafe8bd5f9dbfb8b98b0da03ced29608dcfdeec
939814f341fdd5d35e81a3845a33c4fedb19d2d2
5f5ad88bf2babe506f927d64d2b7a1e1493dc2ae
a2014124ca3b3f9ff28fbab0a83ce3c71bf4622e
77906b653c3eb8a1cd5bd7254e161c00c6086d83
465cba710284204f9851854587c2887c247222db
b9471b13256703d3f5eb88b280b4a16ce325ec1b
62925030859646daeeaf5a4d386a0c41e00dda8a
5f56aea0ca8b74215a5b982bca32236e1e28c76b
23148841baa5dbce48f6adcb7ddf83dcd97debb3
c336d16298a017486c4164c40f8acb28afe64e84
31eae7b619d166c366bf5df4991f04ba8cebea0a
d2a38b4a5965d529566566640519d03d2bd10f6c
b977a025ca21e3b5ca123d8093bd7917694f6da7
35b585759cbf29f8ec428ef89da20705d59f99ec
c2bbf9fe8009b22d0f390f3c8c3f13937067590f
fc9f0643b21cfe571046e27e0c4565f3a1ee96c8
c088fd6a7e1a38e9d5a9815265cb575bb08d08ff
5fddbeb678bd2c36c5e5c891ab8f2b143ced5baf
5d7303c49ac984a9fec60523f2d5297682e16646`, "\n"))
}
func testDateOrder(c *C, head CommitNode) {
iter := NewCommitNodeIterDateOrder(
head,
nil,
nil,
)
var commits []string
iter.ForEach(func(c CommitNode) error {
commits = append(commits, c.ID().String())
return nil
})
c.Assert(commits, DeepEquals, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b
3048d280d2d5b258d9e582a226ff4bbed34fd5c9
d82f291cde9987322c8a0c81a325e1ba6159684c
27aa8cdd2431068606741a589383c02c149ea625
fa058d42fa3bc53f39108a56dad67157169b2191
d0a18ccd8eea3bdabc76d6dc5420af1ea30aae9f
6c629843a1750a27c9af01ed2985f362f619c47a
cf2874632223220e0445abf0a7806dc772c0b37a
d10a0e7c1f340a6cfc14540a5f8c508ce7e2eabf
758ac33217f092bfcded4ad4774954ac054c9609
214e1dca024fb6da5ed65564d2de734df5dc2127
70923099e61fa33f0bc5256d2f938fa44c4df10e
bcaa1ac5644b16f1febb72f31e204720b7bb8934
e1d8866ffa78fa16d2f39b0ba5344a7269ee5371
2275fa7d0c75d20103f90b0e1616937d5a9fc5e6
bdd9a92789d4a86b20a8d3df462df373f41acf23
b359f11ea09e642695edcd114b463da4395b10c1
6f43e8933ba3c04072d5d104acc6118aac3e52ee
ccafe8bd5f9dbfb8b98b0da03ced29608dcfdeec
939814f341fdd5d35e81a3845a33c4fedb19d2d2
5f5ad88bf2babe506f927d64d2b7a1e1493dc2ae
a2014124ca3b3f9ff28fbab0a83ce3c71bf4622e
77906b653c3eb8a1cd5bd7254e161c00c6086d83
465cba710284204f9851854587c2887c247222db
b9471b13256703d3f5eb88b280b4a16ce325ec1b
62925030859646daeeaf5a4d386a0c41e00dda8a
5f56aea0ca8b74215a5b982bca32236e1e28c76b
23148841baa5dbce48f6adcb7ddf83dcd97debb3
c336d16298a017486c4164c40f8acb28afe64e84
31eae7b619d166c366bf5df4991f04ba8cebea0a
b977a025ca21e3b5ca123d8093bd7917694f6da7
d2a38b4a5965d529566566640519d03d2bd10f6c
35b585759cbf29f8ec428ef89da20705d59f99ec
c2bbf9fe8009b22d0f390f3c8c3f13937067590f
fc9f0643b21cfe571046e27e0c4565f3a1ee96c8
c088fd6a7e1a38e9d5a9815265cb575bb08d08ff
5fddbeb678bd2c36c5e5c891ab8f2b143ced5baf
5d7303c49ac984a9fec60523f2d5297682e16646`, "\n"))
}
func testAuthorDateOrder(c *C, head CommitNode) {
iter := NewCommitNodeIterAuthorDateOrder(
head,
nil,
nil,
)
var commits []string
iter.ForEach(func(c CommitNode) error {
commits = append(commits, c.ID().String())
return nil
})
c.Assert(commits, DeepEquals, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b
3048d280d2d5b258d9e582a226ff4bbed34fd5c9
d82f291cde9987322c8a0c81a325e1ba6159684c
27aa8cdd2431068606741a589383c02c149ea625
fa058d42fa3bc53f39108a56dad67157169b2191
d0a18ccd8eea3bdabc76d6dc5420af1ea30aae9f
6c629843a1750a27c9af01ed2985f362f619c47a
cf2874632223220e0445abf0a7806dc772c0b37a
d10a0e7c1f340a6cfc14540a5f8c508ce7e2eabf
758ac33217f092bfcded4ad4774954ac054c9609
214e1dca024fb6da5ed65564d2de734df5dc2127
70923099e61fa33f0bc5256d2f938fa44c4df10e
bcaa1ac5644b16f1febb72f31e204720b7bb8934
e1d8866ffa78fa16d2f39b0ba5344a7269ee5371
2275fa7d0c75d20103f90b0e1616937d5a9fc5e6
bdd9a92789d4a86b20a8d3df462df373f41acf23
b359f11ea09e642695edcd114b463da4395b10c1
6f43e8933ba3c04072d5d104acc6118aac3e52ee
ccafe8bd5f9dbfb8b98b0da03ced29608dcfdeec
939814f341fdd5d35e81a3845a33c4fedb19d2d2
5f5ad88bf2babe506f927d64d2b7a1e1493dc2ae
a2014124ca3b3f9ff28fbab0a83ce3c71bf4622e
77906b653c3eb8a1cd5bd7254e161c00c6086d83
465cba710284204f9851854587c2887c247222db
b9471b13256703d3f5eb88b280b4a16ce325ec1b
5f56aea0ca8b74215a5b982bca32236e1e28c76b
62925030859646daeeaf5a4d386a0c41e00dda8a
23148841baa5dbce48f6adcb7ddf83dcd97debb3
c336d16298a017486c4164c40f8acb28afe64e84
31eae7b619d166c366bf5df4991f04ba8cebea0a
b977a025ca21e3b5ca123d8093bd7917694f6da7
d2a38b4a5965d529566566640519d03d2bd10f6c
35b585759cbf29f8ec428ef89da20705d59f99ec
c2bbf9fe8009b22d0f390f3c8c3f13937067590f
fc9f0643b21cfe571046e27e0c4565f3a1ee96c8
c088fd6a7e1a38e9d5a9815265cb575bb08d08ff
5fddbeb678bd2c36c5e5c891ab8f2b143ced5baf
5d7303c49ac984a9fec60523f2d5297682e16646`, "\n"))
}
go-git-5.13.2/plumbing/object/commitgraph/commitnode_walker_topo_order.go 0000664 0000000 0000000 00000006216 14744245500 0026665 0 ustar 00root root 0000000 0000000 package commitgraph
import (
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/emirpasic/gods/trees/binaryheap"
)
type commitNodeIteratorTopological struct {
exploreStack commitNodeStackable
visitStack commitNodeStackable
inCounts map[plumbing.Hash]int
ignore map[plumbing.Hash]struct{}
}
// NewCommitNodeIterTopoOrder returns a CommitNodeIter that walks the commit history,
// starting at the given commit and visiting its parents in a topological order but
// with the constraint that no parent is emitted before its children are emitted.
//
// This matches `git log --topo-order`
func NewCommitNodeIterTopoOrder(c CommitNode,
seenExternal map[plumbing.Hash]bool,
ignore []plumbing.Hash,
) CommitNodeIter {
seen := composeIgnores(ignore, seenExternal)
inCounts := make(map[plumbing.Hash]int)
heap := &commitNodeHeap{binaryheap.NewWith(generationAndDateOrderComparator)}
heap.Push(c)
lifo := &commitNodeLifo{make([]CommitNode, 0, 8)}
lifo.Push(c)
return &commitNodeIteratorTopological{
exploreStack: heap,
visitStack: lifo,
inCounts: inCounts,
ignore: seen,
}
}
func (iter *commitNodeIteratorTopological) Next() (CommitNode, error) {
var next CommitNode
for {
var ok bool
next, ok = iter.visitStack.Pop()
if !ok {
return nil, io.EOF
}
if iter.inCounts[next.ID()] == 0 {
break
}
}
minimumLevel, generationV2 := next.GenerationV2(), true
if minimumLevel == 0 {
minimumLevel, generationV2 = next.Generation(), false
}
parents := make([]CommitNode, 0, len(next.ParentHashes()))
for i := range next.ParentHashes() {
pc, err := next.ParentNode(i)
if err != nil {
return nil, err
}
parents = append(parents, pc)
if generationV2 {
if pc.GenerationV2() < minimumLevel {
minimumLevel = pc.GenerationV2()
}
continue
}
if pc.Generation() < minimumLevel {
minimumLevel = pc.Generation()
}
}
// EXPLORE
for {
toExplore, ok := iter.exploreStack.Peek()
if !ok {
break
}
if toExplore.ID() != next.ID() && iter.exploreStack.Size() == 1 {
break
}
if generationV2 {
if toExplore.GenerationV2() < minimumLevel {
break
}
} else {
if toExplore.Generation() < minimumLevel {
break
}
}
iter.exploreStack.Pop()
for i, h := range toExplore.ParentHashes() {
if _, has := iter.ignore[h]; has {
continue
}
iter.inCounts[h]++
if iter.inCounts[h] == 1 {
pc, err := toExplore.ParentNode(i)
if err != nil {
return nil, err
}
iter.exploreStack.Push(pc)
}
}
}
// VISIT
for i, h := range next.ParentHashes() {
if _, has := iter.ignore[h]; has {
continue
}
iter.inCounts[h]--
if iter.inCounts[h] == 0 {
iter.visitStack.Push(parents[i])
}
}
delete(iter.inCounts, next.ID())
return next, nil
}
func (iter *commitNodeIteratorTopological) ForEach(cb func(CommitNode) error) error {
for {
obj, err := iter.Next()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
if err := cb(obj); err != nil {
if err == storer.ErrStop {
return nil
}
return err
}
}
}
func (iter *commitNodeIteratorTopological) Close() {
}
go-git-5.13.2/plumbing/object/commitgraph/doc.go 0000664 0000000 0000000 00000000550 14744245500 0021466 0 ustar 00root root 0000000 0000000 // Package commitgraph provides an interface for efficient traversal over Git
// commit graph either through the regular object storage, or optionally with
// the index stored in commit-graph file (Git 2.18+).
//
// The API and functionality of this package are considered EXPERIMENTAL and is
// not considered stable nor production ready.
package commitgraph
go-git-5.13.2/plumbing/object/difftree.go 0000664 0000000 0000000 00000006077 14744245500 0020211 0 ustar 00root root 0000000 0000000 package object
import (
"bytes"
"context"
"github.com/go-git/go-git/v5/utils/merkletrie"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
// DiffTree compares the content and mode of the blobs found via two
// tree objects.
// DiffTree does not perform rename detection, use DiffTreeWithOptions
// instead to detect renames.
func DiffTree(a, b *Tree) (Changes, error) {
return DiffTreeContext(context.Background(), a, b)
}
// DiffTreeContext compares the content and mode of the blobs found via two
// tree objects. Provided context must be non-nil.
// An error will be returned if context expires.
func DiffTreeContext(ctx context.Context, a, b *Tree) (Changes, error) {
return DiffTreeWithOptions(ctx, a, b, nil)
}
// DiffTreeOptions are the configurable options when performing a diff tree.
type DiffTreeOptions struct {
// DetectRenames is whether the diff tree will use rename detection.
DetectRenames bool
// RenameScore is the threshold to of similarity between files to consider
// that a pair of delete and insert are a rename. The number must be
// exactly between 0 and 100.
RenameScore uint
// RenameLimit is the maximum amount of files that can be compared when
// detecting renames. The number of comparisons that have to be performed
// is equal to the number of deleted files * the number of added files.
// That means, that if 100 files were deleted and 50 files were added, 5000
// file comparisons may be needed. So, if the rename limit is 50, the number
// of both deleted and added needs to be equal or less than 50.
// A value of 0 means no limit.
RenameLimit uint
// OnlyExactRenames performs only detection of exact renames and will not perform
// any detection of renames based on file similarity.
OnlyExactRenames bool
}
// DefaultDiffTreeOptions are the default and recommended options for the
// diff tree.
var DefaultDiffTreeOptions = &DiffTreeOptions{
DetectRenames: true,
RenameScore: 60,
RenameLimit: 0,
OnlyExactRenames: false,
}
// DiffTreeWithOptions compares the content and mode of the blobs found
// via two tree objects with the given options. The provided context
// must be non-nil.
// If no options are passed, no rename detection will be performed. The
// recommended options are DefaultDiffTreeOptions.
// An error will be returned if the context expires.
// This function will be deprecated and removed in v6 so the default
// behaviour of DiffTree is to detect renames.
func DiffTreeWithOptions(
ctx context.Context,
a, b *Tree,
opts *DiffTreeOptions,
) (Changes, error) {
from := NewTreeRootNode(a)
to := NewTreeRootNode(b)
hashEqual := func(a, b noder.Hasher) bool {
return bytes.Equal(a.Hash(), b.Hash())
}
merkletrieChanges, err := merkletrie.DiffTreeContext(ctx, from, to, hashEqual)
if err != nil {
if err == merkletrie.ErrCanceled {
return nil, ErrCanceled
}
return nil, err
}
changes, err := newChanges(merkletrieChanges)
if err != nil {
return nil, err
}
if opts == nil {
opts = new(DiffTreeOptions)
}
if opts.DetectRenames {
return DetectRenames(changes, opts)
}
return changes, nil
}
go-git-5.13.2/plumbing/object/difftree_test.go 0000664 0000000 0000000 00000025543 14744245500 0021247 0 ustar 00root root 0000000 0000000 package object
import (
"sort"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-git/v5/storage/memory"
"github.com/go-git/go-git/v5/utils/merkletrie"
. "gopkg.in/check.v1"
)
type DiffTreeSuite struct {
fixtures.Suite
Storer storer.EncodedObjectStorer
Fixture *fixtures.Fixture
cache map[string]storer.EncodedObjectStorer
}
func (s *DiffTreeSuite) SetUpSuite(c *C) {
s.Fixture = fixtures.Basic().One()
sto := filesystem.NewStorage(s.Fixture.DotGit(), cache.NewObjectLRUDefault())
s.Storer = sto
s.cache = make(map[string]storer.EncodedObjectStorer)
}
func (s *DiffTreeSuite) commitFromStorer(c *C, sto storer.EncodedObjectStorer,
h plumbing.Hash) *Commit {
commit, err := GetCommit(sto, h)
c.Assert(err, IsNil)
return commit
}
func (s *DiffTreeSuite) storageFromPackfile(f *fixtures.Fixture) storer.EncodedObjectStorer {
sto, ok := s.cache[f.URL]
if ok {
return sto
}
storer := memory.NewStorage()
pf := f.Packfile()
defer pf.Close()
if err := packfile.UpdateObjectStorage(storer, pf); err != nil {
panic(err)
}
s.cache[f.URL] = storer
return storer
}
var _ = Suite(&DiffTreeSuite{})
type expectChange struct {
Action merkletrie.Action
Name string
}
func assertChanges(a Changes, c *C) {
for _, changes := range a {
action, err := changes.Action()
c.Assert(err, IsNil)
switch action {
case merkletrie.Insert:
c.Assert(changes.From.Tree, IsNil)
c.Assert(changes.To.Tree, NotNil)
case merkletrie.Delete:
c.Assert(changes.From.Tree, NotNil)
c.Assert(changes.To.Tree, IsNil)
case merkletrie.Modify:
c.Assert(changes.From.Tree, NotNil)
c.Assert(changes.To.Tree, NotNil)
default:
c.Fatalf("unknown action: %d", action)
}
}
}
func equalChanges(a Changes, b []expectChange, c *C) bool {
if len(a) != len(b) {
return false
}
sort.Sort(a)
for i, va := range a {
vb := b[i]
action, err := va.Action()
c.Assert(err, IsNil)
if action != vb.Action || va.name() != vb.Name {
return false
}
}
return true
}
func (s *DiffTreeSuite) TestDiffTree(c *C) {
for i, t := range []struct {
repository string // the repo name as in localRepos
commit1 string // the commit of the first tree
commit2 string // the commit of the second tree
expected []expectChange // the expected list of []changeExpect
}{
{
"https://github.com/dezfowler/LiteMock.git",
"",
"",
[]expectChange{},
},
{
"https://github.com/dezfowler/LiteMock.git",
"b7965eaa2c4f245d07191fe0bcfe86da032d672a",
"b7965eaa2c4f245d07191fe0bcfe86da032d672a",
[]expectChange{},
},
{
"https://github.com/dezfowler/LiteMock.git",
"",
"b7965eaa2c4f245d07191fe0bcfe86da032d672a",
[]expectChange{
{Action: merkletrie.Insert, Name: "README"},
},
},
{
"https://github.com/dezfowler/LiteMock.git",
"b7965eaa2c4f245d07191fe0bcfe86da032d672a",
"",
[]expectChange{
{Action: merkletrie.Delete, Name: "README"},
},
},
{
"https://github.com/githubtraining/example-branches.git",
"",
"f0eb272cc8f77803478c6748103a1450aa1abd37",
[]expectChange{
{Action: merkletrie.Insert, Name: "README.md"},
},
},
{
"https://github.com/githubtraining/example-branches.git",
"f0eb272cc8f77803478c6748103a1450aa1abd37",
"",
[]expectChange{
{Action: merkletrie.Delete, Name: "README.md"},
},
},
{
"https://github.com/githubtraining/example-branches.git",
"f0eb272cc8f77803478c6748103a1450aa1abd37",
"f0eb272cc8f77803478c6748103a1450aa1abd37",
[]expectChange{},
},
{
"https://github.com/github/gem-builder.git",
"",
"9608eed92b3839b06ebf72d5043da547de10ce85",
[]expectChange{
{Action: merkletrie.Insert, Name: "README"},
{Action: merkletrie.Insert, Name: "gem_builder.rb"},
{Action: merkletrie.Insert, Name: "gem_eval.rb"},
},
},
{
"https://github.com/github/gem-builder.git",
"9608eed92b3839b06ebf72d5043da547de10ce85",
"",
[]expectChange{
{Action: merkletrie.Delete, Name: "README"},
{Action: merkletrie.Delete, Name: "gem_builder.rb"},
{Action: merkletrie.Delete, Name: "gem_eval.rb"},
},
},
{
"https://github.com/github/gem-builder.git",
"9608eed92b3839b06ebf72d5043da547de10ce85",
"9608eed92b3839b06ebf72d5043da547de10ce85",
[]expectChange{},
},
{
"https://github.com/toqueteos/ts3.git",
"",
"764e914b75d6d6df1fc5d832aa9840f590abf1bb",
[]expectChange{
{Action: merkletrie.Insert, Name: "README.markdown"},
{Action: merkletrie.Insert, Name: "examples/bot.go"},
{Action: merkletrie.Insert, Name: "examples/raw_shell.go"},
{Action: merkletrie.Insert, Name: "helpers.go"},
{Action: merkletrie.Insert, Name: "ts3.go"},
},
},
{
"https://github.com/toqueteos/ts3.git",
"764e914b75d6d6df1fc5d832aa9840f590abf1bb",
"",
[]expectChange{
{Action: merkletrie.Delete, Name: "README.markdown"},
{Action: merkletrie.Delete, Name: "examples/bot.go"},
{Action: merkletrie.Delete, Name: "examples/raw_shell.go"},
{Action: merkletrie.Delete, Name: "helpers.go"},
{Action: merkletrie.Delete, Name: "ts3.go"},
},
},
{
"https://github.com/toqueteos/ts3.git",
"764e914b75d6d6df1fc5d832aa9840f590abf1bb",
"764e914b75d6d6df1fc5d832aa9840f590abf1bb",
[]expectChange{},
},
{
"https://github.com/github/gem-builder.git",
"9608eed92b3839b06ebf72d5043da547de10ce85",
"6c41e05a17e19805879689414026eb4e279f7de0",
[]expectChange{
{Action: merkletrie.Modify, Name: "gem_eval.rb"},
},
},
{
"https://github.com/github/gem-builder.git",
"6c41e05a17e19805879689414026eb4e279f7de0",
"89be3aac2f178719c12953cc9eaa23441f8d9371",
[]expectChange{
{Action: merkletrie.Modify, Name: "gem_eval.rb"},
{Action: merkletrie.Insert, Name: "gem_eval_test.rb"},
{Action: merkletrie.Insert, Name: "security.rb"},
{Action: merkletrie.Insert, Name: "security_test.rb"},
},
},
{
"https://github.com/github/gem-builder.git",
"89be3aac2f178719c12953cc9eaa23441f8d9371",
"597240b7da22d03ad555328f15abc480b820acc0",
[]expectChange{
{Action: merkletrie.Modify, Name: "gem_eval.rb"},
},
},
{
"https://github.com/github/gem-builder.git",
"597240b7da22d03ad555328f15abc480b820acc0",
"0260380e375d2dd0e1a8fcab15f91ce56dbe778e",
[]expectChange{
{Action: merkletrie.Modify, Name: "gem_eval.rb"},
{Action: merkletrie.Modify, Name: "gem_eval_test.rb"},
{Action: merkletrie.Insert, Name: "lazy_dir.rb"},
{Action: merkletrie.Insert, Name: "lazy_dir_test.rb"},
{Action: merkletrie.Modify, Name: "security.rb"},
{Action: merkletrie.Modify, Name: "security_test.rb"},
},
},
{
"https://github.com/github/gem-builder.git",
"0260380e375d2dd0e1a8fcab15f91ce56dbe778e",
"597240b7da22d03ad555328f15abc480b820acc0",
[]expectChange{
{Action: merkletrie.Modify, Name: "gem_eval.rb"},
{Action: merkletrie.Modify, Name: "gem_eval_test.rb"},
{Action: merkletrie.Delete, Name: "lazy_dir.rb"},
{Action: merkletrie.Delete, Name: "lazy_dir_test.rb"},
{Action: merkletrie.Modify, Name: "security.rb"},
{Action: merkletrie.Modify, Name: "security_test.rb"},
},
},
{
"https://github.com/github/gem-builder.git",
"0260380e375d2dd0e1a8fcab15f91ce56dbe778e",
"ca9fd470bacb6262eb4ca23ee48bb2f43711c1ff",
[]expectChange{
{Action: merkletrie.Modify, Name: "gem_eval.rb"},
{Action: merkletrie.Modify, Name: "security.rb"},
{Action: merkletrie.Modify, Name: "security_test.rb"},
},
},
{
"https://github.com/github/gem-builder.git",
"fe3c86745f887c23a0d38c85cfd87ca957312f86",
"b7e3f636febf7a0cd3ab473b6d30081786d2c5b6",
[]expectChange{
{Action: merkletrie.Modify, Name: "gem_eval.rb"},
{Action: merkletrie.Modify, Name: "gem_eval_test.rb"},
{Action: merkletrie.Insert, Name: "git_mock"},
{Action: merkletrie.Modify, Name: "lazy_dir.rb"},
{Action: merkletrie.Modify, Name: "lazy_dir_test.rb"},
{Action: merkletrie.Modify, Name: "security.rb"},
},
},
{
"https://github.com/rumpkernel/rumprun-xen.git",
"1831e47b0c6db750714cd0e4be97b5af17fb1eb0",
"51d8515578ea0c88cc8fc1a057903675cf1fc16c",
[]expectChange{
{Action: merkletrie.Modify, Name: "Makefile"},
{Action: merkletrie.Modify, Name: "netbsd_init.c"},
{Action: merkletrie.Modify, Name: "rumphyper_stubs.c"},
{Action: merkletrie.Delete, Name: "sysproxy.c"},
},
},
{
"https://github.com/rumpkernel/rumprun-xen.git",
"1831e47b0c6db750714cd0e4be97b5af17fb1eb0",
"e13e678f7ee9badd01b120889e0ec5fdc8ae3802",
[]expectChange{
{Action: merkletrie.Modify, Name: "app-tools/rumprun"},
},
},
} {
f := fixtures.ByURL(t.repository).One()
sto := s.storageFromPackfile(f)
var tree1, tree2 *Tree
var err error
if t.commit1 != "" {
tree1, err = s.commitFromStorer(c, sto,
plumbing.NewHash(t.commit1)).Tree()
c.Assert(err, IsNil,
Commentf("subtest %d: unable to retrieve tree from commit %s and repo %s: %s", i, t.commit1, t.repository, err))
}
if t.commit2 != "" {
tree2, err = s.commitFromStorer(c, sto,
plumbing.NewHash(t.commit2)).Tree()
c.Assert(err, IsNil,
Commentf("subtest %d: unable to retrieve tree from commit %s and repo %s", i, t.commit2, t.repository, err))
}
obtained, err := DiffTree(tree1, tree2)
c.Assert(err, IsNil,
Commentf("subtest %d: unable to calculate difftree: %s", i, err))
obtainedFromMethod, err := tree1.Diff(tree2)
c.Assert(err, IsNil,
Commentf("subtest %d: unable to calculate difftree: %s. Result calling Diff method from Tree object returns an error", i, err))
c.Assert(obtained, DeepEquals, obtainedFromMethod)
c.Assert(equalChanges(obtained, t.expected, c), Equals, true,
Commentf("subtest:%d\nrepo=%s\ncommit1=%s\ncommit2=%s\nexpected=%s\nobtained=%s",
i, t.repository, t.commit1, t.commit2, t.expected, obtained))
assertChanges(obtained, c)
}
}
func (s *DiffTreeSuite) TestIssue279(c *C) {
// treeNoders should have the same hash when their mode is
// filemode.Deprecated and filemode.Regular.
a := &treeNoder{
hash: plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
mode: filemode.Regular,
}
b := &treeNoder{
hash: plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
mode: filemode.Deprecated,
}
c.Assert(a.Hash(), DeepEquals, b.Hash())
// yet, they should have different hashes if their contents change.
aa := &treeNoder{
hash: plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
mode: filemode.Regular,
}
c.Assert(a.Hash(), Not(DeepEquals), aa.Hash())
bb := &treeNoder{
hash: plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
mode: filemode.Deprecated,
}
c.Assert(b.Hash(), Not(DeepEquals), bb.Hash())
}
go-git-5.13.2/plumbing/object/file.go 0000664 0000000 0000000 00000006225 14744245500 0017333 0 ustar 00root root 0000000 0000000 package object
import (
"bytes"
"io"
"strings"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/utils/binary"
"github.com/go-git/go-git/v5/utils/ioutil"
)
// File represents git file objects.
type File struct {
// Name is the path of the file. It might be relative to a tree,
// depending of the function that generates it.
Name string
// Mode is the file mode.
Mode filemode.FileMode
// Blob with the contents of the file.
Blob
}
// NewFile returns a File based on the given blob object
func NewFile(name string, m filemode.FileMode, b *Blob) *File {
return &File{Name: name, Mode: m, Blob: *b}
}
// Contents returns the contents of a file as a string.
func (f *File) Contents() (content string, err error) {
reader, err := f.Reader()
if err != nil {
return "", err
}
defer ioutil.CheckClose(reader, &err)
buf := new(bytes.Buffer)
if _, err := buf.ReadFrom(reader); err != nil {
return "", err
}
return buf.String(), nil
}
// IsBinary returns if the file is binary or not
func (f *File) IsBinary() (bin bool, err error) {
reader, err := f.Reader()
if err != nil {
return false, err
}
defer ioutil.CheckClose(reader, &err)
return binary.IsBinary(reader)
}
// Lines returns a slice of lines from the contents of a file, stripping
// all end of line characters. If the last line is empty (does not end
// in an end of line), it is also stripped.
func (f *File) Lines() ([]string, error) {
content, err := f.Contents()
if err != nil {
return nil, err
}
splits := strings.Split(content, "\n")
// remove the last line if it is empty
if splits[len(splits)-1] == "" {
return splits[:len(splits)-1], nil
}
return splits, nil
}
// FileIter provides an iterator for the files in a tree.
type FileIter struct {
s storer.EncodedObjectStorer
w TreeWalker
}
// NewFileIter takes a storer.EncodedObjectStorer and a Tree and returns a
// *FileIter that iterates over all files contained in the tree, recursively.
func NewFileIter(s storer.EncodedObjectStorer, t *Tree) *FileIter {
return &FileIter{s: s, w: *NewTreeWalker(t, true, nil)}
}
// Next moves the iterator to the next file and returns a pointer to it. If
// there are no more files, it returns io.EOF.
func (iter *FileIter) Next() (*File, error) {
for {
name, entry, err := iter.w.Next()
if err != nil {
return nil, err
}
if entry.Mode == filemode.Dir || entry.Mode == filemode.Submodule {
continue
}
blob, err := GetBlob(iter.s, entry.Hash)
if err != nil {
return nil, err
}
return NewFile(name, entry.Mode, blob), nil
}
}
// ForEach call the cb function for each file contained in this iter until
// an error happens or the end of the iter is reached. If plumbing.ErrStop is sent
// the iteration is stop but no error is returned. The iterator is closed.
func (iter *FileIter) ForEach(cb func(*File) error) error {
defer iter.Close()
for {
f, err := iter.Next()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
if err := cb(f); err != nil {
if err == storer.ErrStop {
return nil
}
return err
}
}
}
func (iter *FileIter) Close() {
iter.w.Close()
}
go-git-5.13.2/plumbing/object/file_test.go 0000664 0000000 0000000 00000016234 14744245500 0020373 0 ustar 00root root 0000000 0000000 package object
import (
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/filesystem"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type FileSuite struct {
BaseObjectsSuite
}
var _ = Suite(&FileSuite{})
type fileIterExpectedEntry struct {
Name string
Hash string
}
var fileIterTests = []struct {
repo string // the repo name as in localRepos
commit string // the commit to search for the file
files []fileIterExpectedEntry
}{
{"https://github.com/git-fixtures/basic.git", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", []fileIterExpectedEntry{
{".gitignore", "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88"},
{"CHANGELOG", "d3ff53e0564a9f87d8e84b6e28e5060e517008aa"},
{"LICENSE", "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f"},
{"binary.jpg", "d5c0f4ab811897cadf03aec358ae60d21f91c50d"},
{"go/example.go", "880cd14280f4b9b6ed3986d6671f907d7cc2a198"},
{"json/long.json", "49c6bb89b17060d7b4deacb7b338fcc6ea2352a9"},
{"json/short.json", "c8f1d8c61f9da76f4cb49fd86322b6e685dba956"},
{"php/crappy.php", "9a48f23120e880dfbe41f7c9b7b708e9ee62a492"},
{"vendor/foo.go", "9dea2395f5403188298c1dabe8bdafe562c491e3"},
}},
}
func (s *FileSuite) TestIter(c *C) {
for i, t := range fileIterTests {
f := fixtures.ByURL(t.repo).One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
h := plumbing.NewHash(t.commit)
commit, err := GetCommit(sto, h)
c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit))
tree, err := commit.Tree()
c.Assert(err, IsNil)
iter := NewFileIter(sto, tree)
for k := 0; k < len(t.files); k++ {
exp := t.files[k]
file, err := iter.Next()
c.Assert(err, IsNil, Commentf("subtest %d, iter %d, err=%v", i, k, err))
c.Assert(file.Mode, Equals, filemode.Regular)
c.Assert(file.Hash.IsZero(), Equals, false)
c.Assert(file.Hash, Equals, file.ID())
c.Assert(file.Name, Equals, exp.Name, Commentf("subtest %d, iter %d, name=%s, expected=%s", i, k, file.Name, exp.Hash))
c.Assert(file.Hash.String(), Equals, exp.Hash, Commentf("subtest %d, iter %d, hash=%v, expected=%s", i, k, file.Hash.String(), exp.Hash))
}
_, err = iter.Next()
c.Assert(err, Equals, io.EOF)
}
}
var contentsTests = []struct {
repo string // the repo name as in localRepos
commit string // the commit to search for the file
path string // the path of the file to find
contents string // expected contents of the file
}{
{
"https://github.com/git-fixtures/basic.git",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
".gitignore",
`*.class
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.ear
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
`,
},
{
"https://github.com/git-fixtures/basic.git",
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"CHANGELOG",
`Initial changelog
`,
},
}
func (s *FileSuite) TestContents(c *C) {
for i, t := range contentsTests {
f := fixtures.ByURL(t.repo).One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
h := plumbing.NewHash(t.commit)
commit, err := GetCommit(sto, h)
c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit))
file, err := commit.File(t.path)
c.Assert(err, IsNil)
content, err := file.Contents()
c.Assert(err, IsNil)
c.Assert(content, Equals, t.contents, Commentf(
"subtest %d: commit=%s, path=%s", i, t.commit, t.path))
}
}
var linesTests = []struct {
repo string // the repo name as in localRepos
commit string // the commit to search for the file
path string // the path of the file to find
lines []string // expected lines in the file
}{
{
"https://github.com/git-fixtures/basic.git",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
".gitignore",
[]string{
"*.class",
"",
"# Mobile Tools for Java (J2ME)",
".mtj.tmp/",
"",
"# Package Files #",
"*.jar",
"*.war",
"*.ear",
"",
"# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml",
"hs_err_pid*",
},
},
{
"https://github.com/git-fixtures/basic.git",
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"CHANGELOG",
[]string{
"Initial changelog",
},
},
}
func (s *FileSuite) TestLines(c *C) {
for i, t := range linesTests {
f := fixtures.ByURL(t.repo).One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
h := plumbing.NewHash(t.commit)
commit, err := GetCommit(sto, h)
c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit))
file, err := commit.File(t.path)
c.Assert(err, IsNil)
lines, err := file.Lines()
c.Assert(err, IsNil)
c.Assert(lines, DeepEquals, t.lines, Commentf(
"subtest %d: commit=%s, path=%s", i, t.commit, t.path))
}
}
var ignoreEmptyDirEntriesTests = []struct {
repo string // the repo name as in localRepos
commit string // the commit to search for the file
}{
{
"https://github.com/cpcs499/Final_Pres_P.git",
"70bade703ce556c2c7391a8065c45c943e8b6bc3",
// the Final dir in this commit is empty
},
}
// It is difficult to assert that we are ignoring an (empty) dir as even
// if we don't, no files will be found in it.
//
// At least this test has a high chance of panicking if
// we don't ignore empty dirs.
func (s *FileSuite) TestIgnoreEmptyDirEntries(c *C) {
for i, t := range ignoreEmptyDirEntriesTests {
f := fixtures.ByURL(t.repo).One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
h := plumbing.NewHash(t.commit)
commit, err := GetCommit(sto, h)
c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit))
tree, err := commit.Tree()
c.Assert(err, IsNil)
iter := tree.Files()
defer iter.Close()
for file, err := iter.Next(); err == nil; file, err = iter.Next() {
_, _ = file.Contents()
// this would probably panic if we are not ignoring empty dirs
}
}
}
func (s *FileSuite) TestFileIter(c *C) {
hash := plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea")
commit, err := GetCommit(s.Storer, hash)
c.Assert(err, IsNil)
tree, err := commit.Tree()
c.Assert(err, IsNil)
expected := []string{
".gitignore",
"CHANGELOG",
"LICENSE",
"binary.jpg",
}
var count int
i := tree.Files()
i.ForEach(func(f *File) error {
c.Assert(f.Name, Equals, expected[count])
count++
return nil
})
c.Assert(count, Equals, 4)
count = 0
i = tree.Files()
i.ForEach(func(f *File) error {
count++
return storer.ErrStop
})
c.Assert(count, Equals, 1)
}
func (s *FileSuite) TestFileIterSubmodule(c *C) {
dotgit := fixtures.ByURL("https://github.com/git-fixtures/submodule.git").One().DotGit()
st := filesystem.NewStorage(dotgit, cache.NewObjectLRUDefault())
hash := plumbing.NewHash("b685400c1f9316f350965a5993d350bc746b0bf4")
commit, err := GetCommit(st, hash)
c.Assert(err, IsNil)
tree, err := commit.Tree()
c.Assert(err, IsNil)
expected := []string{
".gitmodules",
"README.md",
}
var count int
i := tree.Files()
i.ForEach(func(f *File) error {
c.Assert(f.Name, Equals, expected[count])
count++
return nil
})
c.Assert(count, Equals, 2)
}
go-git-5.13.2/plumbing/object/merge_base.go 0000664 0000000 0000000 00000012703 14744245500 0020503 0 ustar 00root root 0000000 0000000 package object
import (
"fmt"
"sort"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
)
// errIsReachable is thrown when first commit is an ancestor of the second
var errIsReachable = fmt.Errorf("first is reachable from second")
// MergeBase mimics the behavior of `git merge-base actual other`, returning the
// best common ancestor between the actual and the passed one.
// The best common ancestors can not be reached from other common ancestors.
func (c *Commit) MergeBase(other *Commit) ([]*Commit, error) {
// use sortedByCommitDateDesc strategy
sorted := sortByCommitDateDesc(c, other)
newer := sorted[0]
older := sorted[1]
newerHistory, err := ancestorsIndex(older, newer)
if err == errIsReachable {
return []*Commit{older}, nil
}
if err != nil {
return nil, err
}
var res []*Commit
inNewerHistory := isInIndexCommitFilter(newerHistory)
resIter := NewFilterCommitIter(older, &inNewerHistory, &inNewerHistory)
_ = resIter.ForEach(func(commit *Commit) error {
res = append(res, commit)
return nil
})
return Independents(res)
}
// IsAncestor returns true if the actual commit is ancestor of the passed one.
// It returns an error if the history is not transversable
// It mimics the behavior of `git merge --is-ancestor actual other`
func (c *Commit) IsAncestor(other *Commit) (bool, error) {
found := false
iter := NewCommitPreorderIter(other, nil, nil)
err := iter.ForEach(func(comm *Commit) error {
if comm.Hash != c.Hash {
return nil
}
found = true
return storer.ErrStop
})
return found, err
}
// ancestorsIndex returns a map with the ancestors of the starting commit if the
// excluded one is not one of them. It returns errIsReachable if the excluded commit
// is ancestor of the starting, or another error if the history is not traversable.
func ancestorsIndex(excluded, starting *Commit) (map[plumbing.Hash]struct{}, error) {
if excluded.Hash.String() == starting.Hash.String() {
return nil, errIsReachable
}
startingHistory := map[plumbing.Hash]struct{}{}
startingIter := NewCommitIterBSF(starting, nil, nil)
err := startingIter.ForEach(func(commit *Commit) error {
if commit.Hash == excluded.Hash {
return errIsReachable
}
startingHistory[commit.Hash] = struct{}{}
return nil
})
if err != nil {
return nil, err
}
return startingHistory, nil
}
// Independents returns a subset of the passed commits, that are not reachable the others
// It mimics the behavior of `git merge-base --independent commit...`.
func Independents(commits []*Commit) ([]*Commit, error) {
// use sortedByCommitDateDesc strategy
candidates := sortByCommitDateDesc(commits...)
candidates = removeDuplicated(candidates)
seen := map[plumbing.Hash]struct{}{}
var isLimit CommitFilter = func(commit *Commit) bool {
_, ok := seen[commit.Hash]
return ok
}
if len(candidates) < 2 {
return candidates, nil
}
pos := 0
for {
from := candidates[pos]
others := remove(candidates, from)
fromHistoryIter := NewFilterCommitIter(from, nil, &isLimit)
err := fromHistoryIter.ForEach(func(fromAncestor *Commit) error {
for _, other := range others {
if fromAncestor.Hash == other.Hash {
candidates = remove(candidates, other)
others = remove(others, other)
}
}
if len(candidates) == 1 {
return storer.ErrStop
}
seen[fromAncestor.Hash] = struct{}{}
return nil
})
if err != nil {
return nil, err
}
nextPos := indexOf(candidates, from) + 1
if nextPos >= len(candidates) {
break
}
pos = nextPos
}
return candidates, nil
}
// sortByCommitDateDesc returns the passed commits, sorted by `committer.When desc`
//
// Following this strategy, it is tried to reduce the time needed when walking
// the history from one commit to reach the others. It is assumed that ancestors
// use to be committed before its descendant;
// That way `Independents(A^, A)` will be processed as being `Independents(A, A^)`;
// so starting by `A` it will be reached `A^` way sooner than walking from `A^`
// to the initial commit, and then from `A` to `A^`.
func sortByCommitDateDesc(commits ...*Commit) []*Commit {
sorted := make([]*Commit, len(commits))
copy(sorted, commits)
sort.Slice(sorted, func(i, j int) bool {
return sorted[i].Committer.When.After(sorted[j].Committer.When)
})
return sorted
}
// indexOf returns the first position where target was found in the passed commits
func indexOf(commits []*Commit, target *Commit) int {
for i, commit := range commits {
if target.Hash == commit.Hash {
return i
}
}
return -1
}
// remove returns the passed commits excluding the commit toDelete
func remove(commits []*Commit, toDelete *Commit) []*Commit {
res := make([]*Commit, len(commits))
j := 0
for _, commit := range commits {
if commit.Hash == toDelete.Hash {
continue
}
res[j] = commit
j++
}
return res[:j]
}
// removeDuplicated removes duplicated commits from the passed slice of commits
func removeDuplicated(commits []*Commit) []*Commit {
seen := make(map[plumbing.Hash]struct{}, len(commits))
res := make([]*Commit, len(commits))
j := 0
for _, commit := range commits {
if _, ok := seen[commit.Hash]; ok {
continue
}
seen[commit.Hash] = struct{}{}
res[j] = commit
j++
}
return res[:j]
}
// isInIndexCommitFilter returns a commitFilter that returns true
// if the commit is in the passed index.
func isInIndexCommitFilter(index map[plumbing.Hash]struct{}) CommitFilter {
return func(c *Commit) bool {
_, ok := index[c.Hash]
return ok
}
}
go-git-5.13.2/plumbing/object/merge_base_test.go 0000664 0000000 0000000 00000027700 14744245500 0021545 0 ustar 00root root 0000000 0000000 package object
import (
"fmt"
"sort"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/storage/filesystem"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func alphabeticSortCommits(commits []*Commit) {
sort.Slice(commits, func(i, j int) bool {
return commits[i].Hash.String() > commits[j].Hash.String()
})
}
/*
The following tests consider this history having two root commits: V and W
V---o---M----AB----A---CD1--P---C--------S-------------------Q < master
\ \ / / /
\ X GQ1---G < feature /
\ / \ / / /
W---o---N----o----B---CD2---o---D----o----GQ2------------o < dev
MergeBase
----------------------------
passed merge-base
M, N Commits with unrelated history, have no merge-base
A, B AB Regular merge-base between two commits
A, A A The merge-commit between equal commits, is the same
Q, N N The merge-commit between a commit an its ancestor, is the ancestor
C, D CD1, CD2 Cross merges causes more than one merge-base
G, Q GQ1, GQ2 Feature branches including merges, causes more than one merge-base
Independents
----------------------------
candidates result
A A Only one commit returns it
A, A, A A Repeated commits are ignored
A, A, M, M, N A, N M is reachable from A, so it is not independent
S, G, P S, G P is reachable from S, so it is not independent
CD1, CD2, M, N CD1, CD2 M and N are reachable from CD2, so they're not
C, G, dev, M, N C, G, dev M and N are reachable from G, so they're not
C, D, M, N C, D M and N are reachable from C, so they're not
A, A^, A, N, N^ A, N A^ and N^ are reachable from A and N
A^^^, A^, A^^, A, N A, N A^^^, A^^ and A^ are reachable from A, so they're not
IsAncestor
----------------------------
passed result
A^^, A true Will be true if first is ancestor of the second
M, G true True because it will also reach G from M crossing merge commits
A, A true True if first and second are the same
M, N false Commits with unrelated history, will return false
*/
var _ = Suite(&mergeBaseSuite{})
type mergeBaseSuite struct {
BaseObjectsSuite
}
func (s *mergeBaseSuite) SetUpSuite(c *C) {
s.Fixture = fixtures.ByTag("merge-base").One()
s.Storer = filesystem.NewStorage(s.Fixture.DotGit(), cache.NewObjectLRUDefault())
}
var revisionIndex = map[string]plumbing.Hash{
"master": plumbing.NewHash("dce0e0c20d701c3d260146e443d6b3b079505191"),
"feature": plumbing.NewHash("d1b0093698e398d596ef94d646c4db37e8d1e970"),
"dev": plumbing.NewHash("25ca6c810c08482d61113fbcaaada38bb59093a8"),
"M": plumbing.NewHash("bb355b64e18386dbc3af63dfd09c015c44cbd9b6"),
"N": plumbing.NewHash("d64b894762ab5f09e2b155221b90c18bd0637236"),
"A": plumbing.NewHash("29740cfaf0c2ee4bb532dba9e80040ca738f367c"),
"B": plumbing.NewHash("2c84807970299ba98951c65fe81ebbaac01030f0"),
"AB": plumbing.NewHash("31a7e081a28f149ee98ffd13ba1a6d841a5f46fd"),
"P": plumbing.NewHash("ff84393134864cf9d3a9853a81bde81778bd5805"),
"C": plumbing.NewHash("8b72fabdc4222c3ff965bc310ded788c601c50ed"),
"D": plumbing.NewHash("14777cf3e209334592fbfd0b878f6868394db836"),
"CD1": plumbing.NewHash("4709e13a3cbb300c2b8a917effda776e1b8955c7"),
"CD2": plumbing.NewHash("38468e274e91e50ffb637b88a1954ab6193fe974"),
"S": plumbing.NewHash("628f1a42b70380ed05734bf01b468b46206ef1ea"),
"G": plumbing.NewHash("d1b0093698e398d596ef94d646c4db37e8d1e970"),
"Q": plumbing.NewHash("dce0e0c20d701c3d260146e443d6b3b079505191"),
"GQ1": plumbing.NewHash("ccaaa99c21dad7e9f392c36ae8cb72dc63bed458"),
"GQ2": plumbing.NewHash("806824d4778e94fe7c3244e92a9cd07090c9ab54"),
"A^": plumbing.NewHash("31a7e081a28f149ee98ffd13ba1a6d841a5f46fd"),
"A^^": plumbing.NewHash("bb355b64e18386dbc3af63dfd09c015c44cbd9b6"),
"A^^^": plumbing.NewHash("8d08dd1388b82dd354cb43918d83da86c76b0978"),
"N^": plumbing.NewHash("b6e1fc8dad4f1068fb42774ec5fc65c065b2c312"),
}
func (s *mergeBaseSuite) commitsFromRevs(c *C, revs []string) ([]*Commit, error) {
var commits []*Commit
for _, rev := range revs {
hash, ok := revisionIndex[rev]
if !ok {
return nil, fmt.Errorf("Revision not found '%s'", rev)
}
commits = append(commits, s.commit(c, hash))
}
return commits, nil
}
// AssertMergeBase validates that the merge-base of the passed revs,
// matches the expected result
func (s *mergeBaseSuite) AssertMergeBase(c *C, revs, expectedRevs []string) {
c.Assert(revs, HasLen, 2)
commits, err := s.commitsFromRevs(c, revs)
c.Assert(err, IsNil)
results, err := commits[0].MergeBase(commits[1])
c.Assert(err, IsNil)
expected, err := s.commitsFromRevs(c, expectedRevs)
c.Assert(err, IsNil)
c.Assert(results, HasLen, len(expected))
alphabeticSortCommits(results)
alphabeticSortCommits(expected)
for i, commit := range results {
c.Assert(commit.Hash.String(), Equals, expected[i].Hash.String())
}
}
// AssertIndependents validates the independent commits of the passed list
func (s *mergeBaseSuite) AssertIndependents(c *C, revs, expectedRevs []string) {
commits, err := s.commitsFromRevs(c, revs)
c.Assert(err, IsNil)
results, err := Independents(commits)
c.Assert(err, IsNil)
expected, err := s.commitsFromRevs(c, expectedRevs)
c.Assert(err, IsNil)
c.Assert(results, HasLen, len(expected))
alphabeticSortCommits(results)
alphabeticSortCommits(expected)
for i, commit := range results {
c.Assert(commit.Hash.String(), Equals, expected[i].Hash.String())
}
}
// AssertAncestor validates if the first rev is ancestor of the second one
func (s *mergeBaseSuite) AssertAncestor(c *C, revs []string, shouldBeAncestor bool) {
c.Assert(revs, HasLen, 2)
commits, err := s.commitsFromRevs(c, revs)
c.Assert(err, IsNil)
isAncestor, err := commits[0].IsAncestor(commits[1])
c.Assert(err, IsNil)
c.Assert(isAncestor, Equals, shouldBeAncestor)
}
// TestNoAncestorsWhenNoCommonHistory validates that merge-base returns no commits
// when there is no common history (M, N -> none)
func (s *mergeBaseSuite) TestNoAncestorsWhenNoCommonHistory(c *C) {
revs := []string{"M", "N"}
nothing := []string{}
s.AssertMergeBase(c, revs, nothing)
}
// TestCommonAncestorInMergedOrphans validates that merge-base returns a common
// ancestor in orphan branches when they where merged (A, B -> AB)
func (s *mergeBaseSuite) TestCommonAncestorInMergedOrphans(c *C) {
revs := []string{"A", "B"}
expectedRevs := []string{"AB"}
s.AssertMergeBase(c, revs, expectedRevs)
}
// TestMergeBaseWithSelf validates that merge-base between equal commits, returns
// the same commit (A, A -> A)
func (s *mergeBaseSuite) TestMergeBaseWithSelf(c *C) {
revs := []string{"A", "A"}
expectedRevs := []string{"A"}
s.AssertMergeBase(c, revs, expectedRevs)
}
// TestMergeBaseWithAncestor validates that merge-base between a commit an its
// ancestor returns the ancestor (Q, N -> N)
func (s *mergeBaseSuite) TestMergeBaseWithAncestor(c *C) {
revs := []string{"Q", "N"}
expectedRevs := []string{"N"}
s.AssertMergeBase(c, revs, expectedRevs)
}
// TestDoubleCommonAncestorInCrossMerge validates that merge-base returns two
// common ancestors when there are cross merges (C, D -> CD1, CD2)
func (s *mergeBaseSuite) TestDoubleCommonAncestorInCrossMerge(c *C) {
revs := []string{"C", "D"}
expectedRevs := []string{"CD1", "CD2"}
s.AssertMergeBase(c, revs, expectedRevs)
}
// TestDoubleCommonInSubFeatureBranches validates that merge-base returns two
// common ancestors when two branches where partially merged (G, Q -> GQ1, GQ2)
func (s *mergeBaseSuite) TestDoubleCommonInSubFeatureBranches(c *C) {
revs := []string{"G", "Q"}
expectedRevs := []string{"GQ1", "GQ2"}
s.AssertMergeBase(c, revs, expectedRevs)
}
// TestIndependentOnlyOne validates that Independents for one commit returns
// that same commit (A -> A)
func (s *mergeBaseSuite) TestIndependentOnlyOne(c *C) {
revs := []string{"A"}
expectedRevs := []string{"A"}
s.AssertIndependents(c, revs, expectedRevs)
}
// TestIndependentOnlyRepeated validates that Independents for one repeated commit
// returns that same commit (A, A, A -> A)
func (s *mergeBaseSuite) TestIndependentOnlyRepeated(c *C) {
revs := []string{"A", "A", "A"}
expectedRevs := []string{"A"}
s.AssertIndependents(c, revs, expectedRevs)
}
// TestIndependentWithRepeatedAncestors validates that Independents works well
// when there are repeated ancestors (A, A, M, M, N -> A, N)
func (s *mergeBaseSuite) TestIndependentWithRepeatedAncestors(c *C) {
revs := []string{"A", "A", "M", "M", "N"}
expectedRevs := []string{"A", "N"}
s.AssertIndependents(c, revs, expectedRevs)
}
// TestIndependentBeyondShortcut validates that Independents does not stop walking
// in all paths when one of them is known (S, G, P -> S, G)
func (s *mergeBaseSuite) TestIndependentBeyondShortcut(c *C) {
revs := []string{"S", "G", "P"}
expectedRevs := []string{"S", "G"}
s.AssertIndependents(c, revs, expectedRevs)
}
// TestIndependentBeyondShortcutBis validates that Independents does not stop walking
// in all paths when one of them is known (CD1, CD2, M, N -> CD1, CD2)
func (s *mergeBaseSuite) TestIndependentBeyondShortcutBis(c *C) {
revs := []string{"CD1", "CD2", "M", "N"}
expectedRevs := []string{"CD1", "CD2"}
s.AssertIndependents(c, revs, expectedRevs)
}
// TestIndependentWithPairOfAncestors validates that Independents excluded all
// the ancestors (C, D, M, N -> C, D)
func (s *mergeBaseSuite) TestIndependentWithPairOfAncestors(c *C) {
revs := []string{"C", "D", "M", "N"}
expectedRevs := []string{"C", "D"}
s.AssertIndependents(c, revs, expectedRevs)
}
// TestIndependentAcrossCrossMerges validates that Independents works well
// along cross merges (C, G, dev, M -> C, G, dev)
func (s *mergeBaseSuite) TestIndependentAcrossCrossMerges(c *C) {
revs := []string{"C", "G", "dev", "M", "N"}
expectedRevs := []string{"C", "G", "dev"}
s.AssertIndependents(c, revs, expectedRevs)
}
// TestIndependentChangingOrderRepetition validates that Independents works well
// when the order and repetition is tricky (A, A^, A, N, N^ -> A, N)
func (s *mergeBaseSuite) TestIndependentChangingOrderRepetition(c *C) {
revs := []string{"A", "A^", "A", "N", "N^"}
expectedRevs := []string{"A", "N"}
s.AssertIndependents(c, revs, expectedRevs)
}
// TestIndependentChangingOrder validates that Independents works well
// when the order is tricky (A^^^, A^, A^^, A, N -> A, N)
func (s *mergeBaseSuite) TestIndependentChangingOrder(c *C) {
revs := []string{"A^^^", "A^", "A^^", "A", "N"}
expectedRevs := []string{"A", "N"}
s.AssertIndependents(c, revs, expectedRevs)
}
// TestAncestor validates that IsAncestor returns true if walking from first
// commit, through its parents, it can be reached the second ( A^^, A -> true )
func (s *mergeBaseSuite) TestAncestor(c *C) {
revs := []string{"A^^", "A"}
s.AssertAncestor(c, revs, true)
revs = []string{"A", "A^^"}
s.AssertAncestor(c, revs, false)
}
// TestAncestorBeyondMerges validates that IsAncestor returns true also if first can be
// be reached from first one even crossing merge commits in between ( M, G -> true )
func (s *mergeBaseSuite) TestAncestorBeyondMerges(c *C) {
revs := []string{"M", "G"}
s.AssertAncestor(c, revs, true)
revs = []string{"G", "M"}
s.AssertAncestor(c, revs, false)
}
// TestAncestorSame validates that IsAncestor returns both are the same ( A, A -> true )
func (s *mergeBaseSuite) TestAncestorSame(c *C) {
revs := []string{"A", "A"}
s.AssertAncestor(c, revs, true)
}
// TestAncestorUnrelated validates that IsAncestor returns false when the passed commits
// does not share any history, no matter the order used ( M, N -> false )
func (s *mergeBaseSuite) TestAncestorUnrelated(c *C) {
revs := []string{"M", "N"}
s.AssertAncestor(c, revs, false)
revs = []string{"N", "M"}
s.AssertAncestor(c, revs, false)
}
go-git-5.13.2/plumbing/object/object.go 0000664 0000000 0000000 00000013610 14744245500 0017656 0 ustar 00root root 0000000 0000000 // Package object contains implementations of all Git objects and utility
// functions to work with them.
package object
import (
"bytes"
"errors"
"fmt"
"io"
"strconv"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
)
// ErrUnsupportedObject trigger when a non-supported object is being decoded.
var ErrUnsupportedObject = errors.New("unsupported object type")
// Object is a generic representation of any git object. It is implemented by
// Commit, Tree, Blob, and Tag, and includes the functions that are common to
// them.
//
// Object is returned when an object can be of any type. It is frequently used
// with a type cast to acquire the specific type of object:
//
// func process(obj Object) {
// switch o := obj.(type) {
// case *Commit:
// // o is a Commit
// case *Tree:
// // o is a Tree
// case *Blob:
// // o is a Blob
// case *Tag:
// // o is a Tag
// }
// }
//
// This interface is intentionally different from plumbing.EncodedObject, which
// is a lower level interface used by storage implementations to read and write
// objects in its encoded form.
type Object interface {
ID() plumbing.Hash
Type() plumbing.ObjectType
Decode(plumbing.EncodedObject) error
Encode(plumbing.EncodedObject) error
}
// GetObject gets an object from an object storer and decodes it.
func GetObject(s storer.EncodedObjectStorer, h plumbing.Hash) (Object, error) {
o, err := s.EncodedObject(plumbing.AnyObject, h)
if err != nil {
return nil, err
}
return DecodeObject(s, o)
}
// DecodeObject decodes an encoded object into an Object and associates it to
// the given object storer.
func DecodeObject(s storer.EncodedObjectStorer, o plumbing.EncodedObject) (Object, error) {
switch o.Type() {
case plumbing.CommitObject:
return DecodeCommit(s, o)
case plumbing.TreeObject:
return DecodeTree(s, o)
case plumbing.BlobObject:
return DecodeBlob(o)
case plumbing.TagObject:
return DecodeTag(s, o)
default:
return nil, plumbing.ErrInvalidType
}
}
// DateFormat is the format being used in the original git implementation
const DateFormat = "Mon Jan 02 15:04:05 2006 -0700"
// Signature is used to identify who and when created a commit or tag.
type Signature struct {
// Name represents a person name. It is an arbitrary string.
Name string
// Email is an email, but it cannot be assumed to be well-formed.
Email string
// When is the timestamp of the signature.
When time.Time
}
// Decode decodes a byte slice into a signature
func (s *Signature) Decode(b []byte) {
open := bytes.LastIndexByte(b, '<')
close := bytes.LastIndexByte(b, '>')
if open == -1 || close == -1 {
return
}
if close < open {
return
}
s.Name = string(bytes.Trim(b[:open], " "))
s.Email = string(b[open+1 : close])
hasTime := close+2 < len(b)
if hasTime {
s.decodeTimeAndTimeZone(b[close+2:])
}
}
// Encode encodes a Signature into a writer.
func (s *Signature) Encode(w io.Writer) error {
if _, err := fmt.Fprintf(w, "%s <%s> ", s.Name, s.Email); err != nil {
return err
}
if err := s.encodeTimeAndTimeZone(w); err != nil {
return err
}
return nil
}
var timeZoneLength = 5
func (s *Signature) decodeTimeAndTimeZone(b []byte) {
space := bytes.IndexByte(b, ' ')
if space == -1 {
space = len(b)
}
ts, err := strconv.ParseInt(string(b[:space]), 10, 64)
if err != nil {
return
}
s.When = time.Unix(ts, 0).In(time.UTC)
var tzStart = space + 1
if tzStart >= len(b) || tzStart+timeZoneLength > len(b) {
return
}
timezone := string(b[tzStart : tzStart+timeZoneLength])
tzhours, err1 := strconv.ParseInt(timezone[0:3], 10, 64)
tzmins, err2 := strconv.ParseInt(timezone[3:], 10, 64)
if err1 != nil || err2 != nil {
return
}
if tzhours < 0 {
tzmins *= -1
}
tz := time.FixedZone("", int(tzhours*60*60+tzmins*60))
s.When = s.When.In(tz)
}
func (s *Signature) encodeTimeAndTimeZone(w io.Writer) error {
u := s.When.Unix()
if u < 0 {
u = 0
}
_, err := fmt.Fprintf(w, "%d %s", u, s.When.Format("-0700"))
return err
}
func (s *Signature) String() string {
return fmt.Sprintf("%s <%s>", s.Name, s.Email)
}
// ObjectIter provides an iterator for a set of objects.
type ObjectIter struct {
storer.EncodedObjectIter
s storer.EncodedObjectStorer
}
// NewObjectIter takes a storer.EncodedObjectStorer and a
// storer.EncodedObjectIter and returns an *ObjectIter that iterates over all
// objects contained in the storer.EncodedObjectIter.
func NewObjectIter(s storer.EncodedObjectStorer, iter storer.EncodedObjectIter) *ObjectIter {
return &ObjectIter{iter, s}
}
// Next moves the iterator to the next object and returns a pointer to it. If
// there are no more objects, it returns io.EOF.
func (iter *ObjectIter) Next() (Object, error) {
for {
obj, err := iter.EncodedObjectIter.Next()
if err != nil {
return nil, err
}
o, err := iter.toObject(obj)
if err == plumbing.ErrInvalidType {
continue
}
if err != nil {
return nil, err
}
return o, nil
}
}
// ForEach call the cb function for each object contained on this iter until
// an error happens or the end of the iter is reached. If ErrStop is sent
// the iteration is stop but no error is returned. The iterator is closed.
func (iter *ObjectIter) ForEach(cb func(Object) error) error {
return iter.EncodedObjectIter.ForEach(func(obj plumbing.EncodedObject) error {
o, err := iter.toObject(obj)
if err == plumbing.ErrInvalidType {
return nil
}
if err != nil {
return err
}
return cb(o)
})
}
func (iter *ObjectIter) toObject(obj plumbing.EncodedObject) (Object, error) {
switch obj.Type() {
case plumbing.BlobObject:
blob := &Blob{}
return blob, blob.Decode(obj)
case plumbing.TreeObject:
tree := &Tree{s: iter.s}
return tree, tree.Decode(obj)
case plumbing.CommitObject:
commit := &Commit{}
return commit, commit.Decode(obj)
case plumbing.TagObject:
tag := &Tag{}
return tag, tag.Decode(obj)
default:
return nil, plumbing.ErrInvalidType
}
}
go-git-5.13.2/plumbing/object/object_test.go 0000664 0000000 0000000 00000012223 14744245500 0020714 0 ustar 00root root 0000000 0000000 package object
import (
"io"
"testing"
"time"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/filesystem"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type BaseObjectsSuite struct {
fixtures.Suite
Storer storer.EncodedObjectStorer
Fixture *fixtures.Fixture
}
func (s *BaseObjectsSuite) SetUpSuite(c *C) {
s.Fixture = fixtures.Basic().One()
storer := filesystem.NewStorage(s.Fixture.DotGit(), cache.NewObjectLRUDefault())
s.Storer = storer
}
func (s *BaseObjectsSuite) tag(c *C, h plumbing.Hash) *Tag {
t, err := GetTag(s.Storer, h)
c.Assert(err, IsNil)
return t
}
func (s *BaseObjectsSuite) tree(c *C, h plumbing.Hash) *Tree {
t, err := GetTree(s.Storer, h)
c.Assert(err, IsNil)
return t
}
func (s *BaseObjectsSuite) commit(c *C, h plumbing.Hash) *Commit {
commit, err := GetCommit(s.Storer, h)
c.Assert(err, IsNil)
return commit
}
type ObjectsSuite struct {
BaseObjectsSuite
}
var _ = Suite(&ObjectsSuite{})
func (s *ObjectsSuite) TestNewCommit(c *C) {
hash := plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69")
commit := s.commit(c, hash)
c.Assert(commit.Hash, Equals, commit.ID())
c.Assert(commit.Hash.String(), Equals, "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69")
tree, err := commit.Tree()
c.Assert(err, IsNil)
c.Assert(tree.Hash.String(), Equals, "c2d30fa8ef288618f65f6eed6e168e0d514886f4")
parents := commit.Parents()
parentCommit, err := parents.Next()
c.Assert(err, IsNil)
c.Assert(parentCommit.Hash.String(), Equals, "b029517f6300c2da0f4b651b8642506cd6aaf45d")
parentCommit, err = parents.Next()
c.Assert(err, IsNil)
c.Assert(parentCommit.Hash.String(), Equals, "b8e471f58bcbca63b07bda20e428190409c2db47")
c.Assert(commit.Author.Email, Equals, "mcuadros@gmail.com")
c.Assert(commit.Author.Name, Equals, "Máximo Cuadros")
c.Assert(commit.Author.When.Format(time.RFC3339), Equals, "2015-03-31T13:47:14+02:00")
c.Assert(commit.Committer.Email, Equals, "mcuadros@gmail.com")
c.Assert(commit.Message, Equals, "Merge pull request #1 from dripolles/feature\n\nCreating changelog")
}
func (s *ObjectsSuite) TestParseTree(c *C) {
hash := plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")
tree, err := GetTree(s.Storer, hash)
c.Assert(err, IsNil)
c.Assert(tree.Entries, HasLen, 8)
tree.buildMap()
c.Assert(tree.m, HasLen, 8)
c.Assert(tree.m[".gitignore"].Name, Equals, ".gitignore")
c.Assert(tree.m[".gitignore"].Mode, Equals, filemode.Regular)
c.Assert(tree.m[".gitignore"].Hash.String(), Equals, "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88")
count := 0
iter := tree.Files()
defer iter.Close()
for f, err := iter.Next(); err == nil; f, err = iter.Next() {
count++
if f.Name == "go/example.go" {
reader, err := f.Reader()
c.Assert(err, IsNil)
defer func() { c.Assert(reader.Close(), IsNil) }()
content, _ := io.ReadAll(reader)
c.Assert(content, HasLen, 2780)
}
}
c.Assert(count, Equals, 9)
}
func (s *ObjectsSuite) TestParseSignature(c *C) {
cases := map[string]Signature{
`Foo Bar 1257894000 +0100`: {
Name: "Foo Bar",
Email: "foo@bar.com",
When: MustParseTime("2009-11-11 00:00:00 +0100"),
},
`Foo Bar 1257894000 -0700`: {
Name: "Foo Bar",
Email: "foo@bar.com",
When: MustParseTime("2009-11-10 16:00:00 -0700"),
},
`Foo Bar <> 1257894000 +0100`: {
Name: "Foo Bar",
Email: "",
When: MustParseTime("2009-11-11 00:00:00 +0100"),
},
` <> 1257894000`: {
Name: "",
Email: "",
When: MustParseTime("2009-11-10 23:00:00 +0000"),
},
`Foo Bar `: {
Name: "Foo Bar",
Email: "foo@bar.com",
When: time.Time{},
},
`crap> 1257894000 +1000`: {
Name: "crap>",
Email: "foo@bar.com",
When: MustParseTime("2009-11-11 09:00:00 +1000"),
},
`><`: {
Name: "",
Email: "",
When: time.Time{},
},
``: {
Name: "",
Email: "",
When: time.Time{},
},
`<`: {
Name: "",
Email: "",
When: time.Time{},
},
}
for raw, exp := range cases {
got := &Signature{}
got.Decode([]byte(raw))
c.Assert(got.Name, Equals, exp.Name)
c.Assert(got.Email, Equals, exp.Email)
c.Assert(got.When.Format(time.RFC3339), Equals, exp.When.Format(time.RFC3339))
}
}
func (s *ObjectsSuite) TestObjectIter(c *C) {
encIter, err := s.Storer.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
iter := NewObjectIter(s.Storer, encIter)
objects := []Object{}
iter.ForEach(func(o Object) error {
objects = append(objects, o)
return nil
})
c.Assert(len(objects) > 0, Equals, true)
iter.Close()
encIter, err = s.Storer.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
iter = NewObjectIter(s.Storer, encIter)
i := 0
for {
o, err := iter.Next()
if err == io.EOF {
break
}
c.Assert(err, IsNil)
c.Assert(o.ID(), Equals, objects[i].ID())
c.Assert(o.Type(), Equals, objects[i].Type())
i++
}
iter.Close()
}
func MustParseTime(value string) time.Time {
t, _ := time.Parse("2006-01-02 15:04:05 -0700", value)
return t
}
go-git-5.13.2/plumbing/object/patch.go 0000664 0000000 0000000 00000015235 14744245500 0017514 0 ustar 00root root 0000000 0000000 package object
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"strconv"
"strings"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
fdiff "github.com/go-git/go-git/v5/plumbing/format/diff"
"github.com/go-git/go-git/v5/utils/diff"
dmp "github.com/sergi/go-diff/diffmatchpatch"
)
var (
ErrCanceled = errors.New("operation canceled")
)
func getPatch(message string, changes ...*Change) (*Patch, error) {
ctx := context.Background()
return getPatchContext(ctx, message, changes...)
}
func getPatchContext(ctx context.Context, message string, changes ...*Change) (*Patch, error) {
var filePatches []fdiff.FilePatch
for _, c := range changes {
select {
case <-ctx.Done():
return nil, ErrCanceled
default:
}
fp, err := filePatchWithContext(ctx, c)
if err != nil {
return nil, err
}
filePatches = append(filePatches, fp)
}
return &Patch{message, filePatches}, nil
}
func filePatchWithContext(ctx context.Context, c *Change) (fdiff.FilePatch, error) {
from, to, err := c.Files()
if err != nil {
return nil, err
}
fromContent, fIsBinary, err := fileContent(from)
if err != nil {
return nil, err
}
toContent, tIsBinary, err := fileContent(to)
if err != nil {
return nil, err
}
if fIsBinary || tIsBinary {
return &textFilePatch{from: c.From, to: c.To}, nil
}
diffs := diff.Do(fromContent, toContent)
var chunks []fdiff.Chunk
for _, d := range diffs {
select {
case <-ctx.Done():
return nil, ErrCanceled
default:
}
var op fdiff.Operation
switch d.Type {
case dmp.DiffEqual:
op = fdiff.Equal
case dmp.DiffDelete:
op = fdiff.Delete
case dmp.DiffInsert:
op = fdiff.Add
}
chunks = append(chunks, &textChunk{d.Text, op})
}
return &textFilePatch{
chunks: chunks,
from: c.From,
to: c.To,
}, nil
}
func fileContent(f *File) (content string, isBinary bool, err error) {
if f == nil {
return
}
isBinary, err = f.IsBinary()
if err != nil || isBinary {
return
}
content, err = f.Contents()
return
}
// Patch is an implementation of fdiff.Patch interface
type Patch struct {
message string
filePatches []fdiff.FilePatch
}
func (p *Patch) FilePatches() []fdiff.FilePatch {
return p.filePatches
}
func (p *Patch) Message() string {
return p.message
}
func (p *Patch) Encode(w io.Writer) error {
ue := fdiff.NewUnifiedEncoder(w, fdiff.DefaultContextLines)
return ue.Encode(p)
}
func (p *Patch) Stats() FileStats {
return getFileStatsFromFilePatches(p.FilePatches())
}
func (p *Patch) String() string {
buf := bytes.NewBuffer(nil)
err := p.Encode(buf)
if err != nil {
return fmt.Sprintf("malformed patch: %s", err.Error())
}
return buf.String()
}
// changeEntryWrapper is an implementation of fdiff.File interface
type changeEntryWrapper struct {
ce ChangeEntry
}
func (f *changeEntryWrapper) Hash() plumbing.Hash {
if !f.ce.TreeEntry.Mode.IsFile() {
return plumbing.ZeroHash
}
return f.ce.TreeEntry.Hash
}
func (f *changeEntryWrapper) Mode() filemode.FileMode {
return f.ce.TreeEntry.Mode
}
func (f *changeEntryWrapper) Path() string {
if !f.ce.TreeEntry.Mode.IsFile() {
return ""
}
return f.ce.Name
}
func (f *changeEntryWrapper) Empty() bool {
return !f.ce.TreeEntry.Mode.IsFile()
}
// textFilePatch is an implementation of fdiff.FilePatch interface
type textFilePatch struct {
chunks []fdiff.Chunk
from, to ChangeEntry
}
func (tf *textFilePatch) Files() (from fdiff.File, to fdiff.File) {
f := &changeEntryWrapper{tf.from}
t := &changeEntryWrapper{tf.to}
if !f.Empty() {
from = f
}
if !t.Empty() {
to = t
}
return
}
func (tf *textFilePatch) IsBinary() bool {
return len(tf.chunks) == 0
}
func (tf *textFilePatch) Chunks() []fdiff.Chunk {
return tf.chunks
}
// textChunk is an implementation of fdiff.Chunk interface
type textChunk struct {
content string
op fdiff.Operation
}
func (t *textChunk) Content() string {
return t.content
}
func (t *textChunk) Type() fdiff.Operation {
return t.op
}
// FileStat stores the status of changes in content of a file.
type FileStat struct {
Name string
Addition int
Deletion int
}
func (fs FileStat) String() string {
return printStat([]FileStat{fs})
}
// FileStats is a collection of FileStat.
type FileStats []FileStat
func (fileStats FileStats) String() string {
return printStat(fileStats)
}
// printStat prints the stats of changes in content of files.
// Original implementation: https://github.com/git/git/blob/1a87c842ece327d03d08096395969aca5e0a6996/diff.c#L2615
// Parts of the output:
// |<+++/--->
// example: " main.go | 10 +++++++--- "
func printStat(fileStats []FileStat) string {
maxGraphWidth := uint(53)
maxNameLen := 0
maxChangeLen := 0
scaleLinear := func(it, width, max uint) uint {
if it == 0 || max == 0 {
return 0
}
return 1 + (it * (width - 1) / max)
}
for _, fs := range fileStats {
if len(fs.Name) > maxNameLen {
maxNameLen = len(fs.Name)
}
changes := strconv.Itoa(fs.Addition + fs.Deletion)
if len(changes) > maxChangeLen {
maxChangeLen = len(changes)
}
}
result := ""
for _, fs := range fileStats {
add := uint(fs.Addition)
del := uint(fs.Deletion)
np := maxNameLen - len(fs.Name)
cp := maxChangeLen - len(strconv.Itoa(fs.Addition+fs.Deletion))
total := add + del
if total > maxGraphWidth {
add = scaleLinear(add, maxGraphWidth, total)
del = scaleLinear(del, maxGraphWidth, total)
}
adds := strings.Repeat("+", int(add))
dels := strings.Repeat("-", int(del))
namePad := strings.Repeat(" ", np)
changePad := strings.Repeat(" ", cp)
result += fmt.Sprintf(" %s%s | %s%d %s%s\n", fs.Name, namePad, changePad, total, adds, dels)
}
return result
}
func getFileStatsFromFilePatches(filePatches []fdiff.FilePatch) FileStats {
var fileStats FileStats
for _, fp := range filePatches {
// ignore empty patches (binary files, submodule refs updates)
if len(fp.Chunks()) == 0 {
continue
}
cs := FileStat{}
from, to := fp.Files()
if from == nil {
// New File is created.
cs.Name = to.Path()
} else if to == nil {
// File is deleted.
cs.Name = from.Path()
} else if from.Path() != to.Path() {
// File is renamed.
cs.Name = fmt.Sprintf("%s => %s", from.Path(), to.Path())
} else {
cs.Name = from.Path()
}
for _, chunk := range fp.Chunks() {
s := chunk.Content()
if len(s) == 0 {
continue
}
switch chunk.Type() {
case fdiff.Add:
cs.Addition += strings.Count(s, "\n")
if s[len(s)-1] != '\n' {
cs.Addition++
}
case fdiff.Delete:
cs.Deletion += strings.Count(s, "\n")
if s[len(s)-1] != '\n' {
cs.Deletion++
}
}
}
fileStats = append(fileStats, cs)
}
return fileStats
}
go-git-5.13.2/plumbing/object/patch_stats_test.go 0000664 0000000 0000000 00000002206 14744245500 0021763 0 ustar 00root root 0000000 0000000 package object_test
import (
"time"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-billy/v5/util"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/storage/memory"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type PatchStatsSuite struct {
fixtures.Suite
}
var _ = Suite(&PatchStatsSuite{})
func (s *PatchStatsSuite) TestStatsWithRename(c *C) {
cm := &git.CommitOptions{
Author: &object.Signature{Name: "Foo", Email: "foo@example.local", When: time.Now()},
}
fs := memfs.New()
r, err := git.Init(memory.NewStorage(), fs)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
util.WriteFile(fs, "foo", []byte("foo\nbar\n"), 0644)
_, err = w.Add("foo")
c.Assert(err, IsNil)
_, err = w.Commit("foo\n", cm)
c.Assert(err, IsNil)
_, err = w.Move("foo", "bar")
c.Assert(err, IsNil)
hash, err := w.Commit("rename foo to bar", cm)
c.Assert(err, IsNil)
commit, err := r.CommitObject(hash)
c.Assert(err, IsNil)
fileStats, err := commit.Stats()
c.Assert(err, IsNil)
c.Assert(fileStats[0].Name, Equals, "foo => bar")
}
go-git-5.13.2/plumbing/object/patch_test.go 0000664 0000000 0000000 00000006606 14744245500 0020555 0 ustar 00root root 0000000 0000000 package object
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/storage/filesystem"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type PatchSuite struct {
BaseObjectsSuite
}
var _ = Suite(&PatchSuite{})
func (s *PatchSuite) TestStatsWithSubmodules(c *C) {
storer := filesystem.NewStorage(
fixtures.ByURL("https://github.com/git-fixtures/submodule.git").One().DotGit(), cache.NewObjectLRUDefault())
commit, err := GetCommit(storer, plumbing.NewHash("b685400c1f9316f350965a5993d350bc746b0bf4"))
c.Assert(err, IsNil)
tree, err := commit.Tree()
c.Assert(err, IsNil)
e, err := tree.entry("basic")
c.Assert(err, IsNil)
ch := &Change{
From: ChangeEntry{
Name: "basic",
Tree: tree,
TreeEntry: *e,
},
To: ChangeEntry{
Name: "basic",
Tree: tree,
TreeEntry: *e,
},
}
p, err := getPatch("", ch)
c.Assert(err, IsNil)
c.Assert(p, NotNil)
}
func (s *PatchSuite) TestFileStatsString(c *C) {
testCases := []struct {
description string
input FileStats
expected string
}{
{
description: "no files changed",
input: []FileStat{},
expected: "",
},
{
description: "one file touched - no changes",
input: []FileStat{
{
Name: "file1",
},
},
expected: " file1 | 0 \n",
},
{
description: "one file changed",
input: []FileStat{
{
Name: "file1",
Addition: 1,
},
},
expected: " file1 | 1 +\n",
},
{
description: "one file changed with one addition and one deletion",
input: []FileStat{
{
Name: ".github/workflows/git.yml",
Addition: 1,
Deletion: 1,
},
},
expected: " .github/workflows/git.yml | 2 +-\n",
},
{
description: "two files changed",
input: []FileStat{
{
Name: ".github/workflows/git.yml",
Addition: 1,
Deletion: 1,
},
{
Name: "cli/go-git/go.mod",
Addition: 4,
Deletion: 4,
},
},
expected: " .github/workflows/git.yml | 2 +-\n cli/go-git/go.mod | 8 ++++----\n",
},
{
description: "three files changed",
input: []FileStat{
{
Name: ".github/workflows/git.yml",
Addition: 3,
Deletion: 3,
},
{
Name: "worktree.go",
Addition: 107,
},
{
Name: "worktree_test.go",
Addition: 75,
},
},
expected: " .github/workflows/git.yml | 6 +++---\n" +
" worktree.go | 107 +++++++++++++++++++++++++++++++++++++++++++++++++++++\n" +
" worktree_test.go | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++++\n",
},
{
description: "three files changed with deletions and additions",
input: []FileStat{
{
Name: ".github/workflows/git.yml",
Addition: 3,
Deletion: 3,
},
{
Name: "worktree.go",
Addition: 107,
Deletion: 217,
},
{
Name: "worktree_test.go",
Addition: 75,
Deletion: 275,
},
},
expected: " .github/workflows/git.yml | 6 +++---\n" +
" worktree.go | 324 ++++++++++++++++++-----------------------------------\n" +
" worktree_test.go | 350 ++++++++++++-----------------------------------------\n",
},
}
for _, tc := range testCases {
c.Log("Executing test cases:", tc.description)
c.Assert(printStat(tc.input), Equals, tc.expected)
}
}
go-git-5.13.2/plumbing/object/rename.go 0000664 0000000 0000000 00000045073 14744245500 0017667 0 ustar 00root root 0000000 0000000 package object
import (
"errors"
"io"
"sort"
"strings"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-git/v5/utils/merkletrie"
)
// DetectRenames detects the renames in the given changes on two trees with
// the given options. It will return the given changes grouping additions and
// deletions into modifications when possible.
// If options is nil, the default diff tree options will be used.
func DetectRenames(
changes Changes,
opts *DiffTreeOptions,
) (Changes, error) {
if opts == nil {
opts = DefaultDiffTreeOptions
}
detector := &renameDetector{
renameScore: int(opts.RenameScore),
renameLimit: int(opts.RenameLimit),
onlyExact: opts.OnlyExactRenames,
}
for _, c := range changes {
action, err := c.Action()
if err != nil {
return nil, err
}
switch action {
case merkletrie.Insert:
detector.added = append(detector.added, c)
case merkletrie.Delete:
detector.deleted = append(detector.deleted, c)
default:
detector.modified = append(detector.modified, c)
}
}
return detector.detect()
}
// renameDetector will detect and resolve renames in a set of changes.
// see: https://github.com/eclipse/jgit/blob/master/org.eclipse.jgit/src/org/eclipse/jgit/diff/RenameDetector.java
type renameDetector struct {
added []*Change
deleted []*Change
modified []*Change
renameScore int
renameLimit int
onlyExact bool
}
// detectExactRenames detects matches files that were deleted with files that
// were added where the hash is the same on both. If there are multiple targets
// the one with the most similar path will be chosen as the rename and the
// rest as either deletions or additions.
func (d *renameDetector) detectExactRenames() {
added := groupChangesByHash(d.added)
deletes := groupChangesByHash(d.deleted)
var uniqueAdds []*Change
var nonUniqueAdds [][]*Change
var addedLeft []*Change
for _, cs := range added {
if len(cs) == 1 {
uniqueAdds = append(uniqueAdds, cs[0])
} else {
nonUniqueAdds = append(nonUniqueAdds, cs)
}
}
for _, c := range uniqueAdds {
hash := changeHash(c)
deleted := deletes[hash]
if len(deleted) == 1 {
if sameMode(c, deleted[0]) {
d.modified = append(d.modified, &Change{From: deleted[0].From, To: c.To})
delete(deletes, hash)
} else {
addedLeft = append(addedLeft, c)
}
} else if len(deleted) > 1 {
bestMatch := bestNameMatch(c, deleted)
if bestMatch != nil && sameMode(c, bestMatch) {
d.modified = append(d.modified, &Change{From: bestMatch.From, To: c.To})
delete(deletes, hash)
var newDeletes = make([]*Change, 0, len(deleted)-1)
for _, d := range deleted {
if d != bestMatch {
newDeletes = append(newDeletes, d)
}
}
deletes[hash] = newDeletes
}
} else {
addedLeft = append(addedLeft, c)
}
}
for _, added := range nonUniqueAdds {
hash := changeHash(added[0])
deleted := deletes[hash]
if len(deleted) == 1 {
deleted := deleted[0]
bestMatch := bestNameMatch(deleted, added)
if bestMatch != nil && sameMode(deleted, bestMatch) {
d.modified = append(d.modified, &Change{From: deleted.From, To: bestMatch.To})
delete(deletes, hash)
for _, c := range added {
if c != bestMatch {
addedLeft = append(addedLeft, c)
}
}
} else {
addedLeft = append(addedLeft, added...)
}
} else if len(deleted) > 1 {
maxSize := len(deleted) * len(added)
if d.renameLimit > 0 && d.renameLimit < maxSize {
maxSize = d.renameLimit
}
matrix := make(similarityMatrix, 0, maxSize)
for delIdx, del := range deleted {
deletedName := changeName(del)
for addIdx, add := range added {
addedName := changeName(add)
score := nameSimilarityScore(addedName, deletedName)
matrix = append(matrix, similarityPair{added: addIdx, deleted: delIdx, score: score})
if len(matrix) >= maxSize {
break
}
}
if len(matrix) >= maxSize {
break
}
}
sort.Stable(matrix)
usedAdds := make(map[*Change]struct{})
usedDeletes := make(map[*Change]struct{})
for i := len(matrix) - 1; i >= 0; i-- {
del := deleted[matrix[i].deleted]
add := added[matrix[i].added]
if add == nil || del == nil {
// it was already matched
continue
}
usedAdds[add] = struct{}{}
usedDeletes[del] = struct{}{}
d.modified = append(d.modified, &Change{From: del.From, To: add.To})
added[matrix[i].added] = nil
deleted[matrix[i].deleted] = nil
}
for _, c := range added {
if _, ok := usedAdds[c]; !ok && c != nil {
addedLeft = append(addedLeft, c)
}
}
var newDeletes = make([]*Change, 0, len(deleted)-len(usedDeletes))
for _, c := range deleted {
if _, ok := usedDeletes[c]; !ok && c != nil {
newDeletes = append(newDeletes, c)
}
}
deletes[hash] = newDeletes
} else {
addedLeft = append(addedLeft, added...)
}
}
d.added = addedLeft
d.deleted = nil
for _, dels := range deletes {
d.deleted = append(d.deleted, dels...)
}
}
// detectContentRenames detects renames based on the similarity of the content
// in the files by building a matrix of pairs between sources and destinations
// and matching by the highest score.
// see: https://github.com/eclipse/jgit/blob/master/org.eclipse.jgit/src/org/eclipse/jgit/diff/SimilarityRenameDetector.java
func (d *renameDetector) detectContentRenames() error {
cnt := max(len(d.added), len(d.deleted))
if d.renameLimit > 0 && cnt > d.renameLimit {
return nil
}
srcs, dsts := d.deleted, d.added
matrix, err := buildSimilarityMatrix(srcs, dsts, d.renameScore)
if err != nil {
return err
}
renames := make([]*Change, 0, min(len(matrix), len(dsts)))
// Match rename pairs on a first come, first serve basis until
// we have looked at everything that is above the minimum score.
for i := len(matrix) - 1; i >= 0; i-- {
pair := matrix[i]
src := srcs[pair.deleted]
dst := dsts[pair.added]
if dst == nil || src == nil {
// It was already matched before
continue
}
renames = append(renames, &Change{From: src.From, To: dst.To})
// Claim destination and source as matched
dsts[pair.added] = nil
srcs[pair.deleted] = nil
}
d.modified = append(d.modified, renames...)
d.added = compactChanges(dsts)
d.deleted = compactChanges(srcs)
return nil
}
func (d *renameDetector) detect() (Changes, error) {
if len(d.added) > 0 && len(d.deleted) > 0 {
d.detectExactRenames()
if !d.onlyExact {
if err := d.detectContentRenames(); err != nil {
return nil, err
}
}
}
result := make(Changes, 0, len(d.added)+len(d.deleted)+len(d.modified))
result = append(result, d.added...)
result = append(result, d.deleted...)
result = append(result, d.modified...)
sort.Stable(result)
return result, nil
}
func bestNameMatch(change *Change, changes []*Change) *Change {
var best *Change
var bestScore int
cname := changeName(change)
for _, c := range changes {
score := nameSimilarityScore(cname, changeName(c))
if score > bestScore {
bestScore = score
best = c
}
}
return best
}
func nameSimilarityScore(a, b string) int {
aDirLen := strings.LastIndexByte(a, '/') + 1
bDirLen := strings.LastIndexByte(b, '/') + 1
dirMin := min(aDirLen, bDirLen)
dirMax := max(aDirLen, bDirLen)
var dirScoreLtr, dirScoreRtl int
if dirMax == 0 {
dirScoreLtr = 100
dirScoreRtl = 100
} else {
var dirSim int
for ; dirSim < dirMin; dirSim++ {
if a[dirSim] != b[dirSim] {
break
}
}
dirScoreLtr = dirSim * 100 / dirMax
if dirScoreLtr == 100 {
dirScoreRtl = 100
} else {
for dirSim = 0; dirSim < dirMin; dirSim++ {
if a[aDirLen-1-dirSim] != b[bDirLen-1-dirSim] {
break
}
}
dirScoreRtl = dirSim * 100 / dirMax
}
}
fileMin := min(len(a)-aDirLen, len(b)-bDirLen)
fileMax := max(len(a)-aDirLen, len(b)-bDirLen)
fileSim := 0
for ; fileSim < fileMin; fileSim++ {
if a[len(a)-1-fileSim] != b[len(b)-1-fileSim] {
break
}
}
fileScore := fileSim * 100 / fileMax
return (((dirScoreLtr + dirScoreRtl) * 25) + (fileScore * 50)) / 100
}
func changeName(c *Change) string {
if c.To != empty {
return c.To.Name
}
return c.From.Name
}
func changeHash(c *Change) plumbing.Hash {
if c.To != empty {
return c.To.TreeEntry.Hash
}
return c.From.TreeEntry.Hash
}
func changeMode(c *Change) filemode.FileMode {
if c.To != empty {
return c.To.TreeEntry.Mode
}
return c.From.TreeEntry.Mode
}
func sameMode(a, b *Change) bool {
return changeMode(a) == changeMode(b)
}
func groupChangesByHash(changes []*Change) map[plumbing.Hash][]*Change {
var result = make(map[plumbing.Hash][]*Change)
for _, c := range changes {
hash := changeHash(c)
result[hash] = append(result[hash], c)
}
return result
}
type similarityMatrix []similarityPair
func (m similarityMatrix) Len() int { return len(m) }
func (m similarityMatrix) Swap(i, j int) { m[i], m[j] = m[j], m[i] }
func (m similarityMatrix) Less(i, j int) bool {
if m[i].score == m[j].score {
if m[i].added == m[j].added {
return m[i].deleted < m[j].deleted
}
return m[i].added < m[j].added
}
return m[i].score < m[j].score
}
type similarityPair struct {
// index of the added file
added int
// index of the deleted file
deleted int
// similarity score
score int
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
func min(a, b int) int {
if a < b {
return a
}
return b
}
const maxMatrixSize = 10000
func buildSimilarityMatrix(srcs, dsts []*Change, renameScore int) (similarityMatrix, error) {
// Allocate for the worst-case scenario where every pair has a score
// that we need to consider. We might not need that many.
matrixSize := len(srcs) * len(dsts)
if matrixSize > maxMatrixSize {
matrixSize = maxMatrixSize
}
matrix := make(similarityMatrix, 0, matrixSize)
srcSizes := make([]int64, len(srcs))
dstSizes := make([]int64, len(dsts))
dstTooLarge := make(map[int]bool)
// Consider each pair of files, if the score is above the minimum
// threshold we need to record that scoring in the matrix so we can
// later find the best matches.
outerLoop:
for srcIdx, src := range srcs {
if changeMode(src) != filemode.Regular {
continue
}
// Declare the from file and the similarity index here to be able to
// reuse it inside the inner loop. The reason to not initialize them
// here is so we can skip the initialization in case they happen to
// not be needed later. They will be initialized inside the inner
// loop if and only if they're needed and reused in subsequent passes.
var from *File
var s *similarityIndex
var err error
for dstIdx, dst := range dsts {
if changeMode(dst) != filemode.Regular {
continue
}
if dstTooLarge[dstIdx] {
continue
}
var to *File
srcSize := srcSizes[srcIdx]
if srcSize == 0 {
from, _, err = src.Files()
if err != nil {
return nil, err
}
srcSize = from.Size + 1
srcSizes[srcIdx] = srcSize
}
dstSize := dstSizes[dstIdx]
if dstSize == 0 {
_, to, err = dst.Files()
if err != nil {
return nil, err
}
dstSize = to.Size + 1
dstSizes[dstIdx] = dstSize
}
min, max := srcSize, dstSize
if dstSize < srcSize {
min = dstSize
max = srcSize
}
if int(min*100/max) < renameScore {
// File sizes are too different to be a match
continue
}
if s == nil {
s, err = fileSimilarityIndex(from)
if err != nil {
if err == errIndexFull {
continue outerLoop
}
return nil, err
}
}
if to == nil {
_, to, err = dst.Files()
if err != nil {
return nil, err
}
}
di, err := fileSimilarityIndex(to)
if err != nil {
if err == errIndexFull {
dstTooLarge[dstIdx] = true
}
return nil, err
}
contentScore := s.score(di, 10000)
// The name score returns a value between 0 and 100, so we need to
// convert it to the same range as the content score.
nameScore := nameSimilarityScore(src.From.Name, dst.To.Name) * 100
score := (contentScore*99 + nameScore*1) / 10000
if score < renameScore {
continue
}
matrix = append(matrix, similarityPair{added: dstIdx, deleted: srcIdx, score: score})
}
}
sort.Stable(matrix)
return matrix, nil
}
func compactChanges(changes []*Change) []*Change {
var result []*Change
for _, c := range changes {
if c != nil {
result = append(result, c)
}
}
return result
}
const (
keyShift = 32
maxCountValue = (1 << keyShift) - 1
)
var errIndexFull = errors.New("index is full")
// similarityIndex is an index structure of lines/blocks in one file.
// This structure can be used to compute an approximation of the similarity
// between two files.
// To save space in memory, this index uses a space efficient encoding which
// will not exceed 1MiB per instance. The index starts out at a smaller size
// (closer to 2KiB), but may grow as more distinct blocks within the scanned
// file are discovered.
// see: https://github.com/eclipse/jgit/blob/master/org.eclipse.jgit/src/org/eclipse/jgit/diff/SimilarityIndex.java
type similarityIndex struct {
hashed uint64
// number of non-zero entries in hashes
numHashes int
growAt int
hashes []keyCountPair
hashBits int
}
func fileSimilarityIndex(f *File) (*similarityIndex, error) {
idx := newSimilarityIndex()
if err := idx.hash(f); err != nil {
return nil, err
}
sort.Stable(keyCountPairs(idx.hashes))
return idx, nil
}
func newSimilarityIndex() *similarityIndex {
return &similarityIndex{
hashBits: 8,
hashes: make([]keyCountPair, 1<<8),
growAt: shouldGrowAt(8),
}
}
func (i *similarityIndex) hash(f *File) error {
isBin, err := f.IsBinary()
if err != nil {
return err
}
r, err := f.Reader()
if err != nil {
return err
}
defer ioutil.CheckClose(r, &err)
return i.hashContent(r, f.Size, isBin)
}
func (i *similarityIndex) hashContent(r io.Reader, size int64, isBin bool) error {
var buf = make([]byte, 4096)
var ptr, cnt int
remaining := size
for 0 < remaining {
hash := 5381
var blockHashedCnt uint64
// Hash one line or block, whatever happens first
n := int64(0)
for {
if ptr == cnt {
ptr = 0
var err error
cnt, err = io.ReadFull(r, buf)
if err != nil && err != io.ErrUnexpectedEOF {
return err
}
if cnt == 0 {
return io.EOF
}
}
n++
c := buf[ptr] & 0xff
ptr++
// Ignore CR in CRLF sequence if it's text
if !isBin && c == '\r' && ptr < cnt && buf[ptr] == '\n' {
continue
}
blockHashedCnt++
if c == '\n' {
break
}
hash = (hash << 5) + hash + int(c)
if n >= 64 || n >= remaining {
break
}
}
i.hashed += blockHashedCnt
if err := i.add(hash, blockHashedCnt); err != nil {
return err
}
remaining -= n
}
return nil
}
// score computes the similarity score between this index and another one.
// A region of a file is defined as a line in a text file or a fixed-size
// block in a binary file. To prepare an index, each region in the file is
// hashed; the values and counts of hashes are retained in a sorted table.
// Define the similarity fraction F as the count of matching regions between
// the two files divided between the maximum count of regions in either file.
// The similarity score is F multiplied by the maxScore constant, yielding a
// range [0, maxScore]. It is defined as maxScore for the degenerate case of
// two empty files.
// The similarity score is symmetrical; i.e. a.score(b) == b.score(a).
func (i *similarityIndex) score(other *similarityIndex, maxScore int) int {
var maxHashed = i.hashed
if maxHashed < other.hashed {
maxHashed = other.hashed
}
if maxHashed == 0 {
return maxScore
}
return int(i.common(other) * uint64(maxScore) / maxHashed)
}
func (i *similarityIndex) common(dst *similarityIndex) uint64 {
srcIdx, dstIdx := 0, 0
if i.numHashes == 0 || dst.numHashes == 0 {
return 0
}
var common uint64
srcKey, dstKey := i.hashes[srcIdx].key(), dst.hashes[dstIdx].key()
for {
if srcKey == dstKey {
srcCnt, dstCnt := i.hashes[srcIdx].count(), dst.hashes[dstIdx].count()
if srcCnt < dstCnt {
common += srcCnt
} else {
common += dstCnt
}
srcIdx++
if srcIdx == len(i.hashes) {
break
}
srcKey = i.hashes[srcIdx].key()
dstIdx++
if dstIdx == len(dst.hashes) {
break
}
dstKey = dst.hashes[dstIdx].key()
} else if srcKey < dstKey {
// Region of src that is not in dst
srcIdx++
if srcIdx == len(i.hashes) {
break
}
srcKey = i.hashes[srcIdx].key()
} else {
// Region of dst that is not in src
dstIdx++
if dstIdx == len(dst.hashes) {
break
}
dstKey = dst.hashes[dstIdx].key()
}
}
return common
}
func (i *similarityIndex) add(key int, cnt uint64) error {
key = int(uint32(key) * 0x9e370001 >> 1)
j := i.slot(key)
for {
v := i.hashes[j]
if v == 0 {
// It's an empty slot, so we can store it here.
if i.growAt <= i.numHashes {
if err := i.grow(); err != nil {
return err
}
j = i.slot(key)
continue
}
var err error
i.hashes[j], err = newKeyCountPair(key, cnt)
if err != nil {
return err
}
i.numHashes++
return nil
} else if v.key() == key {
// It's the same key, so increment the counter.
var err error
i.hashes[j], err = newKeyCountPair(key, v.count()+cnt)
return err
} else if j+1 >= len(i.hashes) {
j = 0
} else {
j++
}
}
}
type keyCountPair uint64
func newKeyCountPair(key int, cnt uint64) (keyCountPair, error) {
if cnt > maxCountValue {
return 0, errIndexFull
}
return keyCountPair((uint64(key) << keyShift) | cnt), nil
}
func (p keyCountPair) key() int {
return int(p >> keyShift)
}
func (p keyCountPair) count() uint64 {
return uint64(p) & maxCountValue
}
func (i *similarityIndex) slot(key int) int {
// We use 31 - hashBits because the upper bit was already forced
// to be 0 and we want the remaining high bits to be used as the
// table slot.
return int(uint32(key) >> uint(31-i.hashBits))
}
func shouldGrowAt(hashBits int) int {
return (1 << uint(hashBits)) * (hashBits - 3) / hashBits
}
func (i *similarityIndex) grow() error {
if i.hashBits == 30 {
return errIndexFull
}
old := i.hashes
i.hashBits++
i.growAt = shouldGrowAt(i.hashBits)
// TODO(erizocosmico): find a way to check if it will OOM and return
// errIndexFull instead.
i.hashes = make([]keyCountPair, 1<= len(i.hashes) {
j = 0
}
}
i.hashes[j] = v
}
}
return nil
}
type keyCountPairs []keyCountPair
func (p keyCountPairs) Len() int { return len(p) }
func (p keyCountPairs) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
func (p keyCountPairs) Less(i, j int) bool { return p[i] < p[j] }
go-git-5.13.2/plumbing/object/rename_test.go 0000664 0000000 0000000 00000035662 14744245500 0020731 0 ustar 00root root 0000000 0000000 package object
import (
"path/filepath"
"strings"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
type RenameSuite struct {
BaseObjectsSuite
}
var _ = Suite(&RenameSuite{})
func (s *RenameSuite) TestNameSimilarityScore(c *C) {
testCases := []struct {
a, b string
score int
}{
{"foo/bar.c", "foo/baz.c", 70},
{"src/utils/Foo.java", "tests/utils/Foo.java", 64},
{"foo/bar/baz.py", "README.md", 0},
{"src/utils/something/foo.py", "src/utils/something/other/foo.py", 69},
{"src/utils/something/foo.py", "src/utils/yada/foo.py", 63},
{"src/utils/something/foo.py", "src/utils/something/other/bar.py", 44},
{"src/utils/something/foo.py", "src/utils/something/foo.py", 100},
}
for _, tt := range testCases {
c.Assert(nameSimilarityScore(tt.a, tt.b), Equals, tt.score)
}
}
const (
pathA = "src/A"
pathB = "src/B"
pathH = "src/H"
pathQ = "src/Q"
)
func (s *RenameSuite) TestExactRename_OneRename(c *C) {
a := makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo"))
b := makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo"))
result := detectRenames(c, Changes{a, b}, nil, 1)
assertRename(c, b, a, result[0])
}
func (s *RenameSuite) TestExactRename_DifferentObjects(c *C) {
a := makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo"))
h := makeAdd(c, makeFile(c, pathH, filemode.Regular, "foo"))
q := makeDelete(c, makeFile(c, pathQ, filemode.Regular, "bar"))
result := detectRenames(c, Changes{a, h, q}, nil, 3)
c.Assert(result[0], DeepEquals, a)
c.Assert(result[1], DeepEquals, h)
c.Assert(result[2], DeepEquals, q)
}
func (s *RenameSuite) TestExactRename_OneRenameOneModify(c *C) {
c1 := makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo"))
c2 := makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo"))
c3 := makeChange(c,
makeFile(c, pathH, filemode.Regular, "bar"),
makeFile(c, pathH, filemode.Regular, "bar"),
)
result := detectRenames(c, Changes{c1, c2, c3}, nil, 2)
c.Assert(result[0], DeepEquals, c3)
assertRename(c, c2, c1, result[1])
}
func (s *RenameSuite) TestExactRename_ManyRenames(c *C) {
c1 := makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo"))
c2 := makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo"))
c3 := makeAdd(c, makeFile(c, pathH, filemode.Regular, "bar"))
c4 := makeDelete(c, makeFile(c, pathB, filemode.Regular, "bar"))
result := detectRenames(c, Changes{c1, c2, c3, c4}, nil, 2)
assertRename(c, c4, c3, result[0])
assertRename(c, c2, c1, result[1])
}
func (s *RenameSuite) TestExactRename_MultipleIdenticalDeletes(c *C) {
changes := Changes{
makeDelete(c, makeFile(c, pathA, filemode.Regular, "foo")),
makeDelete(c, makeFile(c, pathB, filemode.Regular, "foo")),
makeDelete(c, makeFile(c, pathH, filemode.Regular, "foo")),
makeAdd(c, makeFile(c, pathQ, filemode.Regular, "foo")),
}
result := detectRenames(c, changes, nil, 3)
assertRename(c, changes[0], changes[3], result[0])
c.Assert(result[1], DeepEquals, changes[1])
c.Assert(result[2], DeepEquals, changes[2])
}
func (s *RenameSuite) TestRenameExact_PathBreaksTie(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, "src/com/foo/a.java", filemode.Regular, "foo")),
makeDelete(c, makeFile(c, "src/com/foo/b.java", filemode.Regular, "foo")),
makeAdd(c, makeFile(c, "c.txt", filemode.Regular, "foo")),
makeDelete(c, makeFile(c, "d.txt", filemode.Regular, "foo")),
makeAdd(c, makeFile(c, "the_e_file.txt", filemode.Regular, "foo")),
}
// Add out of order to avoid first-match succeeding
result := detectRenames(c, Changes{
changes[0],
changes[3],
changes[4],
changes[1],
changes[2],
}, nil, 3)
assertRename(c, changes[3], changes[2], result[0])
assertRename(c, changes[1], changes[0], result[1])
c.Assert(result[2], DeepEquals, changes[4])
}
func (s *RenameSuite) TestExactRename_OneDeleteManyAdds(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, "src/com/foo/a.java", filemode.Regular, "foo")),
makeAdd(c, makeFile(c, "src/com/foo/b.java", filemode.Regular, "foo")),
makeAdd(c, makeFile(c, "c.txt", filemode.Regular, "foo")),
makeDelete(c, makeFile(c, "d.txt", filemode.Regular, "foo")),
}
result := detectRenames(c, changes, nil, 3)
assertRename(c, changes[3], changes[2], result[0])
c.Assert(result[1], DeepEquals, changes[0])
c.Assert(result[2], DeepEquals, changes[1])
}
func (s *RenameSuite) TestExactRename_UnstagedFile(c *C) {
changes := Changes{
makeDelete(c, makeFile(c, pathA, filemode.Regular, "foo")),
makeAdd(c, makeFile(c, pathB, filemode.Regular, "foo")),
}
result := detectRenames(c, changes, nil, 1)
assertRename(c, changes[0], changes[1], result[0])
}
func (s *RenameSuite) TestContentRename_OnePair(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\nbaz\nblarg\n")),
makeDelete(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\nbaz\nblah\n")),
}
result := detectRenames(c, changes, nil, 1)
assertRename(c, changes[1], changes[0], result[0])
}
func (s *RenameSuite) TestContentRename_OneRenameTwoUnrelatedFiles(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\nbaz\nblarg\n")),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo\nbar\nbaz\nblah\n")),
makeAdd(c, makeFile(c, pathB, filemode.Regular, "some\nsort\nof\ntext\n")),
makeDelete(c, makeFile(c, pathH, filemode.Regular, "completely\nunrelated\ntext\n")),
}
result := detectRenames(c, changes, nil, 3)
c.Assert(result[0], DeepEquals, changes[2])
c.Assert(result[1], DeepEquals, changes[3])
assertRename(c, changes[1], changes[0], result[2])
}
func (s *RenameSuite) TestContentRename_LastByteDifferent(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\na")),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo\nbar\nb")),
}
result := detectRenames(c, changes, nil, 1)
assertRename(c, changes[1], changes[0], result[0])
}
func (s *RenameSuite) TestContentRename_NewlinesOnly(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, strings.Repeat("\n", 3))),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, strings.Repeat("\n", 4))),
}
result := detectRenames(c, changes, nil, 1)
assertRename(c, changes[1], changes[0], result[0])
}
func (s *RenameSuite) TestContentRename_SameContentMultipleTimes(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "a\na\na\na\n")),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, "a\na\na\n")),
}
result := detectRenames(c, changes, nil, 1)
assertRename(c, changes[1], changes[0], result[0])
}
func (s *RenameSuite) TestContentRename_OnePairRenameScore50(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "ab\nab\nab\nac\nad\nae\n")),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, "ac\nab\nab\nab\naa\na0\na1\n")),
}
result := detectRenames(c, changes, &DiffTreeOptions{RenameScore: 50}, 1)
assertRename(c, changes[1], changes[0], result[0])
}
func (s *RenameSuite) TestNoRenames_SingleByteFiles(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "a")),
makeAdd(c, makeFile(c, pathQ, filemode.Regular, "b")),
}
result := detectRenames(c, changes, nil, 2)
c.Assert(result[0], DeepEquals, changes[0])
c.Assert(result[1], DeepEquals, changes[1])
}
func (s *RenameSuite) TestNoRenames_EmptyFile(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "")),
}
result := detectRenames(c, changes, nil, 1)
c.Assert(result[0], DeepEquals, changes[0])
}
func (s *RenameSuite) TestNoRenames_EmptyFile2(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "")),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, "blah")),
}
result := detectRenames(c, changes, nil, 2)
c.Assert(result[0], DeepEquals, changes[0])
c.Assert(result[1], DeepEquals, changes[1])
}
func (s *RenameSuite) TestNoRenames_SymlinkAndFile(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "src/dest")),
makeDelete(c, makeFile(c, pathQ, filemode.Symlink, "src/dest")),
}
result := detectRenames(c, changes, nil, 2)
c.Assert(result[0], DeepEquals, changes[0])
c.Assert(result[1], DeepEquals, changes[1])
}
func (s *RenameSuite) TestNoRenames_SymlinkAndFileSamePath(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "src/dest")),
makeDelete(c, makeFile(c, pathA, filemode.Symlink, "src/dest")),
}
result := detectRenames(c, changes, nil, 2)
c.Assert(result[0], DeepEquals, changes[0])
c.Assert(result[1], DeepEquals, changes[1])
}
func (s *RenameSuite) TestRenameLimit(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\nbaz\nblarg\n")),
makeDelete(c, makeFile(c, pathB, filemode.Regular, "foo\nbar\nbaz\nblah\n")),
makeAdd(c, makeFile(c, pathH, filemode.Regular, "a\nb\nc\nd\n")),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, "a\nb\nc\n")),
}
result := detectRenames(c, changes, &DiffTreeOptions{RenameLimit: 1}, 4)
for i, res := range result {
c.Assert(res, DeepEquals, changes[i])
}
}
func (s *RenameSuite) TestRenameExactManyAddsManyDeletesNoGaps(c *C) {
content := "a"
detector := &renameDetector{
added: []*Change{
makeAdd(c, makeFile(c, pathA, filemode.Regular, content)),
makeAdd(c, makeFile(c, pathQ, filemode.Regular, content)),
makeAdd(c, makeFile(c, "something", filemode.Regular, content)),
},
deleted: []*Change{
makeDelete(c, makeFile(c, pathA, filemode.Regular, content)),
makeDelete(c, makeFile(c, pathB, filemode.Regular, content)),
makeDelete(c, makeFile(c, "foo/bar/other", filemode.Regular, content)),
},
}
detector.detectExactRenames()
for _, added := range detector.added {
c.Assert(added, NotNil)
}
for _, deleted := range detector.deleted {
c.Assert(deleted, NotNil)
}
}
func detectRenames(c *C, changes Changes, opts *DiffTreeOptions, expectedResults int) Changes {
result, err := DetectRenames(changes, opts)
c.Assert(err, IsNil)
c.Assert(result, HasLen, expectedResults)
return result
}
func assertRename(c *C, from, to *Change, rename *Change) {
c.Assert(&Change{From: from.From, To: to.To}, DeepEquals, rename)
}
type SimilarityIndexSuite struct {
BaseObjectsSuite
}
var _ = Suite(&SimilarityIndexSuite{})
func (s *SimilarityIndexSuite) TestScoreFiles(c *C) {
tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"))
binary, err := tree.File("binary.jpg")
c.Assert(err, IsNil)
binIndex, err := fileSimilarityIndex(binary)
c.Assert(err, IsNil)
long, err := tree.File("json/long.json")
c.Assert(err, IsNil)
longIndex, err := fileSimilarityIndex(long)
c.Assert(err, IsNil)
short, err := tree.File("json/short.json")
c.Assert(err, IsNil)
shortIndex, err := fileSimilarityIndex(short)
c.Assert(err, IsNil)
php, err := tree.File("php/crappy.php")
c.Assert(err, IsNil)
phpIndex, err := fileSimilarityIndex(php)
c.Assert(err, IsNil)
testCases := []struct {
src, dst *similarityIndex
expectedScore int
}{
{binIndex, binIndex, 10000}, // same file
{shortIndex, longIndex, 32}, // slightly similar files
{longIndex, shortIndex, 32}, // same as previous, diff order
{shortIndex, phpIndex, 1}, // different files
{longIndex, binIndex, 0}, // code vs binary file
}
for _, tt := range testCases {
score := tt.src.score(tt.dst, 10000)
c.Assert(score, Equals, tt.expectedScore)
}
}
func (s *SimilarityIndexSuite) TestHashContent(c *C) {
idx := textIndex(c, "A\n"+
"B\n"+
"D\n"+
"B\n")
keyA := keyFor(c, "A\n")
keyB := keyFor(c, "B\n")
keyD := keyFor(c, "D\n")
c.Assert(keyA, Not(Equals), keyB)
c.Assert(keyA, Not(Equals), keyD)
c.Assert(keyD, Not(Equals), keyB)
c.Assert(idx.numHashes, Equals, 3)
c.Assert(idx.hashes[findIndex(idx, keyA)].count(), Equals, uint64(2))
c.Assert(idx.hashes[findIndex(idx, keyB)].count(), Equals, uint64(4))
c.Assert(idx.hashes[findIndex(idx, keyD)].count(), Equals, uint64(2))
}
func (s *SimilarityIndexSuite) TestCommonSameFiles(c *C) {
content := "A\n" +
"B\n" +
"D\n" +
"B\n"
src := textIndex(c, content)
dst := textIndex(c, content)
c.Assert(src.common(dst), Equals, uint64(8))
c.Assert(dst.common(src), Equals, uint64(8))
c.Assert(src.score(dst, 100), Equals, 100)
c.Assert(dst.score(src, 100), Equals, 100)
}
func (s *SimilarityIndexSuite) TestCommonSameFilesCR(c *C) {
content := "A\r\n" +
"B\r\n" +
"D\r\n" +
"B\r\n"
src := textIndex(c, content)
dst := textIndex(c, strings.ReplaceAll(content, "\r", ""))
c.Assert(src.common(dst), Equals, uint64(8))
c.Assert(dst.common(src), Equals, uint64(8))
c.Assert(src.score(dst, 100), Equals, 100)
c.Assert(dst.score(src, 100), Equals, 100)
}
func (s *SimilarityIndexSuite) TestCommonEmptyFiles(c *C) {
src := textIndex(c, "")
dst := textIndex(c, "")
c.Assert(src.common(dst), Equals, uint64(0))
c.Assert(dst.common(src), Equals, uint64(0))
}
func (s *SimilarityIndexSuite) TestCommonTotallyDifferentFiles(c *C) {
src := textIndex(c, "A\n")
dst := textIndex(c, "D\n")
c.Assert(src.common(dst), Equals, uint64(0))
c.Assert(dst.common(src), Equals, uint64(0))
}
func (s *SimilarityIndexSuite) TestSimilarity75(c *C) {
src := textIndex(c, "A\nB\nC\nD\n")
dst := textIndex(c, "A\nB\nC\nQ\n")
c.Assert(src.common(dst), Equals, uint64(6))
c.Assert(dst.common(src), Equals, uint64(6))
c.Assert(src.score(dst, 100), Equals, 75)
c.Assert(dst.score(src, 100), Equals, 75)
}
func keyFor(c *C, line string) int {
idx := newSimilarityIndex()
err := idx.hashContent(strings.NewReader(line), int64(len(line)), false)
c.Assert(err, IsNil)
c.Assert(idx.numHashes, Equals, 1)
for _, h := range idx.hashes {
if h != 0 {
return h.key()
}
}
return -1
}
func textIndex(c *C, content string) *similarityIndex {
idx := newSimilarityIndex()
err := idx.hashContent(strings.NewReader(content), int64(len(content)), false)
c.Assert(err, IsNil)
return idx
}
func findIndex(idx *similarityIndex, key int) int {
for i, h := range idx.hashes {
if h.key() == key {
return i
}
}
return -1
}
func makeFile(c *C, name string, mode filemode.FileMode, content string) *File {
obj := new(plumbing.MemoryObject)
obj.SetType(plumbing.BlobObject)
_, err := obj.Write([]byte(content))
c.Assert(err, IsNil)
return &File{
Name: name,
Mode: mode,
Blob: Blob{Hash: obj.Hash(), Size: obj.Size(), obj: obj},
}
}
func makeChangeEntry(f *File) ChangeEntry {
sto := memory.NewStorage()
sto.SetEncodedObject(f.obj)
tree := &Tree{s: sto}
return ChangeEntry{
Name: f.Name,
Tree: tree,
TreeEntry: TreeEntry{
Name: filepath.Base(f.Name),
Mode: f.Mode,
Hash: f.Hash,
},
}
}
func makeAdd(c *C, f *File) *Change {
return makeChange(c, nil, f)
}
func makeDelete(c *C, f *File) *Change {
return makeChange(c, f, nil)
}
func makeChange(c *C, from *File, to *File) *Change {
if from == nil {
return &Change{To: makeChangeEntry(to)}
}
if to == nil {
return &Change{From: makeChangeEntry(from)}
}
if from == nil && to == nil {
c.Error("cannot make change without from or to")
}
return &Change{From: makeChangeEntry(from), To: makeChangeEntry(to)}
}
go-git-5.13.2/plumbing/object/signature.go 0000664 0000000 0000000 00000005414 14744245500 0020414 0 ustar 00root root 0000000 0000000 package object
import "bytes"
const (
signatureTypeUnknown signatureType = iota
signatureTypeOpenPGP
signatureTypeX509
signatureTypeSSH
)
var (
// openPGPSignatureFormat is the format of an OpenPGP signature.
openPGPSignatureFormat = signatureFormat{
[]byte("-----BEGIN PGP SIGNATURE-----"),
[]byte("-----BEGIN PGP MESSAGE-----"),
}
// x509SignatureFormat is the format of an X509 signature, which is
// a PKCS#7 (S/MIME) signature.
x509SignatureFormat = signatureFormat{
[]byte("-----BEGIN CERTIFICATE-----"),
[]byte("-----BEGIN SIGNED MESSAGE-----"),
}
// sshSignatureFormat is the format of an SSH signature.
sshSignatureFormat = signatureFormat{
[]byte("-----BEGIN SSH SIGNATURE-----"),
}
)
var (
// knownSignatureFormats is a map of known signature formats, indexed by
// their signatureType.
knownSignatureFormats = map[signatureType]signatureFormat{
signatureTypeOpenPGP: openPGPSignatureFormat,
signatureTypeX509: x509SignatureFormat,
signatureTypeSSH: sshSignatureFormat,
}
)
// signatureType represents the type of the signature.
type signatureType int8
// signatureFormat represents the beginning of a signature.
type signatureFormat [][]byte
// typeForSignature returns the type of the signature based on its format.
func typeForSignature(b []byte) signatureType {
for t, i := range knownSignatureFormats {
for _, begin := range i {
if bytes.HasPrefix(b, begin) {
return t
}
}
}
return signatureTypeUnknown
}
// parseSignedBytes returns the position of the last signature block found in
// the given bytes. If no signature block is found, it returns -1.
//
// When multiple signature blocks are found, the position of the last one is
// returned. Any tailing bytes after this signature block start should be
// considered part of the signature.
//
// Given this, it would be safe to use the returned position to split the bytes
// into two parts: the first part containing the message, the second part
// containing the signature.
//
// Example:
//
// message := []byte(`Message with signature
//
// -----BEGIN SSH SIGNATURE-----
// ...`)
//
// var signature string
// if pos, _ := parseSignedBytes(message); pos != -1 {
// signature = string(message[pos:])
// message = message[:pos]
// }
//
// This logic is on par with git's gpg-interface.c:parse_signed_buffer().
// https://github.com/git/git/blob/7c2ef319c52c4997256f5807564523dfd4acdfc7/gpg-interface.c#L668
func parseSignedBytes(b []byte) (int, signatureType) {
var n, match = 0, -1
var t signatureType
for n < len(b) {
var i = b[n:]
if st := typeForSignature(i); st != signatureTypeUnknown {
match = n
t = st
}
if eol := bytes.IndexByte(i, '\n'); eol >= 0 {
n += eol + 1
continue
}
// If we reach this point, we've reached the end.
break
}
return match, t
}
go-git-5.13.2/plumbing/object/signature_test.go 0000664 0000000 0000000 00000016011 14744245500 0021446 0 ustar 00root root 0000000 0000000 package object
import (
"bytes"
"testing"
)
func Test_typeForSignature(t *testing.T) {
tests := []struct {
name string
b []byte
want signatureType
}{
{
name: "known signature format (PGP)",
b: []byte(`-----BEGIN PGP SIGNATURE-----
iHUEABYKAB0WIQTMqU0ycQ3f6g3PMoWMmmmF4LuV8QUCYGebVwAKCRCMmmmF4LuV
8VtyAP9LbuXAhtK6FQqOjKybBwlV70rLcXVP24ubDuz88VVwSgD+LuObsasWq6/U
TssDKHUR2taa53bQYjkZQBpvvwOrLgc=
=YQUf
-----END PGP SIGNATURE-----`),
want: signatureTypeOpenPGP,
},
{
name: "known signature format (SSH)",
b: []byte(`-----BEGIN SSH SIGNATURE-----
U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgij/EfHS8tCjolj5uEANXgKzFfp
0D7wOhjWVbYZH6KugAAAADZ2l0AAAAAAAAAAZzaGE1MTIAAABTAAAAC3NzaC1lZDI1NTE5
AAAAQIYHMhSVV9L2xwJuV8eWMLjThya8yXgCHDzw3p01D19KirrabW0veiichPB5m+Ihtr
MKEQruIQWJb+8HVXwssA4=
-----END SSH SIGNATURE-----`),
want: signatureTypeSSH,
},
{
name: "known signature format (X509) CERTIFICATE",
b: []byte(`-----BEGIN CERTIFICATE-----
MIIDZjCCAk6gAwIBAgIJALZ9Z3Z9Z3Z9MA0GCSqGSIb3DQEBCwUAMIGIMQswCQYD
VQQGEwJTRTEOMAwGA1UECAwFVGV4YXMxDjAMBgNVBAcMBVRleGFzMQ4wDAYDVQQK
DAVUZXhhczEOMAwGA1UECwwFVGV4YXMxGDAWBgNVBAMMD1RleGFzIENlcnRpZmlj
YXRlMB4XDTE3MDUyNjE3MjY0MloXDTI3MDUyNDE3MjY0MlowgYgxCzAJBgNVBAYT
AlNFMQ4wDAYDVQQIDAVUZXhhczEOMAwGA1UEBwwFVGV4YXMxDjAMBgNVBAoMBVRl
eGFzMQ4wDAYDVQQLDAVUZXhhczEYMBYGA1UEAwwPVGV4YXMgQ2VydGlmaWNhdGUw
ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDQZ9Z3Z9Z3Z9Z3Z9Z3Z9Z3
-----END CERTIFICATE-----`),
want: signatureTypeX509,
},
{
name: "known signature format (x509) SIGNED MESSAGE",
b: []byte(`-----BEGIN SIGNED MESSAGE-----
MIIDZjCCAk6gAwIBAgIJALZ9Z3Z9Z3Z9MA0GCSqGSIb3DQEBCwUAMIGIMQswCQYD
VQQGEwJTRTEOMAwGA1UECAwFVGV4YXMxDjAMBgNVBAcMBVRleGFzMQ4wDAYDVQQK
DAVUZXhhczEOMAwGA1UECwwFVGV4YXMxGDAWBgNVBAMMD1RleGFzIENlcnRpZmlj
YXRlMB4XDTE3MDUyNjE3MjY0MloXDTI3MDUyNDE3MjY0MlowgYgxCzAJBgNVBAYT
AlNFMQ4wDAYDVQQIDAVUZXhhczEOMAwGA1UEBwwFVGV4YXMxDjAMBgNVBAoMBVRl
eGFzMQ4wDAYDVQQLDAVUZXhhczEYMBYGA1UEAwwPVGV4YXMgQ2VydGlmaWNhdGUw
ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDQZ9Z3Z9Z3Z9Z3Z9Z3Z9Z3
-----END SIGNED MESSAGE-----`),
want: signatureTypeX509,
},
{
name: "unknown signature format",
b: []byte(`-----BEGIN ARBITRARY SIGNATURE-----
U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgij/EfHS8tCjolj5uEANXgKzFfp
-----END UNKNOWN SIGNATURE-----`),
want: signatureTypeUnknown,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := typeForSignature(tt.b); got != tt.want {
t.Errorf("typeForSignature() = %v, want %v", got, tt.want)
}
})
}
}
func Test_parseSignedBytes(t *testing.T) {
tests := []struct {
name string
b []byte
wantSignature []byte
wantType signatureType
}{
{
name: "detects signature and type",
b: []byte(`signed tag
-----BEGIN PGP SIGNATURE-----
iQGzBAABCAAdFiEE/h5sbbqJFh9j1AdUSqtFFGopTmwFAmB5XFkACgkQSqtFFGop
TmxvgAv+IPjX5WCLFUIMx8hquMZp1VkhQrseE7rljUYaYpga8gZ9s4kseTGhy7Un
61U3Ro6cTPEiQF/FkAGzSdPuGqv0ARBqHDX2tUI9+Zs/K8aG8tN+JTaof0gBcTyI
BLbZVYDTxbS9whxSDewQd0OvBG1m9ISLUhjXo6mbaVvrKXNXTHg40MPZ8ZxjR/vN
hxXXoUVnFyEDo+v6nK56mYtapThDaQQHHzD6D3VaCq3Msog7qAh9/ZNBmgb88aQ3
FoK8PHMyr5elsV3mE9bciZBUc+dtzjOvp94uQ5ZKUXaPusXaYXnKpVnzhyer6RBI
gJLWtPwAinqmN41rGJ8jDAGrpPNjaRrMhGtbyVUPUf19OxuUIroe77sIIKTP0X2o
Wgp56dYpTst0JcGv/FYCeau/4pTRDfwHAOcDiBQ/0ag9IrZp9P8P9zlKmzNPEraV
pAe1/EFuhv2UDLucAiWM8iDZIcw8iN0OYMOGUmnk0WuGIo7dzLeqMGY+ND5n5Z8J
sZC//k6m
=VhHy
-----END PGP SIGNATURE-----`),
wantSignature: []byte(`-----BEGIN PGP SIGNATURE-----
iQGzBAABCAAdFiEE/h5sbbqJFh9j1AdUSqtFFGopTmwFAmB5XFkACgkQSqtFFGop
TmxvgAv+IPjX5WCLFUIMx8hquMZp1VkhQrseE7rljUYaYpga8gZ9s4kseTGhy7Un
61U3Ro6cTPEiQF/FkAGzSdPuGqv0ARBqHDX2tUI9+Zs/K8aG8tN+JTaof0gBcTyI
BLbZVYDTxbS9whxSDewQd0OvBG1m9ISLUhjXo6mbaVvrKXNXTHg40MPZ8ZxjR/vN
hxXXoUVnFyEDo+v6nK56mYtapThDaQQHHzD6D3VaCq3Msog7qAh9/ZNBmgb88aQ3
FoK8PHMyr5elsV3mE9bciZBUc+dtzjOvp94uQ5ZKUXaPusXaYXnKpVnzhyer6RBI
gJLWtPwAinqmN41rGJ8jDAGrpPNjaRrMhGtbyVUPUf19OxuUIroe77sIIKTP0X2o
Wgp56dYpTst0JcGv/FYCeau/4pTRDfwHAOcDiBQ/0ag9IrZp9P8P9zlKmzNPEraV
pAe1/EFuhv2UDLucAiWM8iDZIcw8iN0OYMOGUmnk0WuGIo7dzLeqMGY+ND5n5Z8J
sZC//k6m
=VhHy
-----END PGP SIGNATURE-----`),
wantType: signatureTypeOpenPGP,
},
{
name: "last signature for multiple signatures",
b: []byte(`signed tag
-----BEGIN PGP SIGNATURE-----
iQGzBAABCAAdFiEE/h5sbbqJFh9j1AdUSqtFFGopTmwFAmB5XFkACgkQSqtFFGop
TmxvgAv+IPjX5WCLFUIMx8hquMZp1VkhQrseE7rljUYaYpga8gZ9s4kseTGhy7Un
61U3Ro6cTPEiQF/FkAGzSdPuGqv0ARBqHDX2tUI9+Zs/K8aG8tN+JTaof0gBcTyI
BLbZVYDTxbS9whxSDewQd0OvBG1m9ISLUhjXo6mbaVvrKXNXTHg40MPZ8ZxjR/vN
hxXXoUVnFyEDo+v6nK56mYtapThDaQQHHzD6D3VaCq3Msog7qAh9/ZNBmgb88aQ3
FoK8PHMyr5elsV3mE9bciZBUc+dtzjOvp94uQ5ZKUXaPusXaYXnKpVnzhyer6RBI
gJLWtPwAinqmN41rGJ8jDAGrpPNjaRrMhGtbyVUPUf19OxuUIroe77sIIKTP0X2o
Wgp56dYpTst0JcGv/FYCeau/4pTRDfwHAOcDiBQ/0ag9IrZp9P8P9zlKmzNPEraV
pAe1/EFuhv2UDLucAiWM8iDZIcw8iN0OYMOGUmnk0WuGIo7dzLeqMGY+ND5n5Z8J
sZC//k6m
=VhHy
-----END PGP SIGNATURE-----
-----BEGIN SSH SIGNATURE-----
U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgij/EfHS8tCjolj5uEANXgKzFfp
0D7wOhjWVbYZH6KugAAAADZ2l0AAAAAAAAAAZzaGE1MTIAAABTAAAAC3NzaC1lZDI1NTE5
AAAAQIYHMhSVV9L2xwJuV8eWMLjThya8yXgCHDzw3p01D19KirrabW0veiichPB5m+Ihtr
MKEQruIQWJb+8HVXwssA4=
-----END SSH SIGNATURE-----`),
wantSignature: []byte(`-----BEGIN SSH SIGNATURE-----
U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgij/EfHS8tCjolj5uEANXgKzFfp
0D7wOhjWVbYZH6KugAAAADZ2l0AAAAAAAAAAZzaGE1MTIAAABTAAAAC3NzaC1lZDI1NTE5
AAAAQIYHMhSVV9L2xwJuV8eWMLjThya8yXgCHDzw3p01D19KirrabW0veiichPB5m+Ihtr
MKEQruIQWJb+8HVXwssA4=
-----END SSH SIGNATURE-----`),
wantType: signatureTypeSSH,
},
{
name: "signature with trailing data",
b: []byte(`An invalid
-----BEGIN SSH SIGNATURE-----
U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgij/EfHS8tCjolj5uEANXgKzFfp
0D7wOhjWVbYZH6KugAAAADZ2l0AAAAAAAAAAZzaGE1MTIAAABTAAAAC3NzaC1lZDI1NTE5
AAAAQIYHMhSVV9L2xwJuV8eWMLjThya8yXgCHDzw3p01D19KirrabW0veiichPB5m+Ihtr
MKEQruIQWJb+8HVXwssA4=
-----END SSH SIGNATURE-----
signed tag`),
wantSignature: []byte(`-----BEGIN SSH SIGNATURE-----
U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgij/EfHS8tCjolj5uEANXgKzFfp
0D7wOhjWVbYZH6KugAAAADZ2l0AAAAAAAAAAZzaGE1MTIAAABTAAAAC3NzaC1lZDI1NTE5
AAAAQIYHMhSVV9L2xwJuV8eWMLjThya8yXgCHDzw3p01D19KirrabW0veiichPB5m+Ihtr
MKEQruIQWJb+8HVXwssA4=
-----END SSH SIGNATURE-----
signed tag`),
wantType: signatureTypeSSH,
},
{
name: "data without signature",
b: []byte(`Some message`),
wantSignature: []byte(``),
wantType: signatureTypeUnknown,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
pos, st := parseSignedBytes(tt.b)
var signature []byte
if pos >= 0 {
signature = tt.b[pos:]
}
if !bytes.Equal(signature, tt.wantSignature) {
t.Errorf("parseSignedBytes() got = %s for pos = %v, want %s", signature, pos, tt.wantSignature)
}
if st != tt.wantType {
t.Errorf("parseSignedBytes() got1 = %v, want %v", st, tt.wantType)
}
})
}
}
func FuzzParseSignedBytes(f *testing.F) {
f.Add([]byte(openPGPSignatureFormat[0]))
f.Add([]byte(x509SignatureFormat[0]))
f.Add([]byte(sshSignatureFormat[0]))
f.Fuzz(func(t *testing.T, input []byte) {
parseSignedBytes(input)
})
}
go-git-5.13.2/plumbing/object/tag.go 0000664 0000000 0000000 00000020731 14744245500 0017165 0 ustar 00root root 0000000 0000000 package object
import (
"bytes"
"fmt"
"io"
"strings"
"github.com/ProtonMail/go-crypto/openpgp"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-git/v5/utils/sync"
)
// Tag represents an annotated tag object. It points to a single git object of
// any type, but tags typically are applied to commit or blob objects. It
// provides a reference that associates the target with a tag name. It also
// contains meta-information about the tag, including the tagger, tag date and
// message.
//
// Note that this is not used for lightweight tags.
//
// https://git-scm.com/book/en/v2/Git-Internals-Git-References#Tags
type Tag struct {
// Hash of the tag.
Hash plumbing.Hash
// Name of the tag.
Name string
// Tagger is the one who created the tag.
Tagger Signature
// Message is an arbitrary text message.
Message string
// PGPSignature is the PGP signature of the tag.
PGPSignature string
// TargetType is the object type of the target.
TargetType plumbing.ObjectType
// Target is the hash of the target object.
Target plumbing.Hash
s storer.EncodedObjectStorer
}
// GetTag gets a tag from an object storer and decodes it.
func GetTag(s storer.EncodedObjectStorer, h plumbing.Hash) (*Tag, error) {
o, err := s.EncodedObject(plumbing.TagObject, h)
if err != nil {
return nil, err
}
return DecodeTag(s, o)
}
// DecodeTag decodes an encoded object into a *Commit and associates it to the
// given object storer.
func DecodeTag(s storer.EncodedObjectStorer, o plumbing.EncodedObject) (*Tag, error) {
t := &Tag{s: s}
if err := t.Decode(o); err != nil {
return nil, err
}
return t, nil
}
// ID returns the object ID of the tag, not the object that the tag references.
// The returned value will always match the current value of Tag.Hash.
//
// ID is present to fulfill the Object interface.
func (t *Tag) ID() plumbing.Hash {
return t.Hash
}
// Type returns the type of object. It always returns plumbing.TagObject.
//
// Type is present to fulfill the Object interface.
func (t *Tag) Type() plumbing.ObjectType {
return plumbing.TagObject
}
// Decode transforms a plumbing.EncodedObject into a Tag struct.
func (t *Tag) Decode(o plumbing.EncodedObject) (err error) {
if o.Type() != plumbing.TagObject {
return ErrUnsupportedObject
}
t.Hash = o.Hash()
reader, err := o.Reader()
if err != nil {
return err
}
defer ioutil.CheckClose(reader, &err)
r := sync.GetBufioReader(reader)
defer sync.PutBufioReader(r)
for {
var line []byte
line, err = r.ReadBytes('\n')
if err != nil && err != io.EOF {
return err
}
line = bytes.TrimSpace(line)
if len(line) == 0 {
break // Start of message
}
split := bytes.SplitN(line, []byte{' '}, 2)
switch string(split[0]) {
case "object":
t.Target = plumbing.NewHash(string(split[1]))
case "type":
t.TargetType, err = plumbing.ParseObjectType(string(split[1]))
if err != nil {
return err
}
case "tag":
t.Name = string(split[1])
case "tagger":
t.Tagger.Decode(split[1])
}
if err == io.EOF {
return nil
}
}
data, err := io.ReadAll(r)
if err != nil {
return err
}
if sm, _ := parseSignedBytes(data); sm >= 0 {
t.PGPSignature = string(data[sm:])
data = data[:sm]
}
t.Message = string(data)
return nil
}
// Encode transforms a Tag into a plumbing.EncodedObject.
func (t *Tag) Encode(o plumbing.EncodedObject) error {
return t.encode(o, true)
}
// EncodeWithoutSignature export a Tag into a plumbing.EncodedObject without the signature (correspond to the payload of the PGP signature).
func (t *Tag) EncodeWithoutSignature(o plumbing.EncodedObject) error {
return t.encode(o, false)
}
func (t *Tag) encode(o plumbing.EncodedObject, includeSig bool) (err error) {
o.SetType(plumbing.TagObject)
w, err := o.Writer()
if err != nil {
return err
}
defer ioutil.CheckClose(w, &err)
if _, err = fmt.Fprintf(w,
"object %s\ntype %s\ntag %s\ntagger ",
t.Target.String(), t.TargetType.Bytes(), t.Name); err != nil {
return err
}
if err = t.Tagger.Encode(w); err != nil {
return err
}
if _, err = fmt.Fprint(w, "\n\n"); err != nil {
return err
}
if _, err = fmt.Fprint(w, t.Message); err != nil {
return err
}
// Note that this is highly sensitive to what it sent along in the message.
// Message *always* needs to end with a newline, or else the message and the
// signature will be concatenated into a corrupt object. Since this is a
// lower-level method, we assume you know what you are doing and have already
// done the needful on the message in the caller.
if includeSig {
if _, err = fmt.Fprint(w, t.PGPSignature); err != nil {
return err
}
}
return err
}
// Commit returns the commit pointed to by the tag. If the tag points to a
// different type of object ErrUnsupportedObject will be returned.
func (t *Tag) Commit() (*Commit, error) {
if t.TargetType != plumbing.CommitObject {
return nil, ErrUnsupportedObject
}
o, err := t.s.EncodedObject(plumbing.CommitObject, t.Target)
if err != nil {
return nil, err
}
return DecodeCommit(t.s, o)
}
// Tree returns the tree pointed to by the tag. If the tag points to a commit
// object the tree of that commit will be returned. If the tag does not point
// to a commit or tree object ErrUnsupportedObject will be returned.
func (t *Tag) Tree() (*Tree, error) {
switch t.TargetType {
case plumbing.CommitObject:
c, err := t.Commit()
if err != nil {
return nil, err
}
return c.Tree()
case plumbing.TreeObject:
return GetTree(t.s, t.Target)
default:
return nil, ErrUnsupportedObject
}
}
// Blob returns the blob pointed to by the tag. If the tag points to a
// different type of object ErrUnsupportedObject will be returned.
func (t *Tag) Blob() (*Blob, error) {
if t.TargetType != plumbing.BlobObject {
return nil, ErrUnsupportedObject
}
return GetBlob(t.s, t.Target)
}
// Object returns the object pointed to by the tag.
func (t *Tag) Object() (Object, error) {
o, err := t.s.EncodedObject(t.TargetType, t.Target)
if err != nil {
return nil, err
}
return DecodeObject(t.s, o)
}
// String returns the meta information contained in the tag as a formatted
// string.
func (t *Tag) String() string {
obj, _ := t.Object()
return fmt.Sprintf(
"%s %s\nTagger: %s\nDate: %s\n\n%s\n%s",
plumbing.TagObject, t.Name, t.Tagger.String(), t.Tagger.When.Format(DateFormat),
t.Message, objectAsString(obj),
)
}
// Verify performs PGP verification of the tag with a provided armored
// keyring and returns openpgp.Entity associated with verifying key on success.
func (t *Tag) Verify(armoredKeyRing string) (*openpgp.Entity, error) {
keyRingReader := strings.NewReader(armoredKeyRing)
keyring, err := openpgp.ReadArmoredKeyRing(keyRingReader)
if err != nil {
return nil, err
}
// Extract signature.
signature := strings.NewReader(t.PGPSignature)
encoded := &plumbing.MemoryObject{}
// Encode tag components, excluding signature and get a reader object.
if err := t.EncodeWithoutSignature(encoded); err != nil {
return nil, err
}
er, err := encoded.Reader()
if err != nil {
return nil, err
}
return openpgp.CheckArmoredDetachedSignature(keyring, er, signature, nil)
}
// TagIter provides an iterator for a set of tags.
type TagIter struct {
storer.EncodedObjectIter
s storer.EncodedObjectStorer
}
// NewTagIter takes a storer.EncodedObjectStorer and a
// storer.EncodedObjectIter and returns a *TagIter that iterates over all
// tags contained in the storer.EncodedObjectIter.
//
// Any non-tag object returned by the storer.EncodedObjectIter is skipped.
func NewTagIter(s storer.EncodedObjectStorer, iter storer.EncodedObjectIter) *TagIter {
return &TagIter{iter, s}
}
// Next moves the iterator to the next tag and returns a pointer to it. If
// there are no more tags, it returns io.EOF.
func (iter *TagIter) Next() (*Tag, error) {
obj, err := iter.EncodedObjectIter.Next()
if err != nil {
return nil, err
}
return DecodeTag(iter.s, obj)
}
// ForEach call the cb function for each tag contained on this iter until
// an error happens or the end of the iter is reached. If ErrStop is sent
// the iteration is stop but no error is returned. The iterator is closed.
func (iter *TagIter) ForEach(cb func(*Tag) error) error {
return iter.EncodedObjectIter.ForEach(func(obj plumbing.EncodedObject) error {
t, err := DecodeTag(iter.s, obj)
if err != nil {
return err
}
return cb(t)
})
}
func objectAsString(obj Object) string {
switch o := obj.(type) {
case *Commit:
return o.String()
default:
return ""
}
}
go-git-5.13.2/plumbing/object/tag_test.go 0000664 0000000 0000000 00000035434 14744245500 0020232 0 ustar 00root root 0000000 0000000 package object
import (
"fmt"
"io"
"strings"
"time"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
type TagSuite struct {
BaseObjectsSuite
}
var _ = Suite(&TagSuite{})
func (s *TagSuite) SetUpSuite(c *C) {
s.BaseObjectsSuite.SetUpSuite(c)
storer := filesystem.NewStorage(fixtures.ByURL("https://github.com/git-fixtures/tags.git").One().DotGit(), cache.NewObjectLRUDefault())
s.Storer = storer
}
func (s *TagSuite) TestNameIDAndType(c *C) {
h := plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69")
tag := s.tag(c, h)
c.Assert(tag.Name, Equals, "annotated-tag")
c.Assert(h, Equals, tag.ID())
c.Assert(plumbing.TagObject, Equals, tag.Type())
}
func (s *TagSuite) TestTagger(c *C) {
tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69"))
c.Assert(tag.Tagger.String(), Equals, "Máximo Cuadros ")
}
func (s *TagSuite) TestAnnotated(c *C) {
tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69"))
c.Assert(tag.Message, Equals, "example annotated tag\n")
commit, err := tag.Commit()
c.Assert(err, IsNil)
c.Assert(commit.Type(), Equals, plumbing.CommitObject)
c.Assert(commit.ID().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f")
}
func (s *TagSuite) TestCommitError(c *C) {
tag := s.tag(c, plumbing.NewHash("fe6cb94756faa81e5ed9240f9191b833db5f40ae"))
commit, err := tag.Commit()
c.Assert(commit, IsNil)
c.Assert(err, NotNil)
c.Assert(err, Equals, ErrUnsupportedObject)
}
func (s *TagSuite) TestCommit(c *C) {
tag := s.tag(c, plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc"))
c.Assert(tag.Message, Equals, "a tagged commit\n")
commit, err := tag.Commit()
c.Assert(err, IsNil)
c.Assert(commit.Type(), Equals, plumbing.CommitObject)
c.Assert(commit.ID().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f")
}
func (s *TagSuite) TestBlobError(c *C) {
tag := s.tag(c, plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc"))
commit, err := tag.Blob()
c.Assert(commit, IsNil)
c.Assert(err, NotNil)
c.Assert(err, Equals, ErrUnsupportedObject)
}
func (s *TagSuite) TestBlob(c *C) {
tag := s.tag(c, plumbing.NewHash("fe6cb94756faa81e5ed9240f9191b833db5f40ae"))
c.Assert(tag.Message, Equals, "a tagged blob\n")
blob, err := tag.Blob()
c.Assert(err, IsNil)
c.Assert(blob.Type(), Equals, plumbing.BlobObject)
c.Assert(blob.ID().String(), Equals, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391")
}
func (s *TagSuite) TestTreeError(c *C) {
tag := s.tag(c, plumbing.NewHash("fe6cb94756faa81e5ed9240f9191b833db5f40ae"))
tree, err := tag.Tree()
c.Assert(tree, IsNil)
c.Assert(err, NotNil)
c.Assert(err, Equals, ErrUnsupportedObject)
}
func (s *TagSuite) TestTree(c *C) {
tag := s.tag(c, plumbing.NewHash("152175bf7e5580299fa1f0ba41ef6474cc043b70"))
c.Assert(tag.Message, Equals, "a tagged tree\n")
tree, err := tag.Tree()
c.Assert(err, IsNil)
c.Assert(tree.Type(), Equals, plumbing.TreeObject)
c.Assert(tree.ID().String(), Equals, "70846e9a10ef7b41064b40f07713d5b8b9a8fc73")
}
func (s *TagSuite) TestTreeFromCommit(c *C) {
tag := s.tag(c, plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc"))
c.Assert(tag.Message, Equals, "a tagged commit\n")
tree, err := tag.Tree()
c.Assert(err, IsNil)
c.Assert(tree.Type(), Equals, plumbing.TreeObject)
c.Assert(tree.ID().String(), Equals, "70846e9a10ef7b41064b40f07713d5b8b9a8fc73")
}
func (s *TagSuite) TestObject(c *C) {
tag := s.tag(c, plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc"))
obj, err := tag.Object()
c.Assert(err, IsNil)
c.Assert(obj.Type(), Equals, plumbing.CommitObject)
c.Assert(obj.ID().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f")
}
func (s *TagSuite) TestTagItter(c *C) {
iter, err := s.Storer.IterEncodedObjects(plumbing.TagObject)
c.Assert(err, IsNil)
var count int
i := NewTagIter(s.Storer, iter)
tag, err := i.Next()
c.Assert(err, IsNil)
c.Assert(tag, NotNil)
c.Assert(tag.Type(), Equals, plumbing.TagObject)
err = i.ForEach(func(t *Tag) error {
c.Assert(t, NotNil)
c.Assert(t.Type(), Equals, plumbing.TagObject)
count++
return nil
})
c.Assert(err, IsNil)
c.Assert(count, Equals, 3)
tag, err = i.Next()
c.Assert(err, Equals, io.EOF)
c.Assert(tag, IsNil)
}
func (s *TagSuite) TestTagIterError(c *C) {
iter, err := s.Storer.IterEncodedObjects(plumbing.TagObject)
c.Assert(err, IsNil)
randomErr := fmt.Errorf("a random error")
i := NewTagIter(s.Storer, iter)
err = i.ForEach(func(t *Tag) error {
return randomErr
})
c.Assert(err, NotNil)
c.Assert(err, Equals, randomErr)
}
func (s *TagSuite) TestTagDecodeWrongType(c *C) {
newTag := &Tag{}
obj := &plumbing.MemoryObject{}
obj.SetType(plumbing.BlobObject)
err := newTag.Decode(obj)
c.Assert(err, Equals, ErrUnsupportedObject)
}
func (s *TagSuite) TestTagEncodeDecodeIdempotent(c *C) {
ts, err := time.Parse(time.RFC3339, "2006-01-02T15:04:05-07:00")
c.Assert(err, IsNil)
tags := []*Tag{
{
Name: "foo",
Tagger: Signature{Name: "Foo", Email: "foo@example.local", When: ts},
Message: "Message\n\nFoo\nBar\nBaz\n\n",
TargetType: plumbing.BlobObject,
Target: plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
},
{
Name: "foo",
Tagger: Signature{Name: "Foo", Email: "foo@example.local", When: ts},
TargetType: plumbing.BlobObject,
Target: plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
},
}
for _, tag := range tags {
obj := &plumbing.MemoryObject{}
err = tag.Encode(obj)
c.Assert(err, IsNil)
newTag := &Tag{}
err = newTag.Decode(obj)
c.Assert(err, IsNil)
tag.Hash = obj.Hash()
c.Assert(newTag, DeepEquals, tag)
}
}
func (s *TagSuite) TestString(c *C) {
tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69"))
c.Assert(tag.String(), Equals, ""+
"tag annotated-tag\n"+
"Tagger: Máximo Cuadros \n"+
"Date: Wed Sep 21 21:13:35 2016 +0200\n"+
"\n"+
"example annotated tag\n"+
"\n"+
"commit f7b877701fbf855b44c0a9e86f3fdce2c298b07f\n"+
"Author: Máximo Cuadros \n"+
"Date: Wed Sep 21 21:10:52 2016 +0200\n"+
"\n"+
" initial\n"+
"\n",
)
tag = s.tag(c, plumbing.NewHash("152175bf7e5580299fa1f0ba41ef6474cc043b70"))
c.Assert(tag.String(), Equals, ""+
"tag tree-tag\n"+
"Tagger: Máximo Cuadros \n"+
"Date: Wed Sep 21 21:17:56 2016 +0200\n"+
"\n"+
"a tagged tree\n"+
"\n",
)
}
func (s *TagSuite) TestStringNonCommit(c *C) {
store := memory.NewStorage()
target := &Tag{
Target: plumbing.NewHash("TAGONE"),
Name: "TAG ONE",
Message: "tag one",
TargetType: plumbing.TagObject,
}
targetObj := &plumbing.MemoryObject{}
target.Encode(targetObj)
store.SetEncodedObject(targetObj)
tag := &Tag{
Target: targetObj.Hash(),
Name: "TAG TWO",
Message: "tag two",
TargetType: plumbing.TagObject,
}
tagObj := &plumbing.MemoryObject{}
tag.Encode(tagObj)
store.SetEncodedObject(tagObj)
tag, err := GetTag(store, tagObj.Hash())
c.Assert(err, IsNil)
c.Assert(tag.String(), Equals,
"tag TAG TWO\n"+
"Tagger: <>\n"+
"Date: Thu Jan 01 00:00:00 1970 +0000\n"+
"\n"+
"tag two\n")
}
func (s *TagSuite) TestLongTagNameSerialization(c *C) {
encoded := &plumbing.MemoryObject{}
decoded := &Tag{}
tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69"))
longName := "my tag: name " + strings.Repeat("test", 4096) + " OK"
tag.Name = longName
err := tag.Encode(encoded)
c.Assert(err, IsNil)
err = decoded.Decode(encoded)
c.Assert(err, IsNil)
c.Assert(decoded.Name, Equals, longName)
}
func (s *TagSuite) TestPGPSignatureSerialization(c *C) {
encoded := &plumbing.MemoryObject{}
decoded := &Tag{}
tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69"))
pgpsignature := `-----BEGIN PGP SIGNATURE-----
iQEcBAABAgAGBQJTZbQlAAoJEF0+sviABDDrZbQH/09PfE51KPVPlanr6q1v4/Ut
LQxfojUWiLQdg2ESJItkcuweYg+kc3HCyFejeDIBw9dpXt00rY26p05qrpnG+85b
hM1/PswpPLuBSr+oCIDj5GMC2r2iEKsfv2fJbNW8iWAXVLoWZRF8B0MfqX/YTMbm
ecorc4iXzQu7tupRihslbNkfvfciMnSDeSvzCpWAHl7h8Wj6hhqePmLm9lAYqnKp
8S5B/1SSQuEAjRZgI4IexpZoeKGVDptPHxLLS38fozsyi0QyDyzEgJxcJQVMXxVi
RUysgqjcpT8+iQM1PblGfHR4XAhuOqN5Fx06PSaFZhqvWFezJ28/CLyX5q+oIVk=
=EFTF
-----END PGP SIGNATURE-----
`
tag.PGPSignature = pgpsignature
err := tag.Encode(encoded)
c.Assert(err, IsNil)
err = decoded.Decode(encoded)
c.Assert(err, IsNil)
c.Assert(decoded.PGPSignature, Equals, pgpsignature)
}
func (s *TagSuite) TestSSHSignatureSerialization(c *C) {
encoded := &plumbing.MemoryObject{}
decoded := &Tag{}
tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69"))
signature := `-----BEGIN SSH SIGNATURE-----
U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgij/EfHS8tCjolj5uEANXgKzFfp
0D7wOhjWVbYZH6KugAAAADZ2l0AAAAAAAAAAZzaGE1MTIAAABTAAAAC3NzaC1lZDI1NTE5
AAAAQIYHMhSVV9L2xwJuV8eWMLjThya8yXgCHDzw3p01D19KirrabW0veiichPB5m+Ihtr
MKEQruIQWJb+8HVXwssA4=
-----END SSH SIGNATURE-----`
tag.PGPSignature = signature
err := tag.Encode(encoded)
c.Assert(err, IsNil)
err = decoded.Decode(encoded)
c.Assert(err, IsNil)
c.Assert(decoded.PGPSignature, Equals, signature)
}
func (s *TagSuite) TestVerify(c *C) {
ts := time.Unix(1617403017, 0)
loc, _ := time.LoadLocation("UTC")
tag := &Tag{
Name: "v0.2",
Tagger: Signature{Name: "go-git", Email: "go-git@example.com", When: ts.In(loc)},
Message: `This is a signed tag
`,
TargetType: plumbing.CommitObject,
Target: plumbing.NewHash("1eca38290a3131d0c90709496a9b2207a872631e"),
PGPSignature: `
-----BEGIN PGP SIGNATURE-----
iHUEABYKAB0WIQTMqU0ycQ3f6g3PMoWMmmmF4LuV8QUCYGeciQAKCRCMmmmF4LuV
8ZoDAP4j9msumYymfHgS3y7jpxPcSyiOMlXjipr2upspvXJ6ewD+K+OPC4pGW7Aq
8UDK8r6qhaloxATcV/LUrvAW2yz4PwM=
=PD+s
-----END PGP SIGNATURE-----
`,
}
armoredKeyRing := `
-----BEGIN PGP PUBLIC KEY BLOCK-----
mDMEYGeSihYJKwYBBAHaRw8BAQdAIs9A3YD/EghhAOkHDkxlUkpqYrXUXebLfmmX
+pdEK6C0D2dvLWdpdCB0ZXN0IGtleYiPBBMWCgA3FiEEzKlNMnEN3+oNzzKFjJpp
heC7lfEFAmBnkooCGyMECwkIBwUVCgkICwUWAwIBAAIeAQIXgAAKCRCMmmmF4LuV
8a3jAQCi4hSqjj6J3ch290FvQaYPGwR+EMQTMBG54t+NN6sDfgD/aZy41+0dnFKl
qM/wLW5Wr9XvwH+1zXXbuSvfxasHowq4OARgZ5KKEgorBgEEAZdVAQUBAQdAXoQz
VTYug16SisAoSrxFnOmxmFu6efYgCAwXu0ZuvzsDAQgHiHgEGBYKACAWIQTMqU0y
cQ3f6g3PMoWMmmmF4LuV8QUCYGeSigIbDAAKCRCMmmmF4LuV8Q4QAQCKW5FnEdWW
lHYKeByw3JugnlZ0U3V/R20bCwDglst5UQEAtkN2iZkHtkPly9xapsfNqnrt2gTt
YIefGtzXfldDxg4=
=Psht
-----END PGP PUBLIC KEY BLOCK-----
`
e, err := tag.Verify(armoredKeyRing)
c.Assert(err, IsNil)
_, ok := e.Identities["go-git test key"]
c.Assert(ok, Equals, true)
}
func (s *TagSuite) TestDecodeAndVerify(c *C) {
objectText := `object f6685df0aac4b5adf9eeb760e6d447145c5d0b56
type commit
tag v1.5
tagger Máximo Cuadros 1618566233 +0200
signed tag
-----BEGIN PGP SIGNATURE-----
iQGzBAABCAAdFiEE/h5sbbqJFh9j1AdUSqtFFGopTmwFAmB5XFkACgkQSqtFFGop
TmxvgAv+IPjX5WCLFUIMx8hquMZp1VkhQrseE7rljUYaYpga8gZ9s4kseTGhy7Un
61U3Ro6cTPEiQF/FkAGzSdPuGqv0ARBqHDX2tUI9+Zs/K8aG8tN+JTaof0gBcTyI
BLbZVYDTxbS9whxSDewQd0OvBG1m9ISLUhjXo6mbaVvrKXNXTHg40MPZ8ZxjR/vN
hxXXoUVnFyEDo+v6nK56mYtapThDaQQHHzD6D3VaCq3Msog7qAh9/ZNBmgb88aQ3
FoK8PHMyr5elsV3mE9bciZBUc+dtzjOvp94uQ5ZKUXaPusXaYXnKpVnzhyer6RBI
gJLWtPwAinqmN41rGJ8jDAGrpPNjaRrMhGtbyVUPUf19OxuUIroe77sIIKTP0X2o
Wgp56dYpTst0JcGv/FYCeau/4pTRDfwHAOcDiBQ/0ag9IrZp9P8P9zlKmzNPEraV
pAe1/EFuhv2UDLucAiWM8iDZIcw8iN0OYMOGUmnk0WuGIo7dzLeqMGY+ND5n5Z8J
sZC//k6m
=VhHy
-----END PGP SIGNATURE-----
`
armoredKeyRing := `
-----BEGIN PGP PUBLIC KEY BLOCK-----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=oYTT
-----END PGP PUBLIC KEY BLOCK-----
`
tagEncodedObject := &plumbing.MemoryObject{}
_, err := tagEncodedObject.Write([]byte(objectText))
tagEncodedObject.SetType(plumbing.TagObject)
c.Assert(err, IsNil)
tag := &Tag{}
err = tag.Decode(tagEncodedObject)
c.Assert(err, IsNil)
_, err = tag.Verify(armoredKeyRing)
c.Assert(err, IsNil)
}
func (s *TagSuite) TestEncodeWithoutSignature(c *C) {
//Similar to TestString since no signature
encoded := &plumbing.MemoryObject{}
tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69"))
err := tag.EncodeWithoutSignature(encoded)
c.Assert(err, IsNil)
er, err := encoded.Reader()
c.Assert(err, IsNil)
payload, err := io.ReadAll(er)
c.Assert(err, IsNil)
c.Assert(string(payload), Equals, ""+
"object f7b877701fbf855b44c0a9e86f3fdce2c298b07f\n"+
"type commit\n"+
"tag annotated-tag\n"+
"tagger Máximo Cuadros 1474485215 +0200\n"+
"\n"+
"example annotated tag\n",
)
}
go-git-5.13.2/plumbing/object/tree.go 0000664 0000000 0000000 00000031136 14744245500 0017352 0 ustar 00root root 0000000 0000000 package object
import (
"context"
"errors"
"fmt"
"io"
"path"
"path/filepath"
"sort"
"strings"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-git/v5/utils/sync"
)
const (
maxTreeDepth = 1024
startingStackSize = 8
)
// New errors defined by this package.
var (
ErrMaxTreeDepth = errors.New("maximum tree depth exceeded")
ErrFileNotFound = errors.New("file not found")
ErrDirectoryNotFound = errors.New("directory not found")
ErrEntryNotFound = errors.New("entry not found")
ErrEntriesNotSorted = errors.New("entries in tree are not sorted")
)
// Tree is basically like a directory - it references a bunch of other trees
// and/or blobs (i.e. files and sub-directories)
type Tree struct {
Entries []TreeEntry
Hash plumbing.Hash
s storer.EncodedObjectStorer
m map[string]*TreeEntry
t map[string]*Tree // tree path cache
}
// GetTree gets a tree from an object storer and decodes it.
func GetTree(s storer.EncodedObjectStorer, h plumbing.Hash) (*Tree, error) {
o, err := s.EncodedObject(plumbing.TreeObject, h)
if err != nil {
return nil, err
}
return DecodeTree(s, o)
}
// DecodeTree decodes an encoded object into a *Tree and associates it to the
// given object storer.
func DecodeTree(s storer.EncodedObjectStorer, o plumbing.EncodedObject) (*Tree, error) {
t := &Tree{s: s}
if err := t.Decode(o); err != nil {
return nil, err
}
return t, nil
}
// TreeEntry represents a file
type TreeEntry struct {
Name string
Mode filemode.FileMode
Hash plumbing.Hash
}
// File returns the hash of the file identified by the `path` argument.
// The path is interpreted as relative to the tree receiver.
func (t *Tree) File(path string) (*File, error) {
e, err := t.FindEntry(path)
if err != nil {
return nil, ErrFileNotFound
}
blob, err := GetBlob(t.s, e.Hash)
if err != nil {
if err == plumbing.ErrObjectNotFound {
return nil, ErrFileNotFound
}
return nil, err
}
return NewFile(path, e.Mode, blob), nil
}
// Size returns the plaintext size of an object, without reading it
// into memory.
func (t *Tree) Size(path string) (int64, error) {
e, err := t.FindEntry(path)
if err != nil {
return 0, ErrEntryNotFound
}
return t.s.EncodedObjectSize(e.Hash)
}
// Tree returns the tree identified by the `path` argument.
// The path is interpreted as relative to the tree receiver.
func (t *Tree) Tree(path string) (*Tree, error) {
e, err := t.FindEntry(path)
if err != nil {
return nil, ErrDirectoryNotFound
}
tree, err := GetTree(t.s, e.Hash)
if err == plumbing.ErrObjectNotFound {
return nil, ErrDirectoryNotFound
}
return tree, err
}
// TreeEntryFile returns the *File for a given *TreeEntry.
func (t *Tree) TreeEntryFile(e *TreeEntry) (*File, error) {
blob, err := GetBlob(t.s, e.Hash)
if err != nil {
return nil, err
}
return NewFile(e.Name, e.Mode, blob), nil
}
// FindEntry search a TreeEntry in this tree or any subtree.
func (t *Tree) FindEntry(path string) (*TreeEntry, error) {
if t.t == nil {
t.t = make(map[string]*Tree)
}
pathParts := strings.Split(path, "/")
startingTree := t
pathCurrent := ""
// search for the longest path in the tree path cache
for i := len(pathParts) - 1; i > 1; i-- {
path := filepath.Join(pathParts[:i]...)
tree, ok := t.t[path]
if ok {
startingTree = tree
pathParts = pathParts[i:]
pathCurrent = path
break
}
}
var tree *Tree
var err error
for tree = startingTree; len(pathParts) > 1; pathParts = pathParts[1:] {
if tree, err = tree.dir(pathParts[0]); err != nil {
return nil, err
}
pathCurrent = filepath.Join(pathCurrent, pathParts[0])
t.t[pathCurrent] = tree
}
return tree.entry(pathParts[0])
}
func (t *Tree) dir(baseName string) (*Tree, error) {
entry, err := t.entry(baseName)
if err != nil {
return nil, ErrDirectoryNotFound
}
obj, err := t.s.EncodedObject(plumbing.TreeObject, entry.Hash)
if err != nil {
return nil, err
}
tree := &Tree{s: t.s}
err = tree.Decode(obj)
return tree, err
}
func (t *Tree) entry(baseName string) (*TreeEntry, error) {
if t.m == nil {
t.buildMap()
}
entry, ok := t.m[baseName]
if !ok {
return nil, ErrEntryNotFound
}
return entry, nil
}
// Files returns a FileIter allowing to iterate over the Tree
func (t *Tree) Files() *FileIter {
return NewFileIter(t.s, t)
}
// ID returns the object ID of the tree. The returned value will always match
// the current value of Tree.Hash.
//
// ID is present to fulfill the Object interface.
func (t *Tree) ID() plumbing.Hash {
return t.Hash
}
// Type returns the type of object. It always returns plumbing.TreeObject.
func (t *Tree) Type() plumbing.ObjectType {
return plumbing.TreeObject
}
// Decode transform an plumbing.EncodedObject into a Tree struct
func (t *Tree) Decode(o plumbing.EncodedObject) (err error) {
if o.Type() != plumbing.TreeObject {
return ErrUnsupportedObject
}
t.Hash = o.Hash()
if o.Size() == 0 {
return nil
}
t.Entries = nil
t.m = nil
reader, err := o.Reader()
if err != nil {
return err
}
defer ioutil.CheckClose(reader, &err)
r := sync.GetBufioReader(reader)
defer sync.PutBufioReader(r)
for {
str, err := r.ReadString(' ')
if err != nil {
if err == io.EOF {
break
}
return err
}
str = str[:len(str)-1] // strip last byte (' ')
mode, err := filemode.New(str)
if err != nil {
return err
}
name, err := r.ReadString(0)
if err != nil && err != io.EOF {
return err
}
var hash plumbing.Hash
if _, err = io.ReadFull(r, hash[:]); err != nil {
return err
}
baseName := name[:len(name)-1]
t.Entries = append(t.Entries, TreeEntry{
Hash: hash,
Mode: mode,
Name: baseName,
})
}
return nil
}
type TreeEntrySorter []TreeEntry
func (s TreeEntrySorter) Len() int {
return len(s)
}
func (s TreeEntrySorter) Less(i, j int) bool {
name1 := s[i].Name
name2 := s[j].Name
if s[i].Mode == filemode.Dir {
name1 += "/"
}
if s[j].Mode == filemode.Dir {
name2 += "/"
}
return name1 < name2
}
func (s TreeEntrySorter) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
}
// Encode transforms a Tree into a plumbing.EncodedObject.
// The tree entries must be sorted by name.
func (t *Tree) Encode(o plumbing.EncodedObject) (err error) {
o.SetType(plumbing.TreeObject)
w, err := o.Writer()
if err != nil {
return err
}
defer ioutil.CheckClose(w, &err)
if !sort.IsSorted(TreeEntrySorter(t.Entries)) {
return ErrEntriesNotSorted
}
for _, entry := range t.Entries {
if strings.IndexByte(entry.Name, 0) != -1 {
return fmt.Errorf("malformed filename %q", entry.Name)
}
if _, err = fmt.Fprintf(w, "%o %s", entry.Mode, entry.Name); err != nil {
return err
}
if _, err = w.Write([]byte{0x00}); err != nil {
return err
}
if _, err = w.Write(entry.Hash[:]); err != nil {
return err
}
}
return err
}
func (t *Tree) buildMap() {
t.m = make(map[string]*TreeEntry)
for i := 0; i < len(t.Entries); i++ {
t.m[t.Entries[i].Name] = &t.Entries[i]
}
}
// Diff returns a list of changes between this tree and the provided one
func (t *Tree) Diff(to *Tree) (Changes, error) {
return t.DiffContext(context.Background(), to)
}
// DiffContext returns a list of changes between this tree and the provided one
// Error will be returned if context expires. Provided context must be non nil.
//
// NOTE: Since version 5.1.0 the renames are correctly handled, the settings
// used are the recommended options DefaultDiffTreeOptions.
func (t *Tree) DiffContext(ctx context.Context, to *Tree) (Changes, error) {
return DiffTreeWithOptions(ctx, t, to, DefaultDiffTreeOptions)
}
// Patch returns a slice of Patch objects with all the changes between trees
// in chunks. This representation can be used to create several diff outputs.
func (t *Tree) Patch(to *Tree) (*Patch, error) {
return t.PatchContext(context.Background(), to)
}
// PatchContext returns a slice of Patch objects with all the changes between
// trees in chunks. This representation can be used to create several diff
// outputs. If context expires, an error will be returned. Provided context must
// be non-nil.
//
// NOTE: Since version 5.1.0 the renames are correctly handled, the settings
// used are the recommended options DefaultDiffTreeOptions.
func (t *Tree) PatchContext(ctx context.Context, to *Tree) (*Patch, error) {
changes, err := t.DiffContext(ctx, to)
if err != nil {
return nil, err
}
return changes.PatchContext(ctx)
}
// treeEntryIter facilitates iterating through the TreeEntry objects in a Tree.
type treeEntryIter struct {
t *Tree
pos int
}
func (iter *treeEntryIter) Next() (TreeEntry, error) {
if iter.pos >= len(iter.t.Entries) {
return TreeEntry{}, io.EOF
}
iter.pos++
return iter.t.Entries[iter.pos-1], nil
}
// TreeWalker provides a means of walking through all of the entries in a Tree.
type TreeWalker struct {
stack []*treeEntryIter
base string
recursive bool
seen map[plumbing.Hash]bool
s storer.EncodedObjectStorer
t *Tree
}
// NewTreeWalker returns a new TreeWalker for the given tree.
//
// It is the caller's responsibility to call Close() when finished with the
// tree walker.
func NewTreeWalker(t *Tree, recursive bool, seen map[plumbing.Hash]bool) *TreeWalker {
stack := make([]*treeEntryIter, 0, startingStackSize)
stack = append(stack, &treeEntryIter{t, 0})
return &TreeWalker{
stack: stack,
recursive: recursive,
seen: seen,
s: t.s,
t: t,
}
}
// Next returns the next object from the tree. Objects are returned in order
// and subtrees are included. After the last object has been returned further
// calls to Next() will return io.EOF.
//
// In the current implementation any objects which cannot be found in the
// underlying repository will be skipped automatically. It is possible that this
// may change in future versions.
func (w *TreeWalker) Next() (name string, entry TreeEntry, err error) {
var obj *Tree
for {
current := len(w.stack) - 1
if current < 0 {
// Nothing left on the stack so we're finished
err = io.EOF
return
}
if current > maxTreeDepth {
// We're probably following bad data or some self-referencing tree
err = ErrMaxTreeDepth
return
}
entry, err = w.stack[current].Next()
if err == io.EOF {
// Finished with the current tree, move back up to the parent
w.stack = w.stack[:current]
w.base, _ = path.Split(w.base)
w.base = strings.TrimSuffix(w.base, "/")
continue
}
if err != nil {
return
}
if w.seen[entry.Hash] {
continue
}
if entry.Mode == filemode.Dir {
obj, err = GetTree(w.s, entry.Hash)
}
name = simpleJoin(w.base, entry.Name)
if err != nil {
err = io.EOF
return
}
break
}
if !w.recursive {
return
}
if obj != nil {
w.stack = append(w.stack, &treeEntryIter{obj, 0})
w.base = simpleJoin(w.base, entry.Name)
}
return
}
// Tree returns the tree that the tree walker most recently operated on.
func (w *TreeWalker) Tree() *Tree {
current := len(w.stack) - 1
if w.stack[current].pos == 0 {
current--
}
if current < 0 {
return nil
}
return w.stack[current].t
}
// Close releases any resources used by the TreeWalker.
func (w *TreeWalker) Close() {
w.stack = nil
}
// TreeIter provides an iterator for a set of trees.
type TreeIter struct {
storer.EncodedObjectIter
s storer.EncodedObjectStorer
}
// NewTreeIter takes a storer.EncodedObjectStorer and a
// storer.EncodedObjectIter and returns a *TreeIter that iterates over all
// tree contained in the storer.EncodedObjectIter.
//
// Any non-tree object returned by the storer.EncodedObjectIter is skipped.
func NewTreeIter(s storer.EncodedObjectStorer, iter storer.EncodedObjectIter) *TreeIter {
return &TreeIter{iter, s}
}
// Next moves the iterator to the next tree and returns a pointer to it. If
// there are no more trees, it returns io.EOF.
func (iter *TreeIter) Next() (*Tree, error) {
for {
obj, err := iter.EncodedObjectIter.Next()
if err != nil {
return nil, err
}
if obj.Type() != plumbing.TreeObject {
continue
}
return DecodeTree(iter.s, obj)
}
}
// ForEach call the cb function for each tree contained on this iter until
// an error happens or the end of the iter is reached. If ErrStop is sent
// the iteration is stop but no error is returned. The iterator is closed.
func (iter *TreeIter) ForEach(cb func(*Tree) error) error {
return iter.EncodedObjectIter.ForEach(func(obj plumbing.EncodedObject) error {
if obj.Type() != plumbing.TreeObject {
return nil
}
t, err := DecodeTree(iter.s, obj)
if err != nil {
return err
}
return cb(t)
})
}
func simpleJoin(parent, child string) string {
if len(parent) > 0 {
return parent + "/" + child
}
return child
}
go-git-5.13.2/plumbing/object/tree_test.go 0000664 0000000 0000000 00000226440 14744245500 0020415 0 ustar 00root root 0000000 0000000 package object
import (
"context"
"errors"
"io"
"sort"
"testing"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/filesystem"
. "gopkg.in/check.v1"
)
type TreeSuite struct {
BaseObjectsSuite
Tree *Tree
}
var _ = Suite(&TreeSuite{})
func (s *TreeSuite) SetUpSuite(c *C) {
s.BaseObjectsSuite.SetUpSuite(c)
hash := plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")
s.Tree = s.tree(c, hash)
}
func (s *TreeSuite) TestDecode(c *C) {
c.Assert(s.Tree.Entries, HasLen, 8)
c.Assert(s.Tree.Entries[0].Name, Equals, ".gitignore")
c.Assert(s.Tree.Entries[0].Hash.String(), Equals, "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88")
c.Assert(s.Tree.Entries[0].Mode, Equals, filemode.Regular)
c.Assert(s.Tree.Entries[4].Name, Equals, "go")
c.Assert(s.Tree.Entries[4].Hash.String(), Equals, "a39771a7651f97faf5c72e08224d857fc35133db")
c.Assert(s.Tree.Entries[4].Mode, Equals, filemode.Dir)
}
func (s *TreeSuite) TestDecodeNonTree(c *C) {
hash := plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492")
blob, err := s.Storer.EncodedObject(plumbing.BlobObject, hash)
c.Assert(err, IsNil)
tree := &Tree{}
err = tree.Decode(blob)
c.Assert(err, Equals, ErrUnsupportedObject)
}
func (s *TreeSuite) TestType(c *C) {
c.Assert(s.Tree.Type(), Equals, plumbing.TreeObject)
}
func (s *TreeSuite) TestTree(c *C) {
expectedEntry, ok := s.Tree.m["vendor"]
c.Assert(ok, Equals, true)
expected := expectedEntry.Hash
obtainedTree, err := s.Tree.Tree("vendor")
c.Assert(err, IsNil)
c.Assert(obtainedTree.Hash, Equals, expected)
}
func (s *TreeSuite) TestTreeNotFound(c *C) {
d, err := s.Tree.Tree("not-found")
c.Assert(d, IsNil)
c.Assert(err, Equals, ErrDirectoryNotFound)
}
func (s *TreeSuite) TestTreeFailsWithExistingFiles(c *C) {
_, err := s.Tree.File("LICENSE")
c.Assert(err, IsNil)
d, err := s.Tree.Tree("LICENSE")
c.Assert(d, IsNil)
c.Assert(err, Equals, ErrDirectoryNotFound)
}
func (s *TreeSuite) TestFile(c *C) {
f, err := s.Tree.File("LICENSE")
c.Assert(err, IsNil)
c.Assert(f.Name, Equals, "LICENSE")
}
func (s *TreeSuite) TestFileNotFound(c *C) {
f, err := s.Tree.File("not-found")
c.Assert(f, IsNil)
c.Assert(err, Equals, ErrFileNotFound)
}
func (s *TreeSuite) TestFileFailsWithExistingTrees(c *C) {
_, err := s.Tree.Tree("vendor")
c.Assert(err, IsNil)
f, err := s.Tree.File("vendor")
c.Assert(f, IsNil)
c.Assert(err, Equals, ErrFileNotFound)
}
func (s *TreeSuite) TestSize(c *C) {
size, err := s.Tree.Size("LICENSE")
c.Assert(err, IsNil)
c.Assert(size, Equals, int64(1072))
}
func (s *TreeSuite) TestFiles(c *C) {
var count int
err := s.Tree.Files().ForEach(func(f *File) error {
count++
return nil
})
c.Assert(err, IsNil)
c.Assert(count, Equals, 9)
}
func (s *TreeSuite) TestFindEntry(c *C) {
e, err := s.Tree.FindEntry("vendor/foo.go")
c.Assert(err, IsNil)
c.Assert(e.Name, Equals, "foo.go")
}
func (s *TreeSuite) TestFindEntryNotFound(c *C) {
e, err := s.Tree.FindEntry("not-found")
c.Assert(e, IsNil)
c.Assert(err, Equals, ErrEntryNotFound)
e, err = s.Tree.FindEntry("not-found/not-found/not-found")
c.Assert(e, IsNil)
c.Assert(err, Equals, ErrDirectoryNotFound)
}
// Overrides returned plumbing.EncodedObject for given hash.
// Otherwise, delegates to actual storer to get real object
type fakeStorer struct {
storer.EncodedObjectStorer
hash plumbing.Hash
fake fakeEncodedObject
}
func (fs fakeStorer) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (plumbing.EncodedObject, error) {
if fs.hash == h {
return fs.fake, nil
}
return fs.EncodedObjectStorer.EncodedObject(t, h)
}
// Overrides reader of plumbing.EncodedObject to simulate read error
type fakeEncodedObject struct{ plumbing.EncodedObject }
func (fe fakeEncodedObject) Reader() (io.ReadCloser, error) {
return nil, errors.New("Simulate encoded object can't be read")
}
func (s *TreeSuite) TestDir(c *C) {
vendor, err := s.Tree.dir("vendor")
c.Assert(err, IsNil)
t, err := GetTree(s.Tree.s, s.Tree.ID())
c.Assert(err, IsNil)
o, err := t.s.EncodedObject(plumbing.AnyObject, vendor.ID())
c.Assert(err, IsNil)
t.s = fakeStorer{t.s, vendor.ID(), fakeEncodedObject{o}}
_, err = t.dir("vendor")
c.Assert(err, NotNil)
}
// This plumbing.EncodedObject implementation has a reader that only returns 6
// bytes at a time, this should simulate the conditions when a read
// returns less bytes than asked, for example when reading a hash which
// is bigger than 6 bytes.
type SortReadObject struct {
t plumbing.ObjectType
h plumbing.Hash
cont []byte
sz int64
}
func (o *SortReadObject) Hash() plumbing.Hash { return o.h }
func (o *SortReadObject) Type() plumbing.ObjectType { return o.t }
func (o *SortReadObject) SetType(t plumbing.ObjectType) { o.t = t }
func (o *SortReadObject) Size() int64 { return o.sz }
func (o *SortReadObject) SetSize(s int64) { o.sz = s }
func (o *SortReadObject) Content() []byte { return o.cont }
func (o *SortReadObject) Reader() (io.ReadCloser, error) {
return &SortReadCloser{pos: 0, data: o.cont}, nil
}
func (o *SortReadObject) Writer() (io.WriteCloser, error) { return o, nil }
func (o *SortReadObject) Write(p []byte) (n int, err error) { return len(p), nil }
func (o *SortReadObject) Close() error { return nil }
// a ReadCloser that only returns 6 bytes at a time, to simulate incomplete reads.
type SortReadCloser struct {
pos int
data []byte
}
func (o *SortReadCloser) Close() error { return nil }
func (o *SortReadCloser) Read(p []byte) (int, error) {
if o.pos == len(o.data) {
return 0, io.EOF
}
sz := len(p)
remaining := len(o.data) - o.pos
if sz > 6 { // don't read more than 6 bytes at a time
sz = 6
}
if sz > remaining {
sz = remaining
}
src := o.data[o.pos : o.pos+sz]
nw := copy(p, src)
o.pos += nw
return nw, nil
}
func (s *TreeSuite) TestTreeEntriesSorted(c *C) {
tree := &Tree{
Entries: []TreeEntry{
{"foo", filemode.Empty, plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d")},
{"bar", filemode.Empty, plumbing.NewHash("c029517f6300c2da0f4b651b8642506cd6aaf45d")},
{"baz", filemode.Empty, plumbing.NewHash("d029517f6300c2da0f4b651b8642506cd6aaf45d")},
},
}
{
c.Assert(sort.IsSorted(TreeEntrySorter(tree.Entries)), Equals, false)
obj := &plumbing.MemoryObject{}
err := tree.Encode(obj)
c.Assert(err, Equals, ErrEntriesNotSorted)
}
{
sort.Sort(TreeEntrySorter(tree.Entries))
obj := &plumbing.MemoryObject{}
err := tree.Encode(obj)
c.Assert(err, IsNil)
}
}
func (s *TreeSuite) TestTreeDecodeEncodeIdempotent(c *C) {
trees := []*Tree{
{
Entries: []TreeEntry{
{"foo", filemode.Empty, plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d")},
{"bar", filemode.Empty, plumbing.NewHash("c029517f6300c2da0f4b651b8642506cd6aaf45d")},
{"baz", filemode.Empty, plumbing.NewHash("d029517f6300c2da0f4b651b8642506cd6aaf45d")},
},
},
}
for _, tree := range trees {
sort.Sort(TreeEntrySorter(tree.Entries))
obj := &plumbing.MemoryObject{}
err := tree.Encode(obj)
c.Assert(err, IsNil)
newTree := &Tree{}
err = newTree.Decode(obj)
c.Assert(err, IsNil)
tree.Hash = obj.Hash()
c.Assert(newTree, DeepEquals, tree)
}
}
func (s *TreeSuite) TestTreeDiff(c *C) {
f := fixtures.ByURL("https://github.com/src-d/go-git.git").One()
storer := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
commit, err := GetCommit(storer, plumbing.NewHash("89f8bda31d29767a6d6ba8f9d0dfb941d598e843"))
c.Assert(err, IsNil)
tree, err := commit.Tree()
c.Assert(err, IsNil)
parentCommit, err := commit.Parent(0)
c.Assert(err, IsNil)
parentTree, err := parentCommit.Tree()
c.Assert(err, IsNil)
ch, err := parentTree.Diff(tree)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 3)
c.Assert(ch[0].From.Name, Equals, "examples/object_storage/main.go")
c.Assert(ch[0].To.Name, Equals, "examples/storage/main.go")
ch, err = parentTree.DiffContext(context.Background(), tree)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 3)
}
func (s *TreeSuite) TestTreeIter(c *C) {
encIter, err := s.Storer.IterEncodedObjects(plumbing.TreeObject)
c.Assert(err, IsNil)
iter := NewTreeIter(s.Storer, encIter)
trees := []*Tree{}
iter.ForEach(func(t *Tree) error {
t.s = nil
trees = append(trees, t)
return nil
})
c.Assert(len(trees) > 0, Equals, true)
iter.Close()
encIter, err = s.Storer.IterEncodedObjects(plumbing.TreeObject)
c.Assert(err, IsNil)
iter = NewTreeIter(s.Storer, encIter)
i := 0
for {
t, err := iter.Next()
if err == io.EOF {
break
}
t.s = nil
c.Assert(err, IsNil)
c.Assert(t, DeepEquals, trees[i])
i += 1
}
iter.Close()
}
func (s *TreeSuite) TestTreeWalkerNext(c *C) {
commit, err := GetCommit(s.Storer, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
c.Assert(err, IsNil)
tree, err := commit.Tree()
c.Assert(err, IsNil)
walker := NewTreeWalker(tree, true, nil)
for _, e := range treeWalkerExpects {
name, entry, err := walker.Next()
if err == io.EOF {
break
}
c.Assert(err, IsNil)
c.Assert(name, Equals, e.Path)
c.Assert(entry.Name, Equals, e.Name)
c.Assert(entry.Mode, Equals, e.Mode)
c.Assert(entry.Hash.String(), Equals, e.Hash)
c.Assert(walker.Tree().ID().String(), Equals, e.Tree)
}
}
func (s *TreeSuite) TestTreeWalkerNextSkipSeen(c *C) {
commit, err := GetCommit(s.Storer, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
c.Assert(err, IsNil)
tree, err := commit.Tree()
c.Assert(err, IsNil)
seen := map[plumbing.Hash]bool{
plumbing.NewHash(treeWalkerExpects[0].Hash): true,
}
walker := NewTreeWalker(tree, true, seen)
for _, e := range treeWalkerExpects[1:] {
name, entry, err := walker.Next()
if err == io.EOF {
break
}
c.Assert(err, IsNil)
c.Assert(name, Equals, e.Path)
c.Assert(entry.Name, Equals, e.Name)
c.Assert(entry.Mode, Equals, e.Mode)
c.Assert(entry.Hash.String(), Equals, e.Hash)
c.Assert(walker.Tree().ID().String(), Equals, e.Tree)
}
}
func (s *TreeSuite) TestTreeWalkerNextNonRecursive(c *C) {
commit := s.commit(c, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
tree, err := commit.Tree()
c.Assert(err, IsNil)
var count int
walker := NewTreeWalker(tree, false, nil)
for {
name, entry, err := walker.Next()
if err == io.EOF {
break
}
c.Assert(err, IsNil)
c.Assert(name, Not(Equals), "")
c.Assert(entry, NotNil)
c.Assert(walker.Tree().ID().String(), Equals, "a8d315b2b1c615d43042c3a62402b8a54288cf5c")
count++
}
c.Assert(count, Equals, 8)
}
func (s *TreeSuite) TestPatchContext_ToNil(c *C) {
commit := s.commit(c, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
tree, err := commit.Tree()
c.Assert(err, IsNil)
patch, err := tree.PatchContext(context.Background(), nil)
c.Assert(err, IsNil)
c.Assert(len(patch.String()), Equals, 242971)
}
func (s *TreeSuite) TestTreeWalkerNextSubmodule(c *C) {
dotgit := fixtures.ByURL("https://github.com/git-fixtures/submodule.git").One().DotGit()
st := filesystem.NewStorage(dotgit, cache.NewObjectLRUDefault())
hash := plumbing.NewHash("b685400c1f9316f350965a5993d350bc746b0bf4")
commit, err := GetCommit(st, hash)
c.Assert(err, IsNil)
tree, err := commit.Tree()
c.Assert(err, IsNil)
expected := []string{
".gitmodules",
"README.md",
"basic",
"itself",
}
var count int
walker := NewTreeWalker(tree, true, nil)
defer walker.Close()
for {
name, entry, err := walker.Next()
if err == io.EOF {
break
}
c.Assert(err, IsNil)
c.Assert(entry, NotNil)
c.Assert(name, Equals, expected[count])
count++
}
c.Assert(count, Equals, 4)
}
var treeWalkerExpects = []struct {
Path string
Mode filemode.FileMode
Name, Hash, Tree string
}{{
Path: ".gitignore", Mode: filemode.Regular, Name: ".gitignore",
Hash: "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88", Tree: "a8d315b2b1c615d43042c3a62402b8a54288cf5c",
}, {
Path: "CHANGELOG", Mode: filemode.Regular, Name: "CHANGELOG",
Hash: "d3ff53e0564a9f87d8e84b6e28e5060e517008aa", Tree: "a8d315b2b1c615d43042c3a62402b8a54288cf5c",
}, {
Path: "LICENSE", Mode: filemode.Regular, Name: "LICENSE",
Hash: "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f", Tree: "a8d315b2b1c615d43042c3a62402b8a54288cf5c",
}, {
Path: "binary.jpg", Mode: filemode.Regular, Name: "binary.jpg",
Hash: "d5c0f4ab811897cadf03aec358ae60d21f91c50d", Tree: "a8d315b2b1c615d43042c3a62402b8a54288cf5c",
}, {
Path: "go", Mode: filemode.Dir, Name: "go",
Hash: "a39771a7651f97faf5c72e08224d857fc35133db", Tree: "a8d315b2b1c615d43042c3a62402b8a54288cf5c",
}, {
Path: "go/example.go", Mode: filemode.Regular, Name: "example.go",
Hash: "880cd14280f4b9b6ed3986d6671f907d7cc2a198", Tree: "a39771a7651f97faf5c72e08224d857fc35133db",
}, {
Path: "json", Mode: filemode.Dir, Name: "json",
Hash: "5a877e6a906a2743ad6e45d99c1793642aaf8eda", Tree: "a8d315b2b1c615d43042c3a62402b8a54288cf5c",
}, {
Path: "json/long.json", Mode: filemode.Regular, Name: "long.json",
Hash: "49c6bb89b17060d7b4deacb7b338fcc6ea2352a9", Tree: "5a877e6a906a2743ad6e45d99c1793642aaf8eda",
}, {
Path: "json/short.json", Mode: filemode.Regular, Name: "short.json",
Hash: "c8f1d8c61f9da76f4cb49fd86322b6e685dba956", Tree: "5a877e6a906a2743ad6e45d99c1793642aaf8eda",
}, {
Path: "php", Mode: filemode.Dir, Name: "php",
Hash: "586af567d0bb5e771e49bdd9434f5e0fb76d25fa", Tree: "a8d315b2b1c615d43042c3a62402b8a54288cf5c",
}, {
Path: "php/crappy.php", Mode: filemode.Regular, Name: "crappy.php",
Hash: "9a48f23120e880dfbe41f7c9b7b708e9ee62a492", Tree: "586af567d0bb5e771e49bdd9434f5e0fb76d25fa",
}, {
Path: "vendor", Mode: filemode.Dir, Name: "vendor",
Hash: "cf4aa3b38974fb7d81f367c0830f7d78d65ab86b", Tree: "a8d315b2b1c615d43042c3a62402b8a54288cf5c",
}, {
Path: "vendor/foo.go", Mode: filemode.Regular, Name: "foo.go",
Hash: "9dea2395f5403188298c1dabe8bdafe562c491e3", Tree: "cf4aa3b38974fb7d81f367c0830f7d78d65ab86b",
}}
func entriesEquals(a, b []TreeEntry) bool {
if a == nil && b == nil {
return true
}
if a == nil || b == nil {
return false
}
if len(a) != len(b) {
return false
}
for i, v := range a {
if v != b[i] {
return false
}
}
return true
}
// When decoding a tree we were not checking the return value of read
// when reading hashes. As a hash is quite small, it worked well nearly
// all the time.
//
// I have found some examples of repos where the read is incomplete and
// the tree decode fails, for example
// http://github.com/sqlcipher/sqlcipher.git, object
// 0ba19d22411289293ab5c012891529967d7c933e.
//
// This tests is performed with that object but using a SortReadObject to
// simulate incomplete reads on all platforms and operating systems.
func (s *TreeSuite) TestTreeDecodeReadBug(c *C) {
cont := []byte{
0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x61, 0x6c, 0x74,
0x65, 0x72, 0x2e, 0x63, 0x0, 0xa4, 0x9d, 0x33, 0x49, 0xd7,
0xe2, 0x3f, 0xb5, 0x81, 0x19, 0x4f, 0x4c, 0xb5, 0x9a, 0xc0,
0xd5, 0x1b, 0x2, 0x1f, 0x78, 0x31, 0x30, 0x30, 0x36, 0x34,
0x34, 0x20, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x2e,
0x63, 0x0, 0x9a, 0x3e, 0x95, 0x97, 0xdb, 0xb, 0x3, 0x20,
0x77, 0xc9, 0x1d, 0x96, 0x9d, 0x22, 0xc6, 0x27, 0x3f, 0x70,
0x2a, 0xc, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x61,
0x74, 0x74, 0x61, 0x63, 0x68, 0x2e, 0x63, 0x0, 0xb8, 0xe1,
0x21, 0x99, 0xb5, 0x7d, 0xe8, 0x11, 0xea, 0xe0, 0xd0, 0x61,
0x42, 0xd5, 0xac, 0x4f, 0xd4, 0x30, 0xb1, 0xd8, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x61, 0x75, 0x74, 0x68, 0x2e,
0x63, 0x0, 0xd3, 0x8b, 0xb8, 0x36, 0xa7, 0x84, 0xfb, 0xfa,
0xb6, 0xab, 0x7b, 0x3, 0xd4, 0xe6, 0xdd, 0x43, 0xed, 0xc4,
0x1f, 0xa7, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x62,
0x61, 0x63, 0x6b, 0x75, 0x70, 0x2e, 0x63, 0x0, 0x25, 0x2f,
0x61, 0xcf, 0xca, 0xa8, 0xfc, 0xf3, 0x13, 0x7e, 0x8, 0xed,
0x68, 0x47, 0xdc, 0xfe, 0x1d, 0xc1, 0xde, 0x54, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x62, 0x69, 0x74, 0x76, 0x65,
0x63, 0x2e, 0x63, 0x0, 0x52, 0x18, 0x4a, 0xa9, 0x64, 0xce,
0x18, 0x98, 0xf3, 0x5d, 0x1b, 0x3d, 0x87, 0x87, 0x1c, 0x2d,
0xe, 0xf4, 0xc5, 0x3d, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34,
0x20, 0x62, 0x74, 0x6d, 0x75, 0x74, 0x65, 0x78, 0x2e, 0x63,
0x0, 0xd8, 0x7d, 0x4d, 0x5f, 0xee, 0xb6, 0x30, 0x7a, 0xec,
0xdc, 0x9a, 0x83, 0x11, 0x14, 0x89, 0xab, 0x30, 0xc6, 0x78,
0xc3, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x62, 0x74,
0x72, 0x65, 0x65, 0x2e, 0x63, 0x0, 0x3c, 0xa6, 0x5, 0x83,
0xe3, 0xc8, 0xe3, 0x12, 0x0, 0xf9, 0x73, 0xe0, 0xe9, 0xc4,
0x53, 0x62, 0x58, 0xb2, 0x64, 0x39, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x62, 0x74, 0x72, 0x65, 0x65, 0x2e, 0x68,
0x0, 0xac, 0xe0, 0xf8, 0xcd, 0x21, 0x77, 0x70, 0xa2, 0xf6,
0x6b, 0x2e, 0xb8, 0x71, 0xbb, 0xc5, 0xfd, 0xc6, 0xfc, 0x2b,
0x68, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x62, 0x74,
0x72, 0x65, 0x65, 0x49, 0x6e, 0x74, 0x2e, 0x68, 0x0, 0xce,
0x3c, 0x54, 0x93, 0xf8, 0xca, 0xd0, 0xbc, 0x54, 0x8a, 0xe8,
0xe4, 0x4e, 0x51, 0x28, 0x31, 0xd8, 0xfa, 0xc4, 0x31, 0x31,
0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x62, 0x75, 0x69, 0x6c,
0x64, 0x2e, 0x63, 0x0, 0x3c, 0x91, 0xcd, 0xcf, 0xdb, 0x7b,
0x1, 0x7c, 0xbc, 0x2d, 0x5c, 0x29, 0x57, 0x1a, 0x98, 0x27,
0xd, 0xe0, 0x71, 0xe6, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34,
0x20, 0x63, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x2e,
0x63, 0x0, 0xd4, 0xc, 0x65, 0xcb, 0x92, 0x45, 0x80, 0x29,
0x6a, 0xd0, 0x69, 0xa0, 0x4b, 0xf9, 0xc9, 0xe9, 0x53, 0x4e,
0xca, 0xa7, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x63,
0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x2e, 0x63, 0x0,
0x9e, 0x91, 0x40, 0x8, 0x5c, 0x0, 0x46, 0xed, 0x3b, 0xf6,
0xf4, 0x48, 0x52, 0x20, 0x69, 0x2d, 0xca, 0x17, 0x43, 0xc5,
0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x63, 0x72, 0x79,
0x70, 0x74, 0x6f, 0x2e, 0x63, 0x0, 0x25, 0x51, 0xe6, 0xba,
0x2, 0x39, 0xf8, 0x5a, 0x35, 0x77, 0x96, 0xa8, 0xdd, 0xa8,
0xca, 0x3e, 0x29, 0x70, 0x93, 0xf8, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2e,
0x68, 0x0, 0xf7, 0x1f, 0x53, 0x2c, 0xdc, 0x44, 0x8f, 0xa,
0x1d, 0xd5, 0xc6, 0xef, 0xf5, 0xfb, 0xd3, 0x3a, 0x91, 0x55,
0xaa, 0x97, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x63,
0x72, 0x79, 0x70, 0x74, 0x6f, 0x5f, 0x63, 0x63, 0x2e, 0x63,
0x0, 0x53, 0x7d, 0xf7, 0xe3, 0xb3, 0x6a, 0xb5, 0xcf, 0xdd,
0x6f, 0xca, 0x40, 0x28, 0xeb, 0xca, 0xe1, 0x86, 0x87, 0xd6,
0x4d, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x63, 0x72,
0x79, 0x70, 0x74, 0x6f, 0x5f, 0x69, 0x6d, 0x70, 0x6c, 0x2e,
0x63, 0x0, 0xa5, 0x89, 0x27, 0xc7, 0x6e, 0xf6, 0x20, 0x56,
0x77, 0xbe, 0x5c, 0x1a, 0x8e, 0x80, 0xc9, 0x83, 0x56, 0xb3,
0xa9, 0xd3, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x63,
0x72, 0x79, 0x70, 0x74, 0x6f, 0x5f, 0x6c, 0x69, 0x62, 0x74,
0x6f, 0x6d, 0x63, 0x72, 0x79, 0x70, 0x74, 0x2e, 0x63, 0x0,
0x1a, 0x33, 0x83, 0xe0, 0x1, 0xa7, 0x21, 0x11, 0xc3, 0xf6,
0x61, 0x92, 0x22, 0xb0, 0x65, 0xf4, 0xbd, 0x1, 0xb, 0xe1,
0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x63, 0x72, 0x79,
0x70, 0x74, 0x6f, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x73,
0x6c, 0x2e, 0x63, 0x0, 0xd0, 0x19, 0x81, 0x3b, 0x47, 0x6c,
0x52, 0xd0, 0x20, 0xe2, 0xc0, 0xac, 0xd5, 0x24, 0xe9, 0xea,
0x3d, 0xf, 0xb9, 0xfe, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34,
0x20, 0x63, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x63, 0x0, 0x60,
0x59, 0x5f, 0xf8, 0x8d, 0x92, 0xf7, 0x8, 0x26, 0x4, 0xfb,
0xd9, 0xdf, 0x9a, 0xfe, 0xa1, 0x6a, 0xe8, 0x6f, 0xf, 0x31,
0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x64, 0x61, 0x74, 0x65,
0x2e, 0x63, 0x0, 0x75, 0x8d, 0xd7, 0xc8, 0x9b, 0xca, 0x39,
0x37, 0xa9, 0xd, 0x70, 0x6e, 0xa9, 0x82, 0xce, 0x3a, 0xcf,
0x11, 0xd1, 0x83, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x2e, 0x63, 0x0, 0x63,
0x4e, 0x11, 0x55, 0x63, 0xae, 0x12, 0xba, 0x65, 0x58, 0xcc,
0xc5, 0x12, 0xae, 0xd6, 0x31, 0xc0, 0x66, 0xba, 0xd8, 0x31,
0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x65, 0x78, 0x70, 0x72,
0x2e, 0x63, 0x0, 0x66, 0x3, 0x97, 0xe0, 0x78, 0xae, 0x48,
0xb2, 0xe7, 0x17, 0x5e, 0x33, 0x85, 0x67, 0x78, 0x19, 0x72,
0x2d, 0xdd, 0x6c, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x66, 0x61, 0x75, 0x6c, 0x74, 0x2e, 0x63, 0x0, 0xc3, 0x2,
0x8c, 0x4f, 0x93, 0x6e, 0xdf, 0x96, 0x71, 0x2d, 0xbe, 0x73,
0xa0, 0x76, 0x62, 0xf0, 0xa2, 0x6b, 0x1d, 0xa, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x66, 0x6b, 0x65, 0x79, 0x2e,
0x63, 0x0, 0xac, 0x35, 0xbc, 0x19, 0x4c, 0xde, 0xb1, 0x27,
0x98, 0x9b, 0x9, 0x40, 0x35, 0xce, 0xe0, 0x6f, 0x57, 0x37,
0x6f, 0x5e, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x66,
0x75, 0x6e, 0x63, 0x2e, 0x63, 0x0, 0xc0, 0x2f, 0x9, 0x6a,
0xda, 0xd5, 0xbc, 0xe9, 0xac, 0x83, 0xd3, 0x5f, 0xf, 0x46,
0x9, 0xd6, 0xf6, 0xd4, 0x3b, 0xe5, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x2e,
0x63, 0x0, 0x7b, 0x2, 0xcf, 0x21, 0x30, 0xe0, 0xd1, 0xa7,
0xb8, 0x89, 0xd8, 0x44, 0xc, 0xcc, 0x82, 0x8, 0xf7, 0xb6,
0x7b, 0xf9, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x68,
0x61, 0x73, 0x68, 0x2e, 0x63, 0x0, 0xe8, 0x1d, 0xcf, 0x95,
0xe4, 0x38, 0x48, 0xfa, 0x70, 0x86, 0xb7, 0xf7, 0x81, 0xc0,
0x90, 0xad, 0xc7, 0xe6, 0xca, 0x8e, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x68, 0x61, 0x73, 0x68, 0x2e, 0x68, 0x0,
0x82, 0xb7, 0xc5, 0x8c, 0x71, 0x9, 0xb, 0x54, 0x7e, 0x10,
0x17, 0x42, 0xaa, 0x9, 0x51, 0x73, 0x9f, 0xf2, 0xee, 0xe7,
0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x68, 0x77, 0x74,
0x69, 0x6d, 0x65, 0x2e, 0x68, 0x0, 0xb8, 0xbc, 0x5a, 0x29,
0x5b, 0xe3, 0xfa, 0xc8, 0x35, 0x1f, 0xa9, 0xf0, 0x8a, 0x77,
0x57, 0x9d, 0x59, 0xc9, 0xa8, 0xe4, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x2e,
0x63, 0x0, 0x9a, 0x56, 0x61, 0xf5, 0x9a, 0x72, 0x95, 0x2b,
0xe6, 0xc1, 0x67, 0xa0, 0xc2, 0xdb, 0x15, 0x9b, 0x91, 0xb7,
0x1f, 0xae, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x6a,
0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x63, 0x0, 0xfe,
0xd2, 0x7b, 0xe3, 0xe3, 0x80, 0x55, 0xd2, 0x20, 0x43, 0x95,
0xcd, 0xe6, 0xff, 0xc9, 0x45, 0x89, 0xfb, 0xf5, 0xe8, 0x31,
0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x6c, 0x65, 0x67, 0x61,
0x63, 0x79, 0x2e, 0x63, 0x0, 0x94, 0x64, 0x9a, 0xe7, 0x5,
0xab, 0x93, 0x85, 0x10, 0x8d, 0xd, 0x88, 0x7a, 0xf0, 0x75,
0x92, 0x89, 0xfb, 0x23, 0xcb, 0x31, 0x30, 0x30, 0x36, 0x34,
0x34, 0x20, 0x6c, 0x65, 0x6d, 0x70, 0x61, 0x72, 0x2e, 0x63,
0x0, 0x2a, 0xfa, 0xa6, 0xce, 0xa6, 0xd8, 0x29, 0x60, 0x2c,
0x27, 0x86, 0xc1, 0xf8, 0xa3, 0x7f, 0x56, 0x7c, 0xf6, 0xfd,
0x53, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x6c, 0x6f,
0x61, 0x64, 0x65, 0x78, 0x74, 0x2e, 0x63, 0x0, 0xcd, 0xcf,
0x6a, 0x93, 0xb8, 0xc4, 0xf, 0x91, 0x4b, 0x94, 0x24, 0xe,
0xf1, 0x4c, 0xb4, 0xa3, 0xa, 0x37, 0xec, 0xa1, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x2e,
0x63, 0x0, 0x39, 0xf6, 0x4, 0x21, 0xe6, 0x81, 0x27, 0x7c,
0xc3, 0xdb, 0xa0, 0x9a, 0xbe, 0x7c, 0xf7, 0x90, 0xd5, 0x28,
0xf5, 0xc3, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x6d,
0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x2e, 0x63, 0x0, 0x35, 0xa4,
0x4e, 0x5f, 0x61, 0xc2, 0xe4, 0x4c, 0x48, 0x1c, 0x62, 0x51,
0xbd, 0xa, 0xae, 0x7a, 0xcd, 0xa4, 0xde, 0xb, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x6d, 0x65, 0x6d, 0x30, 0x2e,
0x63, 0x0, 0xd, 0xb, 0x66, 0x67, 0xd6, 0xa, 0x95, 0x5a,
0x6, 0x96, 0xdf, 0x62, 0x89, 0xb4, 0x91, 0x78, 0x96, 0x93,
0x43, 0xaa, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x6d,
0x65, 0x6d, 0x31, 0x2e, 0x63, 0x0, 0x35, 0x78, 0x49, 0x6f,
0x33, 0x3, 0x7, 0xb2, 0x31, 0xdf, 0xb5, 0x3c, 0xc, 0x2e,
0x1c, 0x6b, 0x32, 0x3d, 0x79, 0x1e, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x6d, 0x65, 0x6d, 0x32, 0x2e, 0x63, 0x0,
0x26, 0x44, 0x8e, 0xa8, 0xaa, 0xe0, 0x36, 0x6a, 0xf0, 0x54,
0x1a, 0xfe, 0xa4, 0x79, 0xb, 0x42, 0xf4, 0xa6, 0x9b, 0x5a,
0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x6d, 0x65, 0x6d,
0x33, 0x2e, 0x63, 0x0, 0x1a, 0x1b, 0x79, 0x1f, 0x28, 0xf8,
0xcf, 0x3c, 0xe4, 0xf9, 0xa3, 0x5c, 0xda, 0xd7, 0xb7, 0x10,
0x75, 0x68, 0xc7, 0x15, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34,
0x20, 0x6d, 0x65, 0x6d, 0x35, 0x2e, 0x63, 0x0, 0x78, 0x3c,
0xef, 0x61, 0x76, 0xc5, 0x9c, 0xbf, 0x30, 0x91, 0x46, 0x31,
0x9, 0x5a, 0x1a, 0x54, 0xf4, 0xe4, 0x2e, 0x8, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x6d, 0x65, 0x6d, 0x6a, 0x6f,
0x75, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x63, 0x0, 0x5, 0x72,
0x59, 0x48, 0xf6, 0x5d, 0x42, 0x7b, 0x7, 0xf7, 0xf9, 0x29,
0xac, 0xa3, 0xff, 0x22, 0x4b, 0x17, 0x53, 0xdf, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x6d, 0x75, 0x74, 0x65, 0x78,
0x2e, 0x63, 0x0, 0xb5, 0x67, 0xe7, 0xc2, 0x7e, 0xf2, 0x4,
0x10, 0x86, 0xaf, 0xe0, 0xf6, 0x96, 0x66, 0xe2, 0x7b, 0xf5,
0x9, 0x8a, 0x59, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x6d, 0x75, 0x74, 0x65, 0x78, 0x2e, 0x68, 0x0, 0x9, 0x78,
0x81, 0x22, 0x52, 0x77, 0x89, 0xa, 0x9c, 0x36, 0xc2, 0x4d,
0x41, 0xf6, 0x11, 0x4d, 0x64, 0xc0, 0x6d, 0xb3, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x6d, 0x75, 0x74, 0x65, 0x78,
0x5f, 0x6e, 0x6f, 0x6f, 0x70, 0x2e, 0x63, 0x0, 0x45, 0x6e,
0x82, 0xa2, 0x5e, 0x27, 0x1b, 0x6, 0x14, 0xe7, 0xf4, 0xf8,
0x3c, 0x22, 0x85, 0x53, 0xb7, 0xfa, 0x1, 0x58, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x6d, 0x75, 0x74, 0x65, 0x78,
0x5f, 0x75, 0x6e, 0x69, 0x78, 0x2e, 0x63, 0x0, 0xec, 0xa7,
0x29, 0x58, 0x31, 0xc2, 0xf0, 0xee, 0x48, 0xba, 0x54, 0xd0,
0x62, 0x91, 0x4d, 0x6, 0xa1, 0xdd, 0x8e, 0xbe, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x6d, 0x75, 0x74, 0x65, 0x78,
0x5f, 0x77, 0x33, 0x32, 0x2e, 0x63, 0x0, 0x27, 0xd1, 0xa,
0xf5, 0xbd, 0x33, 0x1b, 0xdb, 0x97, 0x3f, 0x61, 0x45, 0xb7,
0x4f, 0x72, 0xb6, 0x7, 0xcf, 0xc4, 0x6e, 0x31, 0x30, 0x30,
0x36, 0x34, 0x34, 0x20, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x79,
0x2e, 0x63, 0x0, 0xfc, 0xab, 0x5b, 0xfa, 0xf0, 0x19, 0x8,
0xd3, 0xde, 0x93, 0xfa, 0x88, 0xb5, 0xea, 0xe9, 0xe9, 0x6c,
0xa3, 0xc8, 0xe8, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x6f, 0x73, 0x2e, 0x63, 0x0, 0xbe, 0x2e, 0xa4, 0xcf, 0xc0,
0x19, 0x59, 0x93, 0xa3, 0x40, 0xc9, 0x2, 0xae, 0xdd, 0xf1,
0xbe, 0x4b, 0x8e, 0xd7, 0x3a, 0x31, 0x30, 0x30, 0x36, 0x34,
0x34, 0x20, 0x6f, 0x73, 0x2e, 0x68, 0x0, 0x7, 0xa, 0x2d,
0xdd, 0x17, 0xf7, 0x71, 0xf9, 0x8f, 0xf8, 0xcc, 0xd6, 0xf0,
0x33, 0xbd, 0xac, 0xc5, 0xe9, 0xf6, 0xc, 0x31, 0x30, 0x30,
0x36, 0x34, 0x34, 0x20, 0x6f, 0x73, 0x5f, 0x63, 0x6f, 0x6d,
0x6d, 0x6f, 0x6e, 0x2e, 0x68, 0x0, 0xf6, 0xc3, 0xe7, 0xff,
0x89, 0x46, 0x30, 0x86, 0x40, 0x18, 0x22, 0xf4, 0x81, 0xe7,
0xe3, 0xb8, 0x7b, 0x2c, 0x78, 0xc7, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x6f, 0x73, 0x5f, 0x75, 0x6e, 0x69, 0x78,
0x2e, 0x63, 0x0, 0xab, 0xc2, 0x3a, 0x45, 0x2e, 0x72, 0xf7,
0x1c, 0x76, 0xaf, 0xa9, 0x98, 0x3c, 0x3a, 0xd9, 0xd4, 0x25,
0x61, 0x6c, 0x6d, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x6f, 0x73, 0x5f, 0x77, 0x69, 0x6e, 0x2e, 0x63, 0x0, 0xae,
0xb0, 0x88, 0x14, 0xb3, 0xda, 0xbe, 0x81, 0xb8, 0x4c, 0xda,
0x91, 0x85, 0x82, 0xb0, 0xf, 0xfd, 0x86, 0xe4, 0x87, 0x31,
0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x70, 0x61, 0x67, 0x65,
0x72, 0x2e, 0x63, 0x0, 0x61, 0x72, 0x7f, 0xaa, 0x9c, 0xf,
0x3d, 0x56, 0x62, 0x65, 0xbe, 0x7e, 0xec, 0x5b, 0x2a, 0x35,
0xf6, 0xa4, 0xbc, 0x9f, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34,
0x20, 0x70, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x68, 0x0, 0x6f,
0x65, 0x91, 0x36, 0xe2, 0x76, 0x7, 0x9d, 0xa4, 0x3a, 0x2e,
0x39, 0xe1, 0xb6, 0x86, 0x37, 0xec, 0xad, 0xcf, 0x68, 0x31,
0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x70, 0x61, 0x72, 0x73,
0x65, 0x2e, 0x79, 0x0, 0x83, 0x10, 0xb2, 0x69, 0x89, 0xb0,
0x5b, 0xed, 0x1e, 0x1b, 0x3, 0xda, 0x80, 0xf5, 0xc0, 0xa5,
0x2e, 0x9a, 0xd1, 0xd2, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34,
0x20, 0x70, 0x63, 0x61, 0x63, 0x68, 0x65, 0x2e, 0x63, 0x0,
0x48, 0x2a, 0x18, 0x8b, 0xee, 0x19, 0x91, 0xbc, 0x8a, 0xda,
0xc9, 0x6a, 0x19, 0x3a, 0x53, 0xe5, 0x46, 0x2a, 0x8c, 0x10,
0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x70, 0x63, 0x61,
0x63, 0x68, 0x65, 0x2e, 0x68, 0x0, 0xf4, 0xd4, 0xad, 0x71,
0xc1, 0xd, 0x78, 0xc6, 0xda, 0xbd, 0xe2, 0x52, 0x15, 0xcd,
0x41, 0x5a, 0x76, 0x1, 0x48, 0xca, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x70, 0x63, 0x61, 0x63, 0x68, 0x65, 0x31,
0x2e, 0x63, 0x0, 0x41, 0x47, 0xd2, 0xef, 0xf5, 0x5b, 0xdd,
0x9f, 0xf7, 0xc6, 0x86, 0xc, 0x60, 0x18, 0x10, 0x20, 0x16,
0x6c, 0x5f, 0x50, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x70, 0x72, 0x61, 0x67, 0x6d, 0x61, 0x2e, 0x63, 0x0, 0x22,
0x97, 0x71, 0x69, 0x61, 0x7d, 0x49, 0x22, 0xb3, 0x99, 0x3f,
0x76, 0x9d, 0x90, 0xfa, 0x7b, 0xc4, 0x41, 0xea, 0x50, 0x31,
0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x70, 0x72, 0x65, 0x70,
0x61, 0x72, 0x65, 0x2e, 0x63, 0x0, 0xd7, 0x8d, 0x83, 0xcb,
0xd8, 0x78, 0x97, 0xf5, 0x73, 0x30, 0x3f, 0x9f, 0x57, 0xab,
0x8d, 0xe0, 0x24, 0xa6, 0xe3, 0xf8, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x66, 0x2e,
0x63, 0x0, 0x9f, 0x68, 0xd2, 0x4, 0xff, 0xdc, 0x9f, 0x3d,
0x42, 0x7f, 0x80, 0xa8, 0x23, 0x9a, 0x7f, 0xa3, 0xa9, 0x8a,
0xec, 0xbd, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x72,
0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x2e, 0x63, 0x0, 0x23, 0x4e,
0xbd, 0xf6, 0x58, 0xf4, 0x36, 0xcc, 0x7c, 0x68, 0xf0, 0x27,
0xc4, 0x8b, 0xe, 0x1b, 0x9b, 0xa3, 0x4e, 0x98, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x72, 0x65, 0x73, 0x6f, 0x6c,
0x76, 0x65, 0x2e, 0x63, 0x0, 0x91, 0xef, 0xca, 0xa1, 0xa1,
0x6b, 0xfc, 0x98, 0xfb, 0x35, 0xd8, 0x5c, 0xad, 0x15, 0x6b,
0x93, 0x53, 0x3e, 0x4e, 0x6, 0x31, 0x30, 0x30, 0x36, 0x34,
0x34, 0x20, 0x72, 0x6f, 0x77, 0x73, 0x65, 0x74, 0x2e, 0x63,
0x0, 0x57, 0x61, 0xf9, 0x85, 0x50, 0xb1, 0x76, 0xcc, 0xe1,
0x1d, 0xcb, 0xce, 0xc9, 0x38, 0x99, 0xa0, 0x75, 0xbb, 0x64,
0xfd, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x73, 0x65,
0x6c, 0x65, 0x63, 0x74, 0x2e, 0x63, 0x0, 0xf3, 0xf1, 0x49,
0x9, 0x63, 0x95, 0x5b, 0x8e, 0xd0, 0xc9, 0xfe, 0x6e, 0x1e,
0xec, 0x83, 0x6c, 0x1a, 0x52, 0x94, 0xb4, 0x31, 0x30, 0x30,
0x36, 0x34, 0x34, 0x20, 0x73, 0x68, 0x65, 0x6c, 0x6c, 0x2e,
0x63, 0x0, 0x1b, 0xe2, 0x87, 0x1f, 0xed, 0x9a, 0x1f, 0xdf,
0x1d, 0xf7, 0x19, 0x8e, 0x11, 0x25, 0x36, 0x0, 0xec, 0xba,
0x76, 0xcc, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x73,
0x71, 0x6c, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x2e, 0x68,
0x0, 0x82, 0x75, 0x30, 0x95, 0xcd, 0x17, 0x23, 0xc5, 0xff,
0x4f, 0x11, 0x15, 0xe4, 0x97, 0x55, 0x91, 0xee, 0x34, 0xf5,
0xce, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x73, 0x71,
0x6c, 0x69, 0x74, 0x65, 0x2e, 0x68, 0x2e, 0x69, 0x6e, 0x0,
0x66, 0x8, 0x82, 0x31, 0x75, 0xde, 0x5b, 0x6a, 0xd, 0x37,
0x8f, 0xdb, 0xc, 0x38, 0x18, 0xb6, 0xab, 0x4f, 0xbf, 0x8e,
0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x73, 0x71, 0x6c,
0x69, 0x74, 0x65, 0x33, 0x2e, 0x72, 0x63, 0x0, 0x96, 0x98,
0x76, 0xda, 0x1e, 0x57, 0x14, 0x3d, 0xe0, 0xb4, 0xd1, 0xc7,
0x62, 0x9f, 0xd3, 0x35, 0x6f, 0x2e, 0x1c, 0x96, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x73, 0x71, 0x6c, 0x69, 0x74,
0x65, 0x33, 0x65, 0x78, 0x74, 0x2e, 0x68, 0x0, 0x92, 0x8b,
0xb3, 0xba, 0xd9, 0xdd, 0x64, 0x3c, 0x30, 0x1d, 0xd2, 0xb0,
0xac, 0x22, 0x28, 0x7a, 0x81, 0x28, 0x48, 0x84, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x73, 0x71, 0x6c, 0x69, 0x74,
0x65, 0x49, 0x6e, 0x74, 0x2e, 0x68, 0x0, 0x59, 0x50, 0xf2,
0x37, 0xd9, 0xf9, 0xf2, 0xd3, 0xef, 0x6b, 0xd8, 0xbe, 0x34,
0x2d, 0xcf, 0x64, 0x89, 0x22, 0x51, 0x42, 0x31, 0x30, 0x30,
0x36, 0x34, 0x34, 0x20, 0x73, 0x71, 0x6c, 0x69, 0x74, 0x65,
0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x68, 0x0, 0xc7, 0xae,
0xe5, 0x3c, 0xeb, 0xca, 0x94, 0xda, 0x51, 0xe7, 0x1a, 0x82,
0x2e, 0xa5, 0xa6, 0xde, 0xb9, 0x3, 0x85, 0xdf, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75,
0x73, 0x2e, 0x63, 0x0, 0x28, 0x34, 0x9e, 0x6d, 0x3d, 0x20,
0x88, 0xe0, 0x0, 0x3b, 0x76, 0xf8, 0xa, 0x89, 0x54, 0xfa,
0xec, 0x59, 0x30, 0xba, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34,
0x20, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x63, 0x0, 0x26,
0xbb, 0xfb, 0x4f, 0x45, 0x6c, 0x42, 0x98, 0x25, 0x29, 0xea,
0x1a, 0x63, 0xa0, 0x17, 0x51, 0xdd, 0x3e, 0xe9, 0x5a, 0x31,
0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x63, 0x6c, 0x73,
0x71, 0x6c, 0x69, 0x74, 0x65, 0x2e, 0x63, 0x0, 0xf1, 0xbb,
0x29, 0x21, 0xda, 0xc, 0x68, 0xa4, 0xf1, 0xc8, 0xe1, 0x5c,
0xf5, 0x66, 0xb2, 0x33, 0xe9, 0x2a, 0x51, 0x9f, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x31,
0x2e, 0x63, 0x0, 0xa6, 0x38, 0xe4, 0x80, 0xad, 0xdf, 0x14,
0x43, 0x9c, 0xdf, 0xa4, 0xee, 0x16, 0x4d, 0xc3, 0x1b, 0x79,
0xf8, 0xbc, 0xac, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x74, 0x65, 0x73, 0x74, 0x32, 0x2e, 0x63, 0x0, 0xd1, 0x30,
0xe9, 0xd0, 0x1b, 0x70, 0x24, 0xa5, 0xec, 0x6d, 0x73, 0x5,
0x92, 0xee, 0x4d, 0x1f, 0xb0, 0x2c, 0xfd, 0xb4, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x33,
0x2e, 0x63, 0x0, 0xe3, 0xed, 0x31, 0xc, 0x81, 0x4, 0xfe,
0x36, 0x21, 0xce, 0xbb, 0xf, 0x51, 0xd1, 0x1, 0x45, 0x1,
0x8d, 0x4f, 0xac, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x74, 0x65, 0x73, 0x74, 0x34, 0x2e, 0x63, 0x0, 0xa6, 0x37,
0x5c, 0x7c, 0xc4, 0x3, 0xf6, 0xc, 0xaa, 0xb7, 0xe9, 0x59,
0x53, 0x3e, 0x3d, 0xb1, 0xff, 0x75, 0xa, 0xe4, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x35,
0x2e, 0x63, 0x0, 0x30, 0x3d, 0x12, 0x5, 0xb2, 0x26, 0x28,
0x42, 0x3d, 0x98, 0x6f, 0x71, 0xe2, 0x7c, 0x7c, 0xf7, 0x14,
0xa7, 0x45, 0xa6, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x74, 0x65, 0x73, 0x74, 0x36, 0x2e, 0x63, 0x0, 0xc1, 0x51,
0xea, 0x42, 0x98, 0x9b, 0xb, 0xe2, 0x4e, 0xe4, 0xb9, 0xa4,
0xbe, 0x37, 0x8b, 0x4f, 0x63, 0x6d, 0xb6, 0x41, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x37,
0x2e, 0x63, 0x0, 0x3c, 0xd4, 0xa2, 0x24, 0xd7, 0xe8, 0xe1,
0x6b, 0xd7, 0xcb, 0xe4, 0x9e, 0x2d, 0x3e, 0x94, 0xce, 0x9b,
0x17, 0xbd, 0x76, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x74, 0x65, 0x73, 0x74, 0x38, 0x2e, 0x63, 0x0, 0xc5, 0x73,
0x93, 0x32, 0xd4, 0x6e, 0x57, 0x12, 0x1d, 0xa2, 0x7c, 0x3e,
0x88, 0xfd, 0xe7, 0x5a, 0xeb, 0x87, 0x10, 0xf7, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x39,
0x2e, 0x63, 0x0, 0xe5, 0x99, 0x3e, 0x8f, 0xf7, 0x8f, 0x61,
0xc2, 0x43, 0x5b, 0x6f, 0x97, 0xa3, 0xb4, 0x63, 0xe2, 0x27,
0xc7, 0x67, 0xac, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x73, 0x79, 0x6e, 0x63,
0x2e, 0x63, 0x0, 0xb0, 0xb9, 0x43, 0x18, 0x5b, 0xfc, 0x23,
0xc1, 0x7f, 0xd0, 0x8f, 0x55, 0x76, 0x8c, 0xac, 0x12, 0xa9,
0xf5, 0x69, 0x51, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x75, 0x74, 0x6f, 0x65,
0x78, 0x74, 0x2e, 0x63, 0x0, 0xb5, 0x1, 0x3f, 0x31, 0x73,
0xa2, 0x17, 0x6e, 0x2d, 0x9f, 0xc, 0xaa, 0x99, 0x19, 0x30,
0x36, 0xbf, 0xc3, 0x7e, 0x91, 0x31, 0x30, 0x30, 0x36, 0x34,
0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x62, 0x61, 0x63,
0x6b, 0x75, 0x70, 0x2e, 0x63, 0x0, 0xe9, 0x67, 0x42, 0x4a,
0x29, 0xf, 0x73, 0x8a, 0xec, 0xfd, 0xac, 0x57, 0x8e, 0x9b,
0x87, 0xa4, 0xc4, 0xae, 0x8d, 0x7f, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x62, 0x74,
0x72, 0x65, 0x65, 0x2e, 0x63, 0x0, 0xdb, 0x72, 0x88, 0x9b,
0x2a, 0xfb, 0x62, 0x72, 0x82, 0x8d, 0xda, 0x86, 0x6d, 0xcc,
0xf1, 0x22, 0xa4, 0x9a, 0x72, 0x99, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x0, 0x53, 0x47, 0x27,
0xa0, 0x80, 0x42, 0xb6, 0xca, 0xd6, 0x7e, 0x26, 0x7e, 0x87,
0xb4, 0x3, 0xa4, 0x1a, 0x73, 0xb2, 0x99, 0x31, 0x30, 0x30,
0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x64,
0x65, 0x6d, 0x6f, 0x76, 0x66, 0x73, 0x2e, 0x63, 0x0, 0x63,
0x76, 0x27, 0x7, 0x1d, 0x9e, 0x28, 0xf4, 0xb3, 0x45, 0x1b,
0xbb, 0xdd, 0xf8, 0x8, 0xd1, 0xa9, 0x12, 0x0, 0xf8, 0x31,
0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74,
0x5f, 0x64, 0x65, 0x76, 0x73, 0x79, 0x6d, 0x2e, 0x63, 0x0,
0x21, 0xf0, 0xf6, 0x84, 0xd8, 0x61, 0x11, 0x67, 0x70, 0xde,
0xfc, 0xde, 0xcd, 0x53, 0x2b, 0xa3, 0xee, 0xab, 0xa9, 0x75,
0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73,
0x74, 0x5f, 0x66, 0x73, 0x2e, 0x63, 0x0, 0x47, 0x8c, 0xad,
0x80, 0xb1, 0x6a, 0x90, 0x9b, 0x23, 0xbd, 0x3, 0xc2, 0xda,
0xd8, 0xb4, 0x49, 0xa7, 0x45, 0x87, 0xa1, 0x31, 0x30, 0x30,
0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x66,
0x75, 0x6e, 0x63, 0x2e, 0x63, 0x0, 0x6f, 0x9b, 0xb0, 0x3d,
0xc8, 0x8a, 0x21, 0xd6, 0x58, 0xbf, 0x99, 0x99, 0xba, 0xf6,
0x6d, 0xc1, 0xd5, 0x2e, 0xbc, 0x54, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x68, 0x65,
0x78, 0x69, 0x6f, 0x2e, 0x63, 0x0, 0xb2, 0xb, 0x5c, 0xe7,
0x30, 0xab, 0x7f, 0xa8, 0x0, 0xd2, 0xd0, 0xcc, 0x38, 0xc7,
0x72, 0x75, 0x59, 0x3e, 0xbd, 0xbb, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x6e,
0x69, 0x74, 0x2e, 0x63, 0x0, 0xe3, 0x72, 0x4d, 0x8b, 0xe3,
0x14, 0xdb, 0x9, 0xee, 0xa8, 0x4, 0xb, 0x9d, 0xdf, 0xc8,
0xa8, 0xbe, 0xee, 0x22, 0x91, 0x31, 0x30, 0x30, 0x36, 0x34,
0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x74,
0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x63, 0x0, 0xf5, 0xc3,
0xd9, 0xe4, 0x5, 0x9a, 0x16, 0x56, 0x7, 0x34, 0x7, 0xe4,
0x3a, 0x92, 0x11, 0x79, 0x99, 0x69, 0x7b, 0x93, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f,
0x69, 0x6e, 0x74, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x68,
0x0, 0x69, 0x13, 0x37, 0xd1, 0xae, 0xd6, 0x37, 0x15, 0xd6,
0x2e, 0x76, 0x26, 0x6f, 0xf, 0x3b, 0x50, 0x8b, 0x1, 0xa,
0x34, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65,
0x73, 0x74, 0x5f, 0x6a, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6c,
0x2e, 0x63, 0x0, 0xe8, 0x70, 0x1a, 0x4e, 0xea, 0xdb, 0x8e,
0xad, 0x16, 0x9d, 0x60, 0x6, 0x40, 0x7d, 0x54, 0xa8, 0x98,
0x59, 0x2d, 0x70, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x74, 0x65, 0x73, 0x74, 0x5f, 0x6c, 0x6f, 0x61, 0x64, 0x65,
0x78, 0x74, 0x2e, 0x63, 0x0, 0x11, 0x37, 0xe3, 0xa9, 0xaa,
0xe9, 0x29, 0x6, 0xb8, 0x28, 0x9f, 0x6c, 0x3d, 0xaa, 0x61,
0xf0, 0xd0, 0x70, 0xf5, 0x5a, 0x31, 0x30, 0x30, 0x36, 0x34,
0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x6c,
0x6c, 0x6f, 0x63, 0x2e, 0x63, 0x0, 0xcf, 0x98, 0xa8, 0xfb,
0x21, 0x82, 0xc0, 0xba, 0xf5, 0xa, 0xd5, 0x79, 0x79, 0xb6,
0x75, 0xbb, 0x70, 0x7a, 0x93, 0xb0, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x75,
0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x78, 0x2e, 0x63, 0x0,
0x62, 0x45, 0x41, 0xb3, 0x2a, 0x10, 0xd2, 0x1a, 0x2f, 0xd1,
0xa, 0x35, 0xee, 0x66, 0x32, 0xbd, 0xac, 0x55, 0x2d, 0x41,
0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73,
0x74, 0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65,
0x78, 0x2e, 0x68, 0x0, 0xb7, 0xe1, 0xaf, 0xea, 0x5f, 0xd7,
0x8b, 0x87, 0x58, 0x2, 0x65, 0xf8, 0x4c, 0x81, 0x61, 0x2c,
0xbd, 0x2, 0x5b, 0xaf, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34,
0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x75, 0x74, 0x65,
0x78, 0x2e, 0x63, 0x0, 0xc9, 0xb4, 0xa2, 0x9a, 0xb7, 0x5c,
0x77, 0xea, 0x5f, 0x36, 0xb5, 0x19, 0x32, 0x56, 0xd7, 0xf,
0xe6, 0x58, 0xe, 0x95, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34,
0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6f, 0x6e, 0x65, 0x66,
0x69, 0x6c, 0x65, 0x2e, 0x63, 0x0, 0x69, 0x86, 0x74, 0x41,
0xb8, 0xcc, 0x9a, 0x62, 0x1a, 0xf3, 0x24, 0x13, 0xfc, 0x63,
0xda, 0x80, 0x99, 0x37, 0x64, 0xf4, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6f, 0x73,
0x69, 0x6e, 0x73, 0x74, 0x2e, 0x63, 0x0, 0x53, 0x14, 0x33,
0x31, 0x3e, 0xe3, 0x6c, 0x7, 0xeb, 0x21, 0xc0, 0x2f, 0x31,
0x15, 0xcb, 0x7a, 0x37, 0x48, 0x6c, 0x79, 0x31, 0x30, 0x30,
0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70,
0x63, 0x61, 0x63, 0x68, 0x65, 0x2e, 0x63, 0x0, 0x8f, 0xcf,
0xe7, 0xe2, 0x6e, 0x3f, 0xf1, 0x74, 0x96, 0xb8, 0x40, 0xf5,
0xd6, 0x3c, 0x75, 0x78, 0x3a, 0xff, 0x81, 0x62, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f,
0x71, 0x75, 0x6f, 0x74, 0x61, 0x2e, 0x63, 0x0, 0xe5, 0x90,
0x99, 0x6c, 0xa4, 0xb8, 0x57, 0x4a, 0xb1, 0xe4, 0x18, 0x5d,
0x57, 0x77, 0x56, 0x66, 0x4a, 0xd2, 0x49, 0x5f, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f,
0x71, 0x75, 0x6f, 0x74, 0x61, 0x2e, 0x68, 0x0, 0x2d, 0x7,
0x67, 0xa1, 0x9a, 0xb7, 0xc3, 0xa4, 0x21, 0xcd, 0xba, 0x6a,
0x3, 0x49, 0x20, 0x43, 0x67, 0xc2, 0x2c, 0x81, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f,
0x72, 0x74, 0x72, 0x65, 0x65, 0x2e, 0x63, 0x0, 0xf5, 0x4a,
0xe9, 0xb0, 0x63, 0xbb, 0x73, 0x71, 0x2f, 0xcf, 0xc1, 0xc6,
0x83, 0x2e, 0x2a, 0x50, 0xf6, 0x2a, 0x97, 0xe7, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f,
0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x63, 0x0, 0x12,
0x64, 0x44, 0x67, 0x64, 0x7d, 0x51, 0x39, 0x4a, 0x1, 0xf9,
0xfa, 0x60, 0x37, 0x62, 0x98, 0x18, 0x54, 0x66, 0xfd, 0x31,
0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74,
0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x63, 0x0,
0xed, 0x8, 0x18, 0xe6, 0xf6, 0x5f, 0x27, 0x28, 0x2d, 0xc7,
0xb1, 0xc1, 0x90, 0xec, 0x18, 0x8c, 0x89, 0x33, 0x0, 0x2b,
0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73,
0x74, 0x5f, 0x73, 0x71, 0x6c, 0x6c, 0x6f, 0x67, 0x2e, 0x63,
0x0, 0x4a, 0xa6, 0x8b, 0x7c, 0x42, 0x93, 0x23, 0xb8, 0xee,
0xbe, 0x6c, 0x9c, 0x2d, 0x7, 0xfc, 0x66, 0xd, 0x8d, 0x47,
0xc9, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65,
0x73, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x2e, 0x63, 0x0,
0xd4, 0xc9, 0x2, 0xb5, 0xea, 0x11, 0x1a, 0xd5, 0x8a, 0x73,
0x71, 0x12, 0xc2, 0x8f, 0x0, 0x38, 0x43, 0x4c, 0x85, 0xc0,
0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73,
0x74, 0x5f, 0x73, 0x75, 0x70, 0x65, 0x72, 0x6c, 0x6f, 0x63,
0x6b, 0x2e, 0x63, 0x0, 0x93, 0x6f, 0xca, 0xd0, 0xc5, 0x6f,
0x6b, 0xc8, 0x58, 0x9, 0x74, 0x2f, 0x6a, 0xe1, 0xc1, 0xee,
0xb8, 0xb7, 0xd2, 0xf1, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34,
0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x73, 0x79, 0x73, 0x63,
0x61, 0x6c, 0x6c, 0x2e, 0x63, 0x0, 0x7c, 0x8, 0x73, 0xc1,
0x6d, 0x84, 0x32, 0x2, 0xf3, 0xe, 0x2d, 0xb9, 0x45, 0x9f,
0xa2, 0x99, 0x75, 0xea, 0x5e, 0x68, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x63,
0x6c, 0x76, 0x61, 0x72, 0x2e, 0x63, 0x0, 0x12, 0x19, 0x19,
0xc, 0x3, 0x0, 0xfd, 0x5e, 0xc7, 0xa3, 0xc5, 0x84, 0x8,
0xf3, 0x38, 0x43, 0xd2, 0xe, 0xee, 0x15, 0x31, 0x30, 0x30,
0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x74,
0x68, 0x72, 0x65, 0x61, 0x64, 0x2e, 0x63, 0x0, 0x2f, 0x93,
0x63, 0xb7, 0x50, 0x1e, 0x51, 0x19, 0x81, 0xfe, 0x32, 0x83,
0x1f, 0xf2, 0xe8, 0xfd, 0x2f, 0x30, 0xc4, 0x93, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f,
0x76, 0x66, 0x73, 0x2e, 0x63, 0x0, 0xfc, 0xd5, 0x77, 0x43,
0x9c, 0xfd, 0x6c, 0x72, 0xdd, 0xe4, 0x83, 0x58, 0x92, 0x14,
0x20, 0xcf, 0x6e, 0xf1, 0xf8, 0x6d, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x76, 0x66,
0x73, 0x74, 0x72, 0x61, 0x63, 0x65, 0x2e, 0x63, 0x0, 0xa,
0xac, 0xc0, 0x1f, 0xe4, 0x2e, 0x77, 0xfe, 0xb8, 0x58, 0xe4,
0xbe, 0xd0, 0xcb, 0x7e, 0x4, 0xa4, 0x35, 0xb2, 0x10, 0x31,
0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x74, 0x65, 0x73, 0x74,
0x5f, 0x77, 0x73, 0x64, 0x2e, 0x63, 0x0, 0x99, 0xe4, 0xa0,
0x56, 0x58, 0x1f, 0x58, 0xf4, 0x53, 0x6f, 0xdb, 0x5a, 0x5d,
0xf7, 0x5c, 0x74, 0x69, 0x8a, 0x81, 0x62, 0x31, 0x30, 0x30,
0x36, 0x34, 0x34, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x69,
0x7a, 0x65, 0x2e, 0x63, 0x0, 0xfa, 0xea, 0x5f, 0x26, 0xc7,
0x9c, 0x5e, 0x18, 0x8f, 0xa8, 0x7f, 0x2f, 0xdf, 0x6f, 0xf7,
0x6a, 0x7a, 0x60, 0x6, 0xc5, 0x31, 0x30, 0x30, 0x36, 0x34,
0x34, 0x20, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x2e,
0x63, 0x0, 0xf1, 0xff, 0x76, 0x6e, 0x20, 0x2a, 0x45, 0x18,
0xec, 0x10, 0xe5, 0x27, 0x12, 0xc, 0xd3, 0xe, 0x83, 0xfb,
0xd0, 0x34, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x75,
0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x63, 0x0, 0x3a, 0xb1,
0xab, 0x2a, 0x4b, 0x65, 0xda, 0x3f, 0x19, 0x8c, 0x15, 0x84,
0xd5, 0x4d, 0x36, 0xf1, 0x8c, 0xa1, 0x21, 0x4a, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x75, 0x74, 0x66, 0x2e, 0x63,
0x0, 0x6d, 0x5b, 0x1b, 0xfe, 0x40, 0xc, 0x37, 0x48, 0xaa,
0x70, 0xa3, 0xb2, 0xfd, 0x5e, 0xe, 0xac, 0x5f, 0xc0, 0x4d,
0xe2, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x75, 0x74,
0x69, 0x6c, 0x2e, 0x63, 0x0, 0xd8, 0x3a, 0x63, 0x1, 0x5f,
0xd8, 0x7d, 0xcc, 0x4f, 0xb4, 0x41, 0x66, 0xfa, 0xbf, 0x2e,
0x9b, 0xc9, 0x67, 0x1e, 0xb8, 0x31, 0x30, 0x30, 0x36, 0x34,
0x34, 0x20, 0x76, 0x61, 0x63, 0x75, 0x75, 0x6d, 0x2e, 0x63,
0x0, 0x4a, 0xfb, 0x2c, 0xca, 0x64, 0xdd, 0x60, 0x76, 0x11,
0x22, 0x2c, 0x7, 0x93, 0x2d, 0x12, 0xea, 0xcf, 0xa, 0x2c,
0x22, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x76, 0x64,
0x62, 0x65, 0x2e, 0x63, 0x0, 0xf3, 0x43, 0xe1, 0x3d, 0x4e,
0x91, 0x78, 0x4b, 0x15, 0x88, 0x10, 0xc5, 0xb7, 0xd4, 0x46,
0x84, 0xdf, 0xbf, 0xa2, 0xa5, 0x31, 0x30, 0x30, 0x36, 0x34,
0x34, 0x20, 0x76, 0x64, 0x62, 0x65, 0x2e, 0x68, 0x0, 0xfa,
0x7b, 0x31, 0xb7, 0x27, 0xa, 0x90, 0xd4, 0xf6, 0x37, 0x36,
0x5a, 0xfc, 0xc9, 0xbd, 0xa1, 0xd1, 0xb1, 0xe1, 0xd6, 0x31,
0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x76, 0x64, 0x62, 0x65,
0x49, 0x6e, 0x74, 0x2e, 0x68, 0x0, 0x3a, 0x5b, 0x40, 0x28,
0xbb, 0xd6, 0xc9, 0x56, 0x10, 0xd7, 0xc, 0xce, 0x3, 0x69,
0xdf, 0xcd, 0x60, 0x7a, 0xa9, 0x0, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x76, 0x64, 0x62, 0x65, 0x61, 0x70, 0x69,
0x2e, 0x63, 0x0, 0x7c, 0x86, 0x1e, 0x2d, 0x47, 0x21, 0x8c,
0x91, 0x63, 0x31, 0x77, 0x77, 0xc3, 0x7, 0x21, 0x99, 0xe9,
0xb4, 0x2, 0x80, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x76, 0x64, 0x62, 0x65, 0x61, 0x75, 0x78, 0x2e, 0x63, 0x0,
0x2c, 0x42, 0x69, 0xa5, 0x9e, 0x6d, 0xbc, 0xe8, 0x67, 0x1c,
0x47, 0x4f, 0x34, 0x61, 0x90, 0xbe, 0x2a, 0xe, 0x18, 0x51,
0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x76, 0x64, 0x62,
0x65, 0x62, 0x6c, 0x6f, 0x62, 0x2e, 0x63, 0x0, 0x2e, 0x8f,
0xd8, 0xee, 0x74, 0x47, 0xe6, 0x46, 0x46, 0xe3, 0x49, 0x4b,
0x4c, 0x4, 0x1d, 0x3a, 0x4a, 0xbb, 0x8, 0x85, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x76, 0x64, 0x62, 0x65, 0x6d,
0x65, 0x6d, 0x2e, 0x63, 0x0, 0x8f, 0xc2, 0x22, 0xe2, 0xde,
0x20, 0x50, 0x14, 0x50, 0xec, 0xea, 0x9d, 0x4e, 0xbf, 0xaa,
0xc9, 0x81, 0x4a, 0xae, 0x59, 0x31, 0x30, 0x30, 0x36, 0x34,
0x34, 0x20, 0x76, 0x64, 0x62, 0x65, 0x73, 0x6f, 0x72, 0x74,
0x2e, 0x63, 0x0, 0xfd, 0xfc, 0x4a, 0x79, 0xdd, 0xc9, 0x6e,
0x59, 0x9b, 0x1b, 0xe, 0xeb, 0xac, 0xbd, 0xb8, 0x45, 0xc6,
0x38, 0x13, 0xb2, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20,
0x76, 0x64, 0x62, 0x65, 0x74, 0x72, 0x61, 0x63, 0x65, 0x2e,
0x63, 0x0, 0x35, 0x62, 0x77, 0xe8, 0xd2, 0x3b, 0xca, 0xdb,
0x67, 0x6b, 0x59, 0xd1, 0xa4, 0xdc, 0xf8, 0x42, 0xfd, 0xc4,
0xc9, 0x72, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x76,
0x74, 0x61, 0x62, 0x2e, 0x63, 0x0, 0x95, 0x82, 0x2, 0xc3,
0x1e, 0x24, 0x15, 0xb, 0x60, 0xf1, 0xa, 0x8a, 0xf, 0x74,
0x41, 0xaf, 0xac, 0x3f, 0xbb, 0x1c, 0x31, 0x30, 0x30, 0x36,
0x34, 0x34, 0x20, 0x77, 0x61, 0x6c, 0x2e, 0x63, 0x0, 0xe6,
0x42, 0xea, 0x21, 0x5, 0xb5, 0xc5, 0x4a, 0xf3, 0x5, 0x88,
0x9, 0x62, 0x69, 0xab, 0x75, 0xcb, 0xef, 0x8f, 0xf2, 0x31,
0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x77, 0x61, 0x6c, 0x2e,
0x68, 0x0, 0x9, 0x25, 0x46, 0x35, 0x4b, 0x34, 0xc0, 0xab,
0x3d, 0x20, 0x5, 0x6a, 0x7f, 0x8a, 0x8a, 0x52, 0xe4, 0xd0,
0xb5, 0xf5, 0x31, 0x30, 0x30, 0x36, 0x34, 0x34, 0x20, 0x77,
0x61, 0x6c, 0x6b, 0x65, 0x72, 0x2e, 0x63, 0x0, 0xe7, 0x1e,
0xd2, 0xac, 0x48, 0x4c, 0x91, 0x6c, 0x1c, 0xc1, 0x0, 0x7e,
0x5e, 0x5, 0xda, 0x47, 0x1c, 0xb4, 0x95, 0x99, 0x31, 0x30,
0x30, 0x36, 0x34, 0x34, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65,
0x2e, 0x63, 0x0, 0xe6, 0x14, 0xf4, 0xa6, 0xd8, 0x64, 0xe7,
0xe, 0xc4, 0x32, 0x8d, 0xb, 0xdb, 0x25, 0x4e, 0x3a, 0xc9,
0xf0, 0xd2, 0x87,
}
obj := &SortReadObject{
t: plumbing.TreeObject,
h: plumbing.ZeroHash,
cont: cont,
sz: 5313,
}
expected := &Tree{
Entries: []TreeEntry{
{
Name: "alter.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xa4, 0x9d, 0x33, 0x49, 0xd7, 0xe2, 0x3f, 0xb5, 0x81, 0x19, 0x4f, 0x4c, 0xb5, 0x9a, 0xc0, 0xd5, 0x1b, 0x2, 0x1f, 0x78},
},
{
Name: "analyze.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x9a, 0x3e, 0x95, 0x97, 0xdb, 0xb, 0x3, 0x20, 0x77, 0xc9, 0x1d, 0x96, 0x9d, 0x22, 0xc6, 0x27, 0x3f, 0x70, 0x2a, 0xc},
},
{
Name: "attach.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xb8, 0xe1, 0x21, 0x99, 0xb5, 0x7d, 0xe8, 0x11, 0xea, 0xe0, 0xd0, 0x61, 0x42, 0xd5, 0xac, 0x4f, 0xd4, 0x30, 0xb1, 0xd8},
},
{
Name: "auth.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xd3, 0x8b, 0xb8, 0x36, 0xa7, 0x84, 0xfb, 0xfa, 0xb6, 0xab, 0x7b, 0x3, 0xd4, 0xe6, 0xdd, 0x43, 0xed, 0xc4, 0x1f, 0xa7},
},
{
Name: "backup.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x25, 0x2f, 0x61, 0xcf, 0xca, 0xa8, 0xfc, 0xf3, 0x13, 0x7e, 0x8, 0xed, 0x68, 0x47, 0xdc, 0xfe, 0x1d, 0xc1, 0xde, 0x54},
},
{
Name: "bitvec.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x52, 0x18, 0x4a, 0xa9, 0x64, 0xce, 0x18, 0x98, 0xf3, 0x5d, 0x1b, 0x3d, 0x87, 0x87, 0x1c, 0x2d, 0xe, 0xf4, 0xc5, 0x3d},
},
{
Name: "btmutex.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xd8, 0x7d, 0x4d, 0x5f, 0xee, 0xb6, 0x30, 0x7a, 0xec, 0xdc, 0x9a, 0x83, 0x11, 0x14, 0x89, 0xab, 0x30, 0xc6, 0x78, 0xc3},
},
{
Name: "btree.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x3c, 0xa6, 0x5, 0x83, 0xe3, 0xc8, 0xe3, 0x12, 0x0, 0xf9, 0x73, 0xe0, 0xe9, 0xc4, 0x53, 0x62, 0x58, 0xb2, 0x64, 0x39},
},
{
Name: "btree.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0xac, 0xe0, 0xf8, 0xcd, 0x21, 0x77, 0x70, 0xa2, 0xf6, 0x6b, 0x2e, 0xb8, 0x71, 0xbb, 0xc5, 0xfd, 0xc6, 0xfc, 0x2b, 0x68},
},
{
Name: "btreeInt.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0xce, 0x3c, 0x54, 0x93, 0xf8, 0xca, 0xd0, 0xbc, 0x54, 0x8a, 0xe8, 0xe4, 0x4e, 0x51, 0x28, 0x31, 0xd8, 0xfa, 0xc4, 0x31},
},
{
Name: "build.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x3c, 0x91, 0xcd, 0xcf, 0xdb, 0x7b, 0x1, 0x7c, 0xbc, 0x2d, 0x5c, 0x29, 0x57, 0x1a, 0x98, 0x27, 0xd, 0xe0, 0x71, 0xe6},
},
{
Name: "callback.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xd4, 0xc, 0x65, 0xcb, 0x92, 0x45, 0x80, 0x29, 0x6a, 0xd0, 0x69, 0xa0, 0x4b, 0xf9, 0xc9, 0xe9, 0x53, 0x4e, 0xca, 0xa7},
},
{
Name: "complete.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x9e, 0x91, 0x40, 0x8, 0x5c, 0x0, 0x46, 0xed, 0x3b, 0xf6, 0xf4, 0x48, 0x52, 0x20, 0x69, 0x2d, 0xca, 0x17, 0x43, 0xc5},
},
{
Name: "crypto.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x25, 0x51, 0xe6, 0xba, 0x2, 0x39, 0xf8, 0x5a, 0x35, 0x77, 0x96, 0xa8, 0xdd, 0xa8, 0xca, 0x3e, 0x29, 0x70, 0x93, 0xf8},
},
{
Name: "crypto.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0xf7, 0x1f, 0x53, 0x2c, 0xdc, 0x44, 0x8f, 0xa, 0x1d, 0xd5, 0xc6, 0xef, 0xf5, 0xfb, 0xd3, 0x3a, 0x91, 0x55, 0xaa, 0x97},
},
{
Name: "crypto_cc.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x53, 0x7d, 0xf7, 0xe3, 0xb3, 0x6a, 0xb5, 0xcf, 0xdd, 0x6f, 0xca, 0x40, 0x28, 0xeb, 0xca, 0xe1, 0x86, 0x87, 0xd6, 0x4d},
},
{
Name: "crypto_impl.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xa5, 0x89, 0x27, 0xc7, 0x6e, 0xf6, 0x20, 0x56, 0x77, 0xbe, 0x5c, 0x1a, 0x8e, 0x80, 0xc9, 0x83, 0x56, 0xb3, 0xa9, 0xd3},
},
{
Name: "crypto_libtomcrypt.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x1a, 0x33, 0x83, 0xe0, 0x1, 0xa7, 0x21, 0x11, 0xc3, 0xf6, 0x61, 0x92, 0x22, 0xb0, 0x65, 0xf4, 0xbd, 0x1, 0xb, 0xe1},
},
{
Name: "crypto_openssl.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xd0, 0x19, 0x81, 0x3b, 0x47, 0x6c, 0x52, 0xd0, 0x20, 0xe2, 0xc0, 0xac, 0xd5, 0x24, 0xe9, 0xea, 0x3d, 0xf, 0xb9, 0xfe},
},
{
Name: "ctime.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x60, 0x59, 0x5f, 0xf8, 0x8d, 0x92, 0xf7, 0x8, 0x26, 0x4, 0xfb, 0xd9, 0xdf, 0x9a, 0xfe, 0xa1, 0x6a, 0xe8, 0x6f, 0xf},
},
{
Name: "date.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x75, 0x8d, 0xd7, 0xc8, 0x9b, 0xca, 0x39, 0x37, 0xa9, 0xd, 0x70, 0x6e, 0xa9, 0x82, 0xce, 0x3a, 0xcf, 0x11, 0xd1, 0x83},
},
{
Name: "delete.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x63, 0x4e, 0x11, 0x55, 0x63, 0xae, 0x12, 0xba, 0x65, 0x58, 0xcc, 0xc5, 0x12, 0xae, 0xd6, 0x31, 0xc0, 0x66, 0xba, 0xd8},
},
{
Name: "expr.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x66, 0x3, 0x97, 0xe0, 0x78, 0xae, 0x48, 0xb2, 0xe7, 0x17, 0x5e, 0x33, 0x85, 0x67, 0x78, 0x19, 0x72, 0x2d, 0xdd, 0x6c},
},
{
Name: "fault.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xc3, 0x2, 0x8c, 0x4f, 0x93, 0x6e, 0xdf, 0x96, 0x71, 0x2d, 0xbe, 0x73, 0xa0, 0x76, 0x62, 0xf0, 0xa2, 0x6b, 0x1d, 0xa},
},
{
Name: "fkey.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xac, 0x35, 0xbc, 0x19, 0x4c, 0xde, 0xb1, 0x27, 0x98, 0x9b, 0x9, 0x40, 0x35, 0xce, 0xe0, 0x6f, 0x57, 0x37, 0x6f, 0x5e},
},
{
Name: "func.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xc0, 0x2f, 0x9, 0x6a, 0xda, 0xd5, 0xbc, 0xe9, 0xac, 0x83, 0xd3, 0x5f, 0xf, 0x46, 0x9, 0xd6, 0xf6, 0xd4, 0x3b, 0xe5},
},
{
Name: "global.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x7b, 0x2, 0xcf, 0x21, 0x30, 0xe0, 0xd1, 0xa7, 0xb8, 0x89, 0xd8, 0x44, 0xc, 0xcc, 0x82, 0x8, 0xf7, 0xb6, 0x7b, 0xf9},
},
{
Name: "hash.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xe8, 0x1d, 0xcf, 0x95, 0xe4, 0x38, 0x48, 0xfa, 0x70, 0x86, 0xb7, 0xf7, 0x81, 0xc0, 0x90, 0xad, 0xc7, 0xe6, 0xca, 0x8e},
},
{
Name: "hash.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0x82, 0xb7, 0xc5, 0x8c, 0x71, 0x9, 0xb, 0x54, 0x7e, 0x10, 0x17, 0x42, 0xaa, 0x9, 0x51, 0x73, 0x9f, 0xf2, 0xee, 0xe7},
},
{
Name: "hwtime.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0xb8, 0xbc, 0x5a, 0x29, 0x5b, 0xe3, 0xfa, 0xc8, 0x35, 0x1f, 0xa9, 0xf0, 0x8a, 0x77, 0x57, 0x9d, 0x59, 0xc9, 0xa8, 0xe4},
},
{
Name: "insert.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x9a, 0x56, 0x61, 0xf5, 0x9a, 0x72, 0x95, 0x2b, 0xe6, 0xc1, 0x67, 0xa0, 0xc2, 0xdb, 0x15, 0x9b, 0x91, 0xb7, 0x1f, 0xae},
},
{
Name: "journal.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xfe, 0xd2, 0x7b, 0xe3, 0xe3, 0x80, 0x55, 0xd2, 0x20, 0x43, 0x95, 0xcd, 0xe6, 0xff, 0xc9, 0x45, 0x89, 0xfb, 0xf5, 0xe8},
},
{
Name: "legacy.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x94, 0x64, 0x9a, 0xe7, 0x5, 0xab, 0x93, 0x85, 0x10, 0x8d, 0xd, 0x88, 0x7a, 0xf0, 0x75, 0x92, 0x89, 0xfb, 0x23, 0xcb},
},
{
Name: "lempar.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x2a, 0xfa, 0xa6, 0xce, 0xa6, 0xd8, 0x29, 0x60, 0x2c, 0x27, 0x86, 0xc1, 0xf8, 0xa3, 0x7f, 0x56, 0x7c, 0xf6, 0xfd, 0x53},
},
{
Name: "loadext.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xcd, 0xcf, 0x6a, 0x93, 0xb8, 0xc4, 0xf, 0x91, 0x4b, 0x94, 0x24, 0xe, 0xf1, 0x4c, 0xb4, 0xa3, 0xa, 0x37, 0xec, 0xa1},
},
{
Name: "main.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x39, 0xf6, 0x4, 0x21, 0xe6, 0x81, 0x27, 0x7c, 0xc3, 0xdb, 0xa0, 0x9a, 0xbe, 0x7c, 0xf7, 0x90, 0xd5, 0x28, 0xf5, 0xc3},
},
{
Name: "malloc.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x35, 0xa4, 0x4e, 0x5f, 0x61, 0xc2, 0xe4, 0x4c, 0x48, 0x1c, 0x62, 0x51, 0xbd, 0xa, 0xae, 0x7a, 0xcd, 0xa4, 0xde, 0xb},
},
{
Name: "mem0.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xd, 0xb, 0x66, 0x67, 0xd6, 0xa, 0x95, 0x5a, 0x6, 0x96, 0xdf, 0x62, 0x89, 0xb4, 0x91, 0x78, 0x96, 0x93, 0x43, 0xaa},
},
{
Name: "mem1.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x35, 0x78, 0x49, 0x6f, 0x33, 0x3, 0x7, 0xb2, 0x31, 0xdf, 0xb5, 0x3c, 0xc, 0x2e, 0x1c, 0x6b, 0x32, 0x3d, 0x79, 0x1e},
},
{
Name: "mem2.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x26, 0x44, 0x8e, 0xa8, 0xaa, 0xe0, 0x36, 0x6a, 0xf0, 0x54, 0x1a, 0xfe, 0xa4, 0x79, 0xb, 0x42, 0xf4, 0xa6, 0x9b, 0x5a},
},
{
Name: "mem3.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x1a, 0x1b, 0x79, 0x1f, 0x28, 0xf8, 0xcf, 0x3c, 0xe4, 0xf9, 0xa3, 0x5c, 0xda, 0xd7, 0xb7, 0x10, 0x75, 0x68, 0xc7, 0x15},
},
{
Name: "mem5.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x78, 0x3c, 0xef, 0x61, 0x76, 0xc5, 0x9c, 0xbf, 0x30, 0x91, 0x46, 0x31, 0x9, 0x5a, 0x1a, 0x54, 0xf4, 0xe4, 0x2e, 0x8},
},
{
Name: "memjournal.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x5, 0x72, 0x59, 0x48, 0xf6, 0x5d, 0x42, 0x7b, 0x7, 0xf7, 0xf9, 0x29, 0xac, 0xa3, 0xff, 0x22, 0x4b, 0x17, 0x53, 0xdf},
},
{
Name: "mutex.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xb5, 0x67, 0xe7, 0xc2, 0x7e, 0xf2, 0x4, 0x10, 0x86, 0xaf, 0xe0, 0xf6, 0x96, 0x66, 0xe2, 0x7b, 0xf5, 0x9, 0x8a, 0x59},
},
{
Name: "mutex.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0x9, 0x78, 0x81, 0x22, 0x52, 0x77, 0x89, 0xa, 0x9c, 0x36, 0xc2, 0x4d, 0x41, 0xf6, 0x11, 0x4d, 0x64, 0xc0, 0x6d, 0xb3},
},
{
Name: "mutex_noop.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x45, 0x6e, 0x82, 0xa2, 0x5e, 0x27, 0x1b, 0x6, 0x14, 0xe7, 0xf4, 0xf8, 0x3c, 0x22, 0x85, 0x53, 0xb7, 0xfa, 0x1, 0x58},
},
{
Name: "mutex_unix.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xec, 0xa7, 0x29, 0x58, 0x31, 0xc2, 0xf0, 0xee, 0x48, 0xba, 0x54, 0xd0, 0x62, 0x91, 0x4d, 0x6, 0xa1, 0xdd, 0x8e, 0xbe},
},
{
Name: "mutex_w32.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x27, 0xd1, 0xa, 0xf5, 0xbd, 0x33, 0x1b, 0xdb, 0x97, 0x3f, 0x61, 0x45, 0xb7, 0x4f, 0x72, 0xb6, 0x7, 0xcf, 0xc4, 0x6e},
},
{
Name: "notify.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xfc, 0xab, 0x5b, 0xfa, 0xf0, 0x19, 0x8, 0xd3, 0xde, 0x93, 0xfa, 0x88, 0xb5, 0xea, 0xe9, 0xe9, 0x6c, 0xa3, 0xc8, 0xe8},
},
{
Name: "os.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xbe, 0x2e, 0xa4, 0xcf, 0xc0, 0x19, 0x59, 0x93, 0xa3, 0x40, 0xc9, 0x2, 0xae, 0xdd, 0xf1, 0xbe, 0x4b, 0x8e, 0xd7, 0x3a},
},
{
Name: "os.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0x7, 0xa, 0x2d, 0xdd, 0x17, 0xf7, 0x71, 0xf9, 0x8f, 0xf8, 0xcc, 0xd6, 0xf0, 0x33, 0xbd, 0xac, 0xc5, 0xe9, 0xf6, 0xc},
},
{
Name: "os_common.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0xf6, 0xc3, 0xe7, 0xff, 0x89, 0x46, 0x30, 0x86, 0x40, 0x18, 0x22, 0xf4, 0x81, 0xe7, 0xe3, 0xb8, 0x7b, 0x2c, 0x78, 0xc7},
},
{
Name: "os_unix.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xab, 0xc2, 0x3a, 0x45, 0x2e, 0x72, 0xf7, 0x1c, 0x76, 0xaf, 0xa9, 0x98, 0x3c, 0x3a, 0xd9, 0xd4, 0x25, 0x61, 0x6c, 0x6d},
},
{
Name: "os_win.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xae, 0xb0, 0x88, 0x14, 0xb3, 0xda, 0xbe, 0x81, 0xb8, 0x4c, 0xda, 0x91, 0x85, 0x82, 0xb0, 0xf, 0xfd, 0x86, 0xe4, 0x87},
},
{
Name: "pager.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x61, 0x72, 0x7f, 0xaa, 0x9c, 0xf, 0x3d, 0x56, 0x62, 0x65, 0xbe, 0x7e, 0xec, 0x5b, 0x2a, 0x35, 0xf6, 0xa4, 0xbc, 0x9f},
},
{
Name: "pager.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0x6f, 0x65, 0x91, 0x36, 0xe2, 0x76, 0x7, 0x9d, 0xa4, 0x3a, 0x2e, 0x39, 0xe1, 0xb6, 0x86, 0x37, 0xec, 0xad, 0xcf, 0x68},
},
{
Name: "parse.y", Mode: filemode.Regular,
Hash: plumbing.Hash{0x83, 0x10, 0xb2, 0x69, 0x89, 0xb0, 0x5b, 0xed, 0x1e, 0x1b, 0x3, 0xda, 0x80, 0xf5, 0xc0, 0xa5, 0x2e, 0x9a, 0xd1, 0xd2},
},
{
Name: "pcache.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x48, 0x2a, 0x18, 0x8b, 0xee, 0x19, 0x91, 0xbc, 0x8a, 0xda, 0xc9, 0x6a, 0x19, 0x3a, 0x53, 0xe5, 0x46, 0x2a, 0x8c, 0x10},
},
{
Name: "pcache.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0xf4, 0xd4, 0xad, 0x71, 0xc1, 0xd, 0x78, 0xc6, 0xda, 0xbd, 0xe2, 0x52, 0x15, 0xcd, 0x41, 0x5a, 0x76, 0x1, 0x48, 0xca},
},
{
Name: "pcache1.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x41, 0x47, 0xd2, 0xef, 0xf5, 0x5b, 0xdd, 0x9f, 0xf7, 0xc6, 0x86, 0xc, 0x60, 0x18, 0x10, 0x20, 0x16, 0x6c, 0x5f, 0x50},
},
{
Name: "pragma.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x22, 0x97, 0x71, 0x69, 0x61, 0x7d, 0x49, 0x22, 0xb3, 0x99, 0x3f, 0x76, 0x9d, 0x90, 0xfa, 0x7b, 0xc4, 0x41, 0xea, 0x50},
},
{
Name: "prepare.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xd7, 0x8d, 0x83, 0xcb, 0xd8, 0x78, 0x97, 0xf5, 0x73, 0x30, 0x3f, 0x9f, 0x57, 0xab, 0x8d, 0xe0, 0x24, 0xa6, 0xe3, 0xf8},
},
{
Name: "printf.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x9f, 0x68, 0xd2, 0x4, 0xff, 0xdc, 0x9f, 0x3d, 0x42, 0x7f, 0x80, 0xa8, 0x23, 0x9a, 0x7f, 0xa3, 0xa9, 0x8a, 0xec, 0xbd},
},
{
Name: "random.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x23, 0x4e, 0xbd, 0xf6, 0x58, 0xf4, 0x36, 0xcc, 0x7c, 0x68, 0xf0, 0x27, 0xc4, 0x8b, 0xe, 0x1b, 0x9b, 0xa3, 0x4e, 0x98},
},
{
Name: "resolve.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x91, 0xef, 0xca, 0xa1, 0xa1, 0x6b, 0xfc, 0x98, 0xfb, 0x35, 0xd8, 0x5c, 0xad, 0x15, 0x6b, 0x93, 0x53, 0x3e, 0x4e, 0x6},
},
{
Name: "rowset.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x57, 0x61, 0xf9, 0x85, 0x50, 0xb1, 0x76, 0xcc, 0xe1, 0x1d, 0xcb, 0xce, 0xc9, 0x38, 0x99, 0xa0, 0x75, 0xbb, 0x64, 0xfd},
},
{
Name: "select.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xf3, 0xf1, 0x49, 0x9, 0x63, 0x95, 0x5b, 0x8e, 0xd0, 0xc9, 0xfe, 0x6e, 0x1e, 0xec, 0x83, 0x6c, 0x1a, 0x52, 0x94, 0xb4},
},
{
Name: "shell.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x1b, 0xe2, 0x87, 0x1f, 0xed, 0x9a, 0x1f, 0xdf, 0x1d, 0xf7, 0x19, 0x8e, 0x11, 0x25, 0x36, 0x0, 0xec, 0xba, 0x76, 0xcc},
},
{
Name: "sqlcipher.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0x82, 0x75, 0x30, 0x95, 0xcd, 0x17, 0x23, 0xc5, 0xff, 0x4f, 0x11, 0x15, 0xe4, 0x97, 0x55, 0x91, 0xee, 0x34, 0xf5, 0xce},
},
{
Name: "sqlite.h.in", Mode: filemode.Regular,
Hash: plumbing.Hash{0x66, 0x8, 0x82, 0x31, 0x75, 0xde, 0x5b, 0x6a, 0xd, 0x37, 0x8f, 0xdb, 0xc, 0x38, 0x18, 0xb6, 0xab, 0x4f, 0xbf, 0x8e},
},
{
Name: "sqlite3.rc", Mode: filemode.Regular,
Hash: plumbing.Hash{0x96, 0x98, 0x76, 0xda, 0x1e, 0x57, 0x14, 0x3d, 0xe0, 0xb4, 0xd1, 0xc7, 0x62, 0x9f, 0xd3, 0x35, 0x6f, 0x2e, 0x1c, 0x96},
},
{
Name: "sqlite3ext.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0x92, 0x8b, 0xb3, 0xba, 0xd9, 0xdd, 0x64, 0x3c, 0x30, 0x1d, 0xd2, 0xb0, 0xac, 0x22, 0x28, 0x7a, 0x81, 0x28, 0x48, 0x84},
},
{
Name: "sqliteInt.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0x59, 0x50, 0xf2, 0x37, 0xd9, 0xf9, 0xf2, 0xd3, 0xef, 0x6b, 0xd8, 0xbe, 0x34, 0x2d, 0xcf, 0x64, 0x89, 0x22, 0x51, 0x42},
},
{
Name: "sqliteLimit.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0xc7, 0xae, 0xe5, 0x3c, 0xeb, 0xca, 0x94, 0xda, 0x51, 0xe7, 0x1a, 0x82, 0x2e, 0xa5, 0xa6, 0xde, 0xb9, 0x3, 0x85, 0xdf},
},
{
Name: "status.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x28, 0x34, 0x9e, 0x6d, 0x3d, 0x20, 0x88, 0xe0, 0x0, 0x3b, 0x76, 0xf8, 0xa, 0x89, 0x54, 0xfa, 0xec, 0x59, 0x30, 0xba},
},
{
Name: "table.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x26, 0xbb, 0xfb, 0x4f, 0x45, 0x6c, 0x42, 0x98, 0x25, 0x29, 0xea, 0x1a, 0x63, 0xa0, 0x17, 0x51, 0xdd, 0x3e, 0xe9, 0x5a},
},
{
Name: "tclsqlite.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xf1, 0xbb, 0x29, 0x21, 0xda, 0xc, 0x68, 0xa4, 0xf1, 0xc8, 0xe1, 0x5c, 0xf5, 0x66, 0xb2, 0x33, 0xe9, 0x2a, 0x51, 0x9f},
},
{
Name: "test1.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xa6, 0x38, 0xe4, 0x80, 0xad, 0xdf, 0x14, 0x43, 0x9c, 0xdf, 0xa4, 0xee, 0x16, 0x4d, 0xc3, 0x1b, 0x79, 0xf8, 0xbc, 0xac},
},
{
Name: "test2.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xd1, 0x30, 0xe9, 0xd0, 0x1b, 0x70, 0x24, 0xa5, 0xec, 0x6d, 0x73, 0x5, 0x92, 0xee, 0x4d, 0x1f, 0xb0, 0x2c, 0xfd, 0xb4},
},
{
Name: "test3.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xe3, 0xed, 0x31, 0xc, 0x81, 0x4, 0xfe, 0x36, 0x21, 0xce, 0xbb, 0xf, 0x51, 0xd1, 0x1, 0x45, 0x1, 0x8d, 0x4f, 0xac},
},
{
Name: "test4.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xa6, 0x37, 0x5c, 0x7c, 0xc4, 0x3, 0xf6, 0xc, 0xaa, 0xb7, 0xe9, 0x59, 0x53, 0x3e, 0x3d, 0xb1, 0xff, 0x75, 0xa, 0xe4},
},
{
Name: "test5.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x30, 0x3d, 0x12, 0x5, 0xb2, 0x26, 0x28, 0x42, 0x3d, 0x98, 0x6f, 0x71, 0xe2, 0x7c, 0x7c, 0xf7, 0x14, 0xa7, 0x45, 0xa6},
},
{
Name: "test6.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xc1, 0x51, 0xea, 0x42, 0x98, 0x9b, 0xb, 0xe2, 0x4e, 0xe4, 0xb9, 0xa4, 0xbe, 0x37, 0x8b, 0x4f, 0x63, 0x6d, 0xb6, 0x41},
},
{
Name: "test7.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x3c, 0xd4, 0xa2, 0x24, 0xd7, 0xe8, 0xe1, 0x6b, 0xd7, 0xcb, 0xe4, 0x9e, 0x2d, 0x3e, 0x94, 0xce, 0x9b, 0x17, 0xbd, 0x76},
},
{
Name: "test8.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xc5, 0x73, 0x93, 0x32, 0xd4, 0x6e, 0x57, 0x12, 0x1d, 0xa2, 0x7c, 0x3e, 0x88, 0xfd, 0xe7, 0x5a, 0xeb, 0x87, 0x10, 0xf7},
},
{
Name: "test9.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xe5, 0x99, 0x3e, 0x8f, 0xf7, 0x8f, 0x61, 0xc2, 0x43, 0x5b, 0x6f, 0x97, 0xa3, 0xb4, 0x63, 0xe2, 0x27, 0xc7, 0x67, 0xac},
},
{
Name: "test_async.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xb0, 0xb9, 0x43, 0x18, 0x5b, 0xfc, 0x23, 0xc1, 0x7f, 0xd0, 0x8f, 0x55, 0x76, 0x8c, 0xac, 0x12, 0xa9, 0xf5, 0x69, 0x51},
},
{
Name: "test_autoext.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xb5, 0x1, 0x3f, 0x31, 0x73, 0xa2, 0x17, 0x6e, 0x2d, 0x9f, 0xc, 0xaa, 0x99, 0x19, 0x30, 0x36, 0xbf, 0xc3, 0x7e, 0x91},
},
{
Name: "test_backup.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xe9, 0x67, 0x42, 0x4a, 0x29, 0xf, 0x73, 0x8a, 0xec, 0xfd, 0xac, 0x57, 0x8e, 0x9b, 0x87, 0xa4, 0xc4, 0xae, 0x8d, 0x7f},
},
{
Name: "test_btree.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xdb, 0x72, 0x88, 0x9b, 0x2a, 0xfb, 0x62, 0x72, 0x82, 0x8d, 0xda, 0x86, 0x6d, 0xcc, 0xf1, 0x22, 0xa4, 0x9a, 0x72, 0x99},
},
{
Name: "test_config.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x53, 0x47, 0x27, 0xa0, 0x80, 0x42, 0xb6, 0xca, 0xd6, 0x7e, 0x26, 0x7e, 0x87, 0xb4, 0x3, 0xa4, 0x1a, 0x73, 0xb2, 0x99},
},
{
Name: "test_demovfs.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x63, 0x76, 0x27, 0x7, 0x1d, 0x9e, 0x28, 0xf4, 0xb3, 0x45, 0x1b, 0xbb, 0xdd, 0xf8, 0x8, 0xd1, 0xa9, 0x12, 0x0, 0xf8},
},
{
Name: "test_devsym.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x21, 0xf0, 0xf6, 0x84, 0xd8, 0x61, 0x11, 0x67, 0x70, 0xde, 0xfc, 0xde, 0xcd, 0x53, 0x2b, 0xa3, 0xee, 0xab, 0xa9, 0x75},
},
{
Name: "test_fs.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x47, 0x8c, 0xad, 0x80, 0xb1, 0x6a, 0x90, 0x9b, 0x23, 0xbd, 0x3, 0xc2, 0xda, 0xd8, 0xb4, 0x49, 0xa7, 0x45, 0x87, 0xa1},
},
{
Name: "test_func.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x6f, 0x9b, 0xb0, 0x3d, 0xc8, 0x8a, 0x21, 0xd6, 0x58, 0xbf, 0x99, 0x99, 0xba, 0xf6, 0x6d, 0xc1, 0xd5, 0x2e, 0xbc, 0x54},
},
{
Name: "test_hexio.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xb2, 0xb, 0x5c, 0xe7, 0x30, 0xab, 0x7f, 0xa8, 0x0, 0xd2, 0xd0, 0xcc, 0x38, 0xc7, 0x72, 0x75, 0x59, 0x3e, 0xbd, 0xbb},
},
{
Name: "test_init.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xe3, 0x72, 0x4d, 0x8b, 0xe3, 0x14, 0xdb, 0x9, 0xee, 0xa8, 0x4, 0xb, 0x9d, 0xdf, 0xc8, 0xa8, 0xbe, 0xee, 0x22, 0x91},
},
{
Name: "test_intarray.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xf5, 0xc3, 0xd9, 0xe4, 0x5, 0x9a, 0x16, 0x56, 0x7, 0x34, 0x7, 0xe4, 0x3a, 0x92, 0x11, 0x79, 0x99, 0x69, 0x7b, 0x93},
},
{
Name: "test_intarray.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0x69, 0x13, 0x37, 0xd1, 0xae, 0xd6, 0x37, 0x15, 0xd6, 0x2e, 0x76, 0x26, 0x6f, 0xf, 0x3b, 0x50, 0x8b, 0x1, 0xa, 0x34},
},
{
Name: "test_journal.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xe8, 0x70, 0x1a, 0x4e, 0xea, 0xdb, 0x8e, 0xad, 0x16, 0x9d, 0x60, 0x6, 0x40, 0x7d, 0x54, 0xa8, 0x98, 0x59, 0x2d, 0x70},
},
{
Name: "test_loadext.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x11, 0x37, 0xe3, 0xa9, 0xaa, 0xe9, 0x29, 0x6, 0xb8, 0x28, 0x9f, 0x6c, 0x3d, 0xaa, 0x61, 0xf0, 0xd0, 0x70, 0xf5, 0x5a},
},
{
Name: "test_malloc.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xcf, 0x98, 0xa8, 0xfb, 0x21, 0x82, 0xc0, 0xba, 0xf5, 0xa, 0xd5, 0x79, 0x79, 0xb6, 0x75, 0xbb, 0x70, 0x7a, 0x93, 0xb0},
},
{
Name: "test_multiplex.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x62, 0x45, 0x41, 0xb3, 0x2a, 0x10, 0xd2, 0x1a, 0x2f, 0xd1, 0xa, 0x35, 0xee, 0x66, 0x32, 0xbd, 0xac, 0x55, 0x2d, 0x41},
},
{
Name: "test_multiplex.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0xb7, 0xe1, 0xaf, 0xea, 0x5f, 0xd7, 0x8b, 0x87, 0x58, 0x2, 0x65, 0xf8, 0x4c, 0x81, 0x61, 0x2c, 0xbd, 0x2, 0x5b, 0xaf},
},
{
Name: "test_mutex.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xc9, 0xb4, 0xa2, 0x9a, 0xb7, 0x5c, 0x77, 0xea, 0x5f, 0x36, 0xb5, 0x19, 0x32, 0x56, 0xd7, 0xf, 0xe6, 0x58, 0xe, 0x95},
},
{
Name: "test_onefile.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x69, 0x86, 0x74, 0x41, 0xb8, 0xcc, 0x9a, 0x62, 0x1a, 0xf3, 0x24, 0x13, 0xfc, 0x63, 0xda, 0x80, 0x99, 0x37, 0x64, 0xf4},
},
{
Name: "test_osinst.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x53, 0x14, 0x33, 0x31, 0x3e, 0xe3, 0x6c, 0x7, 0xeb, 0x21, 0xc0, 0x2f, 0x31, 0x15, 0xcb, 0x7a, 0x37, 0x48, 0x6c, 0x79},
},
{
Name: "test_pcache.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x8f, 0xcf, 0xe7, 0xe2, 0x6e, 0x3f, 0xf1, 0x74, 0x96, 0xb8, 0x40, 0xf5, 0xd6, 0x3c, 0x75, 0x78, 0x3a, 0xff, 0x81, 0x62},
},
{Name: "test_quota.c", Mode: filemode.Regular, Hash: plumbing.Hash{
0xe5, 0x90, 0x99, 0x6c, 0xa4, 0xb8, 0x57, 0x4a, 0xb1, 0xe4, 0x18, 0x5d, 0x57, 0x77, 0x56, 0x66, 0x4a, 0xd2, 0x49, 0x5f}}, {Name: "test_quota.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0x2d, 0x7, 0x67, 0xa1, 0x9a, 0xb7, 0xc3, 0xa4, 0x21, 0xcd, 0xba, 0x6a, 0x3, 0x49, 0x20, 0x43, 0x67, 0xc2, 0x2c, 0x81},
},
{
Name: "test_rtree.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xf5, 0x4a, 0xe9, 0xb0, 0x63, 0xbb, 0x73, 0x71, 0x2f, 0xcf, 0xc1, 0xc6, 0x83, 0x2e, 0x2a, 0x50, 0xf6, 0x2a, 0x97, 0xe7},
},
{
Name: "test_schema.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x12, 0x64, 0x44, 0x67, 0x64, 0x7d, 0x51, 0x39, 0x4a, 0x1, 0xf9, 0xfa, 0x60, 0x37, 0x62, 0x98, 0x18, 0x54, 0x66, 0xfd},
},
{
Name: "test_server.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xed, 0x8, 0x18, 0xe6, 0xf6, 0x5f, 0x27, 0x28, 0x2d, 0xc7, 0xb1, 0xc1, 0x90, 0xec, 0x18, 0x8c, 0x89, 0x33, 0x0, 0x2b},
},
{
Name: "test_sqllog.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x4a, 0xa6, 0x8b, 0x7c, 0x42, 0x93, 0x23, 0xb8, 0xee, 0xbe, 0x6c, 0x9c, 0x2d, 0x7, 0xfc, 0x66, 0xd, 0x8d, 0x47, 0xc9},
},
{
Name: "test_stat.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xd4, 0xc9, 0x2, 0xb5, 0xea, 0x11, 0x1a, 0xd5, 0x8a, 0x73, 0x71, 0x12, 0xc2, 0x8f, 0x0, 0x38, 0x43, 0x4c, 0x85, 0xc0},
},
{
Name: "test_superlock.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x93, 0x6f, 0xca, 0xd0, 0xc5, 0x6f, 0x6b, 0xc8, 0x58, 0x9, 0x74, 0x2f, 0x6a, 0xe1, 0xc1, 0xee, 0xb8, 0xb7, 0xd2, 0xf1},
},
{
Name: "test_syscall.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x7c, 0x8, 0x73, 0xc1, 0x6d, 0x84, 0x32, 0x2, 0xf3, 0xe, 0x2d, 0xb9, 0x45, 0x9f, 0xa2, 0x99, 0x75, 0xea, 0x5e, 0x68},
},
{
Name: "test_tclvar.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x12, 0x19, 0x19, 0xc, 0x3, 0x0, 0xfd, 0x5e, 0xc7, 0xa3, 0xc5, 0x84, 0x8, 0xf3, 0x38, 0x43, 0xd2, 0xe, 0xee, 0x15},
},
{
Name: "test_thread.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x2f, 0x93, 0x63, 0xb7, 0x50, 0x1e, 0x51, 0x19, 0x81, 0xfe, 0x32, 0x83, 0x1f, 0xf2, 0xe8, 0xfd, 0x2f, 0x30, 0xc4, 0x93},
},
{
Name: "test_vfs.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xfc, 0xd5, 0x77, 0x43, 0x9c, 0xfd, 0x6c, 0x72, 0xdd, 0xe4, 0x83, 0x58, 0x92, 0x14, 0x20, 0xcf, 0x6e, 0xf1, 0xf8, 0x6d},
},
{
Name: "test_vfstrace.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xa, 0xac, 0xc0, 0x1f, 0xe4, 0x2e, 0x77, 0xfe, 0xb8, 0x58, 0xe4, 0xbe, 0xd0, 0xcb, 0x7e, 0x4, 0xa4, 0x35, 0xb2, 0x10},
},
{
Name: "test_wsd.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x99, 0xe4, 0xa0, 0x56, 0x58, 0x1f, 0x58, 0xf4, 0x53, 0x6f, 0xdb, 0x5a, 0x5d, 0xf7, 0x5c, 0x74, 0x69, 0x8a, 0x81, 0x62},
},
{
Name: "tokenize.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xfa, 0xea, 0x5f, 0x26, 0xc7, 0x9c, 0x5e, 0x18, 0x8f, 0xa8, 0x7f, 0x2f, 0xdf, 0x6f, 0xf7, 0x6a, 0x7a, 0x60, 0x6, 0xc5},
},
{
Name: "trigger.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xf1, 0xff, 0x76, 0x6e, 0x20, 0x2a, 0x45, 0x18, 0xec, 0x10, 0xe5, 0x27, 0x12, 0xc, 0xd3, 0xe, 0x83, 0xfb, 0xd0, 0x34},
},
{
Name: "update.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x3a, 0xb1, 0xab, 0x2a, 0x4b, 0x65, 0xda, 0x3f, 0x19, 0x8c, 0x15, 0x84, 0xd5, 0x4d, 0x36, 0xf1, 0x8c, 0xa1, 0x21, 0x4a},
},
{
Name: "utf.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x6d, 0x5b, 0x1b, 0xfe, 0x40, 0xc, 0x37, 0x48, 0xaa, 0x70, 0xa3, 0xb2, 0xfd, 0x5e, 0xe, 0xac, 0x5f, 0xc0, 0x4d, 0xe2},
},
{
Name: "util.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xd8, 0x3a, 0x63, 0x1, 0x5f, 0xd8, 0x7d, 0xcc, 0x4f, 0xb4, 0x41, 0x66, 0xfa, 0xbf, 0x2e, 0x9b, 0xc9, 0x67, 0x1e, 0xb8},
},
{
Name: "vacuum.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x4a, 0xfb, 0x2c, 0xca, 0x64, 0xdd, 0x60, 0x76, 0x11, 0x22, 0x2c, 0x7, 0x93, 0x2d, 0x12, 0xea, 0xcf, 0xa, 0x2c, 0x22},
},
{
Name: "vdbe.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xf3, 0x43, 0xe1, 0x3d, 0x4e, 0x91, 0x78, 0x4b, 0x15, 0x88, 0x10, 0xc5, 0xb7, 0xd4, 0x46, 0x84, 0xdf, 0xbf, 0xa2, 0xa5},
},
{
Name: "vdbe.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0xfa, 0x7b, 0x31, 0xb7, 0x27, 0xa, 0x90, 0xd4, 0xf6, 0x37, 0x36, 0x5a, 0xfc, 0xc9, 0xbd, 0xa1, 0xd1, 0xb1, 0xe1, 0xd6},
},
{
Name: "vdbeInt.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0x3a, 0x5b, 0x40, 0x28, 0xbb, 0xd6, 0xc9, 0x56, 0x10, 0xd7, 0xc, 0xce, 0x3, 0x69, 0xdf, 0xcd, 0x60, 0x7a, 0xa9, 0x0},
},
{
Name: "vdbeapi.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x7c, 0x86, 0x1e, 0x2d, 0x47, 0x21, 0x8c, 0x91, 0x63, 0x31, 0x77, 0x77, 0xc3, 0x7, 0x21, 0x99, 0xe9, 0xb4, 0x2, 0x80},
},
{
Name: "vdbeaux.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x2c, 0x42, 0x69, 0xa5, 0x9e, 0x6d, 0xbc, 0xe8, 0x67, 0x1c, 0x47, 0x4f, 0x34, 0x61, 0x90, 0xbe, 0x2a, 0xe, 0x18, 0x51},
},
{
Name: "vdbeblob.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x2e, 0x8f, 0xd8, 0xee, 0x74, 0x47, 0xe6, 0x46, 0x46, 0xe3, 0x49, 0x4b, 0x4c, 0x4, 0x1d, 0x3a, 0x4a, 0xbb, 0x8, 0x85},
},
{
Name: "vdbemem.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x8f, 0xc2, 0x22, 0xe2, 0xde, 0x20, 0x50, 0x14, 0x50, 0xec, 0xea, 0x9d, 0x4e, 0xbf, 0xaa, 0xc9, 0x81, 0x4a, 0xae, 0x59},
},
{
Name: "vdbesort.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xfd, 0xfc, 0x4a, 0x79, 0xdd, 0xc9, 0x6e, 0x59, 0x9b, 0x1b, 0xe, 0xeb, 0xac, 0xbd, 0xb8, 0x45, 0xc6, 0x38, 0x13, 0xb2},
},
{
Name: "vdbetrace.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x35, 0x62, 0x77, 0xe8, 0xd2, 0x3b, 0xca, 0xdb, 0x67, 0x6b, 0x59, 0xd1, 0xa4, 0xdc, 0xf8, 0x42, 0xfd, 0xc4, 0xc9, 0x72},
},
{
Name: "vtab.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0x95, 0x82, 0x2, 0xc3, 0x1e, 0x24, 0x15, 0xb, 0x60, 0xf1, 0xa, 0x8a, 0xf, 0x74, 0x41, 0xaf, 0xac, 0x3f, 0xbb, 0x1c},
},
{
Name: "wal.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xe6, 0x42, 0xea, 0x21, 0x5, 0xb5, 0xc5, 0x4a, 0xf3, 0x5, 0x88, 0x9, 0x62, 0x69, 0xab, 0x75, 0xcb, 0xef, 0x8f, 0xf2},
},
{
Name: "wal.h", Mode: filemode.Regular,
Hash: plumbing.Hash{0x9, 0x25, 0x46, 0x35, 0x4b, 0x34, 0xc0, 0xab, 0x3d, 0x20, 0x5, 0x6a, 0x7f, 0x8a, 0x8a, 0x52, 0xe4, 0xd0, 0xb5, 0xf5},
},
{
Name: "walker.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xe7, 0x1e, 0xd2, 0xac, 0x48, 0x4c, 0x91, 0x6c, 0x1c, 0xc1, 0x0, 0x7e, 0x5e, 0x5, 0xda, 0x47, 0x1c, 0xb4, 0x95, 0x99},
},
{
Name: "where.c", Mode: filemode.Regular,
Hash: plumbing.Hash{0xe6, 0x14, 0xf4, 0xa6, 0xd8, 0x64, 0xe7, 0xe, 0xc4, 0x32, 0x8d, 0xb, 0xdb, 0x25, 0x4e, 0x3a, 0xc9, 0xf0, 0xd2, 0x87},
},
},
Hash: plumbing.Hash{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
s: (storer.EncodedObjectStorer)(nil),
m: map[string]*TreeEntry(nil),
}
var obtained Tree
err := obtained.Decode(obj)
c.Assert(err, IsNil)
c.Assert(entriesEquals(obtained.Entries, expected.Entries), Equals, true)
}
func FuzzDecode(f *testing.F) {
f.Fuzz(func(t *testing.T, input []byte) {
obj := &SortReadObject{
t: plumbing.TreeObject,
h: plumbing.ZeroHash,
cont: input,
sz: int64(len(input)),
}
newTree := &Tree{}
newTree.Decode(obj)
})
}
go-git-5.13.2/plumbing/object/treenoder.go 0000664 0000000 0000000 00000006514 14744245500 0020404 0 ustar 00root root 0000000 0000000 package object
import (
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
// A treenoder is a helper type that wraps git trees into merkletrie
// noders.
//
// As a merkletrie noder doesn't understand the concept of modes (e.g.
// file permissions), the treenoder includes the mode of the git tree in
// the hash, so changes in the modes will be detected as modifications
// to the file contents by the merkletrie difftree algorithm. This is
// consistent with how the "git diff-tree" command works.
type treeNoder struct {
parent *Tree // the root node is its own parent
name string // empty string for the root node
mode filemode.FileMode
hash plumbing.Hash
children []noder.Noder // memoized
}
// NewTreeRootNode returns the root node of a Tree
func NewTreeRootNode(t *Tree) noder.Noder {
if t == nil {
return &treeNoder{}
}
return &treeNoder{
parent: t,
name: "",
mode: filemode.Dir,
hash: t.Hash,
}
}
func (t *treeNoder) Skip() bool {
return false
}
func (t *treeNoder) isRoot() bool {
return t.name == ""
}
func (t *treeNoder) String() string {
return "treeNoder <" + t.name + ">"
}
func (t *treeNoder) Hash() []byte {
if t.mode == filemode.Deprecated {
return append(t.hash[:], filemode.Regular.Bytes()...)
}
return append(t.hash[:], t.mode.Bytes()...)
}
func (t *treeNoder) Name() string {
return t.name
}
func (t *treeNoder) IsDir() bool {
return t.mode == filemode.Dir
}
// Children will return the children of a treenoder as treenoders,
// building them from the children of the wrapped git tree.
func (t *treeNoder) Children() ([]noder.Noder, error) {
if t.mode != filemode.Dir {
return noder.NoChildren, nil
}
// children are memoized for efficiency
if t.children != nil {
return t.children, nil
}
// the parent of the returned children will be ourself as a tree if
// we are a not the root treenoder. The root is special as it
// is is own parent.
parent := t.parent
if !t.isRoot() {
var err error
if parent, err = t.parent.Tree(t.name); err != nil {
return nil, err
}
}
var err error
t.children, err = transformChildren(parent)
return t.children, err
}
// Returns the children of a tree as treenoders.
// Efficiency is key here.
func transformChildren(t *Tree) ([]noder.Noder, error) {
var err error
var e TreeEntry
// there will be more tree entries than children in the tree,
// due to submodules and empty directories, but I think it is still
// worth it to pre-allocate the whole array now, even if sometimes
// is bigger than needed.
ret := make([]noder.Noder, 0, len(t.Entries))
walker := NewTreeWalker(t, false, nil) // don't recurse
// don't defer walker.Close() for efficiency reasons.
for {
_, e, err = walker.Next()
if err == io.EOF {
break
}
if err != nil {
walker.Close()
return nil, err
}
ret = append(ret, &treeNoder{
parent: t,
name: e.Name,
mode: e.Mode,
hash: e.Hash,
})
}
walker.Close()
return ret, nil
}
// len(t.tree.Entries) != the number of elements walked by treewalker
// for some reason because of empty directories, submodules, etc, so we
// have to walk here.
func (t *treeNoder) NumChildren() (int, error) {
children, err := t.Children()
if err != nil {
return 0, err
}
return len(children), nil
}
go-git-5.13.2/plumbing/object_test.go 0000664 0000000 0000000 00000002406 14744245500 0017450 0 ustar 00root root 0000000 0000000 package plumbing
import . "gopkg.in/check.v1"
type ObjectSuite struct{}
var _ = Suite(&ObjectSuite{})
func (s *ObjectSuite) TestObjectTypeString(c *C) {
c.Assert(CommitObject.String(), Equals, "commit")
c.Assert(TreeObject.String(), Equals, "tree")
c.Assert(BlobObject.String(), Equals, "blob")
c.Assert(TagObject.String(), Equals, "tag")
c.Assert(REFDeltaObject.String(), Equals, "ref-delta")
c.Assert(OFSDeltaObject.String(), Equals, "ofs-delta")
c.Assert(AnyObject.String(), Equals, "any")
c.Assert(ObjectType(42).String(), Equals, "unknown")
}
func (s *ObjectSuite) TestObjectTypeBytes(c *C) {
c.Assert(CommitObject.Bytes(), DeepEquals, []byte("commit"))
}
func (s *ObjectSuite) TestObjectTypeValid(c *C) {
c.Assert(CommitObject.Valid(), Equals, true)
c.Assert(ObjectType(42).Valid(), Equals, false)
}
func (s *ObjectSuite) TestParseObjectType(c *C) {
for s, e := range map[string]ObjectType{
"commit": CommitObject,
"tree": TreeObject,
"blob": BlobObject,
"tag": TagObject,
"ref-delta": REFDeltaObject,
"ofs-delta": OFSDeltaObject,
} {
t, err := ParseObjectType(s)
c.Assert(err, IsNil)
c.Assert(e, Equals, t)
}
t, err := ParseObjectType("foo")
c.Assert(err, Equals, ErrInvalidType)
c.Assert(t, Equals, InvalidObject)
}
go-git-5.13.2/plumbing/protocol/ 0000775 0000000 0000000 00000000000 14744245500 0016453 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/protocol/packp/ 0000775 0000000 0000000 00000000000 14744245500 0017551 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/protocol/packp/advrefs.go 0000664 0000000 0000000 00000012701 14744245500 0021533 0 ustar 00root root 0000000 0000000 package packp
import (
"fmt"
"sort"
"strings"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/memory"
)
// AdvRefs values represent the information transmitted on an
// advertised-refs message. Values from this type are not zero-value
// safe, use the New function instead.
type AdvRefs struct {
// Prefix stores prefix payloads.
//
// When using this message over (smart) HTTP, you have to add a pktline
// before the whole thing with the following payload:
//
// '# service=$servicename" LF
//
// Moreover, some (all) git HTTP smart servers will send a flush-pkt
// just after the first pkt-line.
//
// To accommodate both situations, the Prefix field allow you to store
// any data you want to send before the actual pktlines. It will also
// be filled up with whatever is found on the line.
Prefix [][]byte
// Head stores the resolved HEAD reference if present.
// This can be present with git-upload-pack, not with git-receive-pack.
Head *plumbing.Hash
// Capabilities are the capabilities.
Capabilities *capability.List
// References are the hash references.
References map[string]plumbing.Hash
// Peeled are the peeled hash references.
Peeled map[string]plumbing.Hash
// Shallows are the shallow object ids.
Shallows []plumbing.Hash
}
// NewAdvRefs returns a pointer to a new AdvRefs value, ready to be used.
func NewAdvRefs() *AdvRefs {
return &AdvRefs{
Prefix: [][]byte{},
Capabilities: capability.NewList(),
References: make(map[string]plumbing.Hash),
Peeled: make(map[string]plumbing.Hash),
Shallows: []plumbing.Hash{},
}
}
func (a *AdvRefs) AddReference(r *plumbing.Reference) error {
switch r.Type() {
case plumbing.SymbolicReference:
v := fmt.Sprintf("%s:%s", r.Name().String(), r.Target().String())
return a.Capabilities.Add(capability.SymRef, v)
case plumbing.HashReference:
a.References[r.Name().String()] = r.Hash()
default:
return plumbing.ErrInvalidType
}
return nil
}
func (a *AdvRefs) AllReferences() (memory.ReferenceStorage, error) {
s := memory.ReferenceStorage{}
if err := a.addRefs(s); err != nil {
return s, plumbing.NewUnexpectedError(err)
}
return s, nil
}
func (a *AdvRefs) addRefs(s storer.ReferenceStorer) error {
for name, hash := range a.References {
ref := plumbing.NewReferenceFromStrings(name, hash.String())
if err := s.SetReference(ref); err != nil {
return err
}
}
if a.supportSymrefs() {
return a.addSymbolicRefs(s)
}
return a.resolveHead(s)
}
// If the server does not support symrefs capability,
// we need to guess the reference where HEAD is pointing to.
//
// Git versions prior to 1.8.4.3 has an special procedure to get
// the reference where is pointing to HEAD:
// - Check if a reference called master exists. If exists and it
// has the same hash as HEAD hash, we can say that HEAD is pointing to master
// - If master does not exists or does not have the same hash as HEAD,
// order references and check in that order if that reference has the same
// hash than HEAD. If yes, set HEAD pointing to that branch hash
// - If no reference is found, throw an error
func (a *AdvRefs) resolveHead(s storer.ReferenceStorer) error {
if a.Head == nil {
return nil
}
ref, err := s.Reference(plumbing.Master)
// check first if HEAD is pointing to master
if err == nil {
ok, err := a.createHeadIfCorrectReference(ref, s)
if err != nil {
return err
}
if ok {
return nil
}
}
if err != nil && err != plumbing.ErrReferenceNotFound {
return err
}
// From here we are trying to guess the branch that HEAD is pointing
refIter, err := s.IterReferences()
if err != nil {
return err
}
var refNames []string
err = refIter.ForEach(func(r *plumbing.Reference) error {
refNames = append(refNames, string(r.Name()))
return nil
})
if err != nil {
return err
}
sort.Strings(refNames)
var headSet bool
for _, refName := range refNames {
ref, err := s.Reference(plumbing.ReferenceName(refName))
if err != nil {
return err
}
ok, err := a.createHeadIfCorrectReference(ref, s)
if err != nil {
return err
}
if ok {
headSet = true
break
}
}
if !headSet {
return plumbing.ErrReferenceNotFound
}
return nil
}
func (a *AdvRefs) createHeadIfCorrectReference(
reference *plumbing.Reference,
s storer.ReferenceStorer) (bool, error) {
if reference.Hash() == *a.Head {
headRef := plumbing.NewSymbolicReference(plumbing.HEAD, reference.Name())
if err := s.SetReference(headRef); err != nil {
return false, err
}
return true, nil
}
return false, nil
}
func (a *AdvRefs) addSymbolicRefs(s storer.ReferenceStorer) error {
for _, symref := range a.Capabilities.Get(capability.SymRef) {
chunks := strings.Split(symref, ":")
if len(chunks) != 2 {
err := fmt.Errorf("bad number of `:` in symref value (%q)", symref)
return plumbing.NewUnexpectedError(err)
}
name := plumbing.ReferenceName(chunks[0])
target := plumbing.ReferenceName(chunks[1])
ref := plumbing.NewSymbolicReference(name, target)
if err := s.SetReference(ref); err != nil {
return nil
}
}
return nil
}
func (a *AdvRefs) supportSymrefs() bool {
return a.Capabilities.Supports(capability.SymRef)
}
// IsEmpty returns true if doesn't contain any reference.
func (a *AdvRefs) IsEmpty() bool {
return a.Head == nil &&
len(a.References) == 0 &&
len(a.Peeled) == 0 &&
len(a.Shallows) == 0
}
go-git-5.13.2/plumbing/protocol/packp/advrefs_decode.go 0000664 0000000 0000000 00000014700 14744245500 0023037 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"encoding/hex"
"errors"
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
)
// Decode reads the next advertised-refs message form its input and
// stores it in the AdvRefs.
func (a *AdvRefs) Decode(r io.Reader) error {
d := newAdvRefsDecoder(r)
return d.Decode(a)
}
type advRefsDecoder struct {
s *pktline.Scanner // a pkt-line scanner from the input stream
line []byte // current pkt-line contents, use parser.nextLine() to make it advance
nLine int // current pkt-line number for debugging, begins at 1
hash plumbing.Hash // last hash read
err error // sticky error, use the parser.error() method to fill this out
data *AdvRefs // parsed data is stored here
}
var (
// ErrEmptyAdvRefs is returned by Decode if it gets an empty advertised
// references message.
ErrEmptyAdvRefs = errors.New("empty advertised-ref message")
// ErrEmptyInput is returned by Decode if the input is empty.
ErrEmptyInput = errors.New("empty input")
)
func newAdvRefsDecoder(r io.Reader) *advRefsDecoder {
return &advRefsDecoder{
s: pktline.NewScanner(r),
}
}
func (d *advRefsDecoder) Decode(v *AdvRefs) error {
d.data = v
for state := decodePrefix; state != nil; {
state = state(d)
}
return d.err
}
type decoderStateFn func(*advRefsDecoder) decoderStateFn
// fills out the parser sticky error
func (d *advRefsDecoder) error(format string, a ...interface{}) {
msg := fmt.Sprintf(
"pkt-line %d: %s", d.nLine,
fmt.Sprintf(format, a...),
)
d.err = NewErrUnexpectedData(msg, d.line)
}
// Reads a new pkt-line from the scanner, makes its payload available as
// p.line and increments p.nLine. A successful invocation returns true,
// otherwise, false is returned and the sticky error is filled out
// accordingly. Trims eols at the end of the payloads.
func (d *advRefsDecoder) nextLine() bool {
d.nLine++
if !d.s.Scan() {
if d.err = d.s.Err(); d.err != nil {
return false
}
if d.nLine == 1 {
d.err = ErrEmptyInput
return false
}
d.error("EOF")
return false
}
d.line = d.s.Bytes()
d.line = bytes.TrimSuffix(d.line, eol)
return true
}
// The HTTP smart prefix is often followed by a flush-pkt.
func decodePrefix(d *advRefsDecoder) decoderStateFn {
if ok := d.nextLine(); !ok {
return nil
}
if !isPrefix(d.line) {
return decodeFirstHash
}
tmp := make([]byte, len(d.line))
copy(tmp, d.line)
d.data.Prefix = append(d.data.Prefix, tmp)
if ok := d.nextLine(); !ok {
return nil
}
if !isFlush(d.line) {
return decodeFirstHash
}
d.data.Prefix = append(d.data.Prefix, pktline.Flush)
if ok := d.nextLine(); !ok {
return nil
}
return decodeFirstHash
}
func isPrefix(payload []byte) bool {
return len(payload) > 0 && payload[0] == '#'
}
// If the first hash is zero, then a no-refs is coming. Otherwise, a
// list-of-refs is coming, and the hash will be followed by the first
// advertised ref.
func decodeFirstHash(p *advRefsDecoder) decoderStateFn {
// If the repository is empty, we receive a flush here (HTTP).
if isFlush(p.line) {
p.err = ErrEmptyAdvRefs
return nil
}
// TODO: Use object-format (when available) for hash size. Git 2.41+
if len(p.line) < hashSize {
p.error("cannot read hash, pkt-line too short")
return nil
}
if _, err := hex.Decode(p.hash[:], p.line[:hashSize]); err != nil {
p.error("invalid hash text: %s", err)
return nil
}
p.line = p.line[hashSize:]
if p.hash.IsZero() {
return decodeSkipNoRefs
}
return decodeFirstRef
}
// Skips SP "capabilities^{}" NUL
func decodeSkipNoRefs(p *advRefsDecoder) decoderStateFn {
if len(p.line) < len(noHeadMark) {
p.error("too short zero-id ref")
return nil
}
if !bytes.HasPrefix(p.line, noHeadMark) {
p.error("malformed zero-id ref")
return nil
}
p.line = p.line[len(noHeadMark):]
return decodeCaps
}
// decode the refname, expects SP refname NULL
func decodeFirstRef(l *advRefsDecoder) decoderStateFn {
if len(l.line) < 3 {
l.error("line too short after hash")
return nil
}
if !bytes.HasPrefix(l.line, sp) {
l.error("no space after hash")
return nil
}
l.line = l.line[1:]
chunks := bytes.SplitN(l.line, null, 2)
if len(chunks) < 2 {
l.error("NULL not found")
return nil
}
ref := chunks[0]
l.line = chunks[1]
if bytes.Equal(ref, []byte(head)) {
l.data.Head = &l.hash
} else {
l.data.References[string(ref)] = l.hash
}
return decodeCaps
}
func decodeCaps(p *advRefsDecoder) decoderStateFn {
if err := p.data.Capabilities.Decode(p.line); err != nil {
p.error("invalid capabilities: %s", err)
return nil
}
return decodeOtherRefs
}
// The refs are either tips (obj-id SP refname) or a peeled (obj-id SP refname^{}).
// If there are no refs, then there might be a shallow or flush-ptk.
func decodeOtherRefs(p *advRefsDecoder) decoderStateFn {
if ok := p.nextLine(); !ok {
return nil
}
if bytes.HasPrefix(p.line, shallow) {
return decodeShallow
}
if len(p.line) == 0 {
return nil
}
saveTo := p.data.References
if bytes.HasSuffix(p.line, peeled) {
p.line = bytes.TrimSuffix(p.line, peeled)
saveTo = p.data.Peeled
}
ref, hash, err := readRef(p.line)
if err != nil {
p.error("%s", err)
return nil
}
saveTo[ref] = hash
return decodeOtherRefs
}
// Reads a ref-name
func readRef(data []byte) (string, plumbing.Hash, error) {
chunks := bytes.Split(data, sp)
switch {
case len(chunks) == 1:
return "", plumbing.ZeroHash, fmt.Errorf("malformed ref data: no space was found")
case len(chunks) > 2:
return "", plumbing.ZeroHash, fmt.Errorf("malformed ref data: more than one space found")
default:
return string(chunks[1]), plumbing.NewHash(string(chunks[0])), nil
}
}
// Keeps reading shallows until a flush-pkt is found
func decodeShallow(p *advRefsDecoder) decoderStateFn {
if !bytes.HasPrefix(p.line, shallow) {
p.error("malformed shallow prefix, found %q... instead", p.line[:len(shallow)])
return nil
}
p.line = bytes.TrimPrefix(p.line, shallow)
if len(p.line) != hashSize {
p.error(fmt.Sprintf(
"malformed shallow hash: wrong length, expected 40 bytes, read %d bytes",
len(p.line)))
return nil
}
text := p.line[:hashSize]
var h plumbing.Hash
if _, err := hex.Decode(h[:], text); err != nil {
p.error("invalid hash text: %s", err)
return nil
}
p.data.Shallows = append(p.data.Shallows, h)
if ok := p.nextLine(); !ok {
return nil
}
if len(p.line) == 0 {
return nil // successful parse of the advertised-refs message
}
return decodeShallow
}
go-git-5.13.2/plumbing/protocol/packp/advrefs_decode_test.go 0000664 0000000 0000000 00000041534 14744245500 0024103 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"io"
"strings"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
. "gopkg.in/check.v1"
)
type AdvRefsDecodeSuite struct{}
var _ = Suite(&AdvRefsDecodeSuite{})
func (s *AdvRefsDecodeSuite) TestEmpty(c *C) {
var buf bytes.Buffer
ar := NewAdvRefs()
c.Assert(ar.Decode(&buf), Equals, ErrEmptyInput)
}
func (s *AdvRefsDecodeSuite) TestEmptyFlush(c *C) {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
e.Flush()
ar := NewAdvRefs()
c.Assert(ar.Decode(&buf), Equals, ErrEmptyAdvRefs)
}
func (s *AdvRefsDecodeSuite) TestEmptyPrefixFlush(c *C) {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
e.EncodeString("# service=git-upload-pack")
e.Flush()
e.Flush()
ar := NewAdvRefs()
c.Assert(ar.Decode(&buf), Equals, ErrEmptyAdvRefs)
}
func (s *AdvRefsDecodeSuite) TestShortForHash(c *C) {
payloads := []string{
"6ecf0ef2c2dffb796",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*too short.*")
}
func (s *AdvRefsDecodeSuite) testDecoderErrorMatches(c *C, input io.Reader, pattern string) {
ar := NewAdvRefs()
c.Assert(ar.Decode(input), ErrorMatches, pattern)
}
func (s *AdvRefsDecodeSuite) TestInvalidFirstHash(c *C) {
payloads := []string{
"6ecf0ef2c2dffb796alberto2219af86ec6584e5 HEAD\x00multi_ack thin-pack\n",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*invalid hash.*")
}
func (s *AdvRefsDecodeSuite) TestZeroId(c *C) {
payloads := []string{
"0000000000000000000000000000000000000000 capabilities^{}\x00multi_ack thin-pack\n",
pktline.FlushString,
}
ar := s.testDecodeOK(c, payloads)
c.Assert(ar.Head, IsNil)
}
func (s *AdvRefsDecodeSuite) testDecodeOK(c *C, payloads []string) *AdvRefs {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(payloads...)
c.Assert(err, IsNil)
ar := NewAdvRefs()
c.Assert(ar.Decode(&buf), IsNil)
return ar
}
func (s *AdvRefsDecodeSuite) TestMalformedZeroId(c *C) {
payloads := []string{
"0000000000000000000000000000000000000000 wrong\x00multi_ack thin-pack\n",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*malformed zero-id.*")
}
func (s *AdvRefsDecodeSuite) TestShortZeroId(c *C) {
payloads := []string{
"0000000000000000000000000000000000000000 capabi",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*too short zero-id.*")
}
func (s *AdvRefsDecodeSuite) TestHead(c *C) {
payloads := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00",
pktline.FlushString,
}
ar := s.testDecodeOK(c, payloads)
c.Assert(*ar.Head, Equals,
plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
}
func (s *AdvRefsDecodeSuite) TestFirstIsNotHead(c *C) {
payloads := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/heads/master\x00",
pktline.FlushString,
}
ar := s.testDecodeOK(c, payloads)
c.Assert(ar.Head, IsNil)
c.Assert(ar.References["refs/heads/master"], Equals,
plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
}
func (s *AdvRefsDecodeSuite) TestShortRef(c *C) {
payloads := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 H",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*too short.*")
}
func (s *AdvRefsDecodeSuite) TestNoNULL(c *C) {
payloads := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEADofs-delta multi_ack",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*NULL not found.*")
}
func (s *AdvRefsDecodeSuite) TestNoSpaceAfterHash(c *C) {
payloads := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5-HEAD\x00",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*no space after hash.*")
}
func (s *AdvRefsDecodeSuite) TestNoCaps(c *C) {
payloads := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00",
pktline.FlushString,
}
ar := s.testDecodeOK(c, payloads)
c.Assert(ar.Capabilities.IsEmpty(), Equals, true)
}
func (s *AdvRefsDecodeSuite) TestCaps(c *C) {
type entry struct {
Name capability.Capability
Values []string
}
for _, test := range [...]struct {
input []string
capabilities []entry
}{{
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00",
pktline.FlushString,
},
capabilities: []entry{},
}, {
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00\n",
pktline.FlushString,
},
capabilities: []entry{},
}, {
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta",
pktline.FlushString,
},
capabilities: []entry{
{
Name: capability.OFSDelta,
Values: []string(nil),
},
},
}, {
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta multi_ack",
pktline.FlushString,
},
capabilities: []entry{
{Name: capability.OFSDelta, Values: []string(nil)},
{Name: capability.MultiACK, Values: []string(nil)},
},
}, {
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta multi_ack\n",
pktline.FlushString,
},
capabilities: []entry{
{Name: capability.OFSDelta, Values: []string(nil)},
{Name: capability.MultiACK, Values: []string(nil)},
},
}, {
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:refs/heads/master agent=foo=bar\n",
pktline.FlushString,
},
capabilities: []entry{
{Name: capability.SymRef, Values: []string{"HEAD:refs/heads/master"}},
{Name: capability.Agent, Values: []string{"foo=bar"}},
},
}, {
input: []string{
"0000000000000000000000000000000000000000 capabilities^{}\x00report-status report-status-v2 delete-refs side-band-64k quiet atomic ofs-delta object-format=sha1 agent=git/2.41.0\n",
pktline.FlushString,
},
capabilities: []entry{
{Name: capability.ReportStatus, Values: []string(nil)},
{Name: capability.ObjectFormat, Values: []string{"sha1"}},
{Name: capability.Agent, Values: []string{"git/2.41.0"}},
},
}} {
ar := s.testDecodeOK(c, test.input)
for _, fixCap := range test.capabilities {
c.Assert(ar.Capabilities.Supports(fixCap.Name), Equals, true,
Commentf("input = %q, capability = %q", test.input, fixCap.Name))
c.Assert(ar.Capabilities.Get(fixCap.Name), DeepEquals, fixCap.Values,
Commentf("input = %q, capability = %q", test.input, fixCap.Name))
}
}
}
func (s *AdvRefsDecodeSuite) TestWithPrefix(c *C) {
payloads := []string{
"# this is a prefix\n",
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta\n",
pktline.FlushString,
}
ar := s.testDecodeOK(c, payloads)
c.Assert(len(ar.Prefix), Equals, 1)
c.Assert(ar.Prefix[0], DeepEquals, []byte("# this is a prefix"))
}
func (s *AdvRefsDecodeSuite) TestWithPrefixAndFlush(c *C) {
payloads := []string{
"# this is a prefix\n",
pktline.FlushString,
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta\n",
pktline.FlushString,
}
ar := s.testDecodeOK(c, payloads)
c.Assert(len(ar.Prefix), Equals, 2)
c.Assert(ar.Prefix[0], DeepEquals, []byte("# this is a prefix"))
c.Assert(ar.Prefix[1], DeepEquals, []byte(pktline.FlushString))
}
func (s *AdvRefsDecodeSuite) TestOtherRefs(c *C) {
for _, test := range [...]struct {
input []string
references map[string]plumbing.Hash
peeled map[string]plumbing.Hash
}{{
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
pktline.FlushString,
},
references: make(map[string]plumbing.Hash),
peeled: make(map[string]plumbing.Hash),
}, {
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
"1111111111111111111111111111111111111111 ref/foo",
pktline.FlushString,
},
references: map[string]plumbing.Hash{
"ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"),
},
peeled: make(map[string]plumbing.Hash),
}, {
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
"1111111111111111111111111111111111111111 ref/foo\n",
pktline.FlushString,
},
references: map[string]plumbing.Hash{
"ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"),
},
peeled: make(map[string]plumbing.Hash),
}, {
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
"1111111111111111111111111111111111111111 ref/foo\n",
"2222222222222222222222222222222222222222 ref/bar",
pktline.FlushString,
},
references: map[string]plumbing.Hash{
"ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"),
"ref/bar": plumbing.NewHash("2222222222222222222222222222222222222222"),
},
peeled: make(map[string]plumbing.Hash),
}, {
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
"1111111111111111111111111111111111111111 ref/foo^{}\n",
pktline.FlushString,
},
references: make(map[string]plumbing.Hash),
peeled: map[string]plumbing.Hash{
"ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"),
},
}, {
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
"1111111111111111111111111111111111111111 ref/foo\n",
"2222222222222222222222222222222222222222 ref/bar^{}",
pktline.FlushString,
},
references: map[string]plumbing.Hash{
"ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"),
},
peeled: map[string]plumbing.Hash{
"ref/bar": plumbing.NewHash("2222222222222222222222222222222222222222"),
},
}, {
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"51b8b4fb32271d39fbdd760397406177b2b0fd36 refs/pull/10/head\n",
"02b5a6031ba7a8cbfde5d65ff9e13ecdbc4a92ca refs/pull/100/head\n",
"c284c212704c43659bf5913656b8b28e32da1621 refs/pull/100/merge\n",
"3d6537dce68c8b7874333a1720958bd8db3ae8ca refs/pull/101/merge\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
pktline.FlushString,
},
references: map[string]plumbing.Hash{
"refs/heads/master": plumbing.NewHash("a6930aaee06755d1bdcfd943fbf614e4d92bb0c7"),
"refs/pull/10/head": plumbing.NewHash("51b8b4fb32271d39fbdd760397406177b2b0fd36"),
"refs/pull/100/head": plumbing.NewHash("02b5a6031ba7a8cbfde5d65ff9e13ecdbc4a92ca"),
"refs/pull/100/merge": plumbing.NewHash("c284c212704c43659bf5913656b8b28e32da1621"),
"refs/pull/101/merge": plumbing.NewHash("3d6537dce68c8b7874333a1720958bd8db3ae8ca"),
"refs/tags/v2.6.11": plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c"),
"refs/tags/v2.6.11-tree": plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c"),
},
peeled: map[string]plumbing.Hash{
"refs/tags/v2.6.11": plumbing.NewHash("c39ae07f393806ccf406ef966e9a15afc43cc36a"),
"refs/tags/v2.6.11-tree": plumbing.NewHash("c39ae07f393806ccf406ef966e9a15afc43cc36a"),
},
}} {
ar := s.testDecodeOK(c, test.input)
comment := Commentf("input = %v\n", test.input)
c.Assert(ar.References, DeepEquals, test.references, comment)
c.Assert(ar.Peeled, DeepEquals, test.peeled, comment)
}
}
func (s *AdvRefsDecodeSuite) TestMalformedOtherRefsNoSpace(c *C) {
payloads := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00multi_ack thin-pack\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8crefs/tags/v2.6.11\n",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*malformed ref data.*")
}
func (s *AdvRefsDecodeSuite) TestMalformedOtherRefsMultipleSpaces(c *C) {
payloads := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00multi_ack thin-pack\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags v2.6.11\n",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*malformed ref data.*")
}
func (s *AdvRefsDecodeSuite) TestShallow(c *C) {
for _, test := range [...]struct {
input []string
shallows []plumbing.Hash
}{{
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
pktline.FlushString,
},
shallows: []plumbing.Hash{},
}, {
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
"shallow 1111111111111111111111111111111111111111\n",
pktline.FlushString,
},
shallows: []plumbing.Hash{plumbing.NewHash("1111111111111111111111111111111111111111")},
}, {
input: []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
"shallow 1111111111111111111111111111111111111111\n",
"shallow 2222222222222222222222222222222222222222\n",
pktline.FlushString,
},
shallows: []plumbing.Hash{
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
},
}} {
ar := s.testDecodeOK(c, test.input)
comment := Commentf("input = %v\n", test.input)
c.Assert(ar.Shallows, DeepEquals, test.shallows, comment)
}
}
func (s *AdvRefsDecodeSuite) TestInvalidShallowHash(c *C) {
payloads := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
"shallow 11111111alcortes111111111111111111111111\n",
"shallow 2222222222222222222222222222222222222222\n",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*invalid hash text.*")
}
func (s *AdvRefsDecodeSuite) TestGarbageAfterShallow(c *C) {
payloads := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
"shallow 1111111111111111111111111111111111111111\n",
"shallow 2222222222222222222222222222222222222222\n",
"b5be40b90dbaa6bd337f3b77de361bfc0723468b refs/tags/v4.4",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*malformed shallow prefix.*")
}
func (s *AdvRefsDecodeSuite) TestMalformedShallowHash(c *C) {
payloads := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
"shallow 1111111111111111111111111111111111111111\n",
"shallow 2222222222222222222222222222222222222222 malformed\n",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*malformed shallow hash.*")
}
func (s *AdvRefsDecodeSuite) TestEOFRefs(c *C) {
input := strings.NewReader("" +
"005b6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n" +
"003fa6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n" +
"00355dc01c595e6c6ec9ccda4f6ffbf614e4d92bb0c7 refs/foo\n",
)
s.testDecoderErrorMatches(c, input, ".*invalid pkt-len.*")
}
func (s *AdvRefsDecodeSuite) TestEOFShallows(c *C) {
input := strings.NewReader("" +
"005b6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n" +
"003fa6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n" +
"00445dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n" +
"0047c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n" +
"0035shallow 1111111111111111111111111111111111111111\n" +
"0034shallow 222222222222222222222222")
s.testDecoderErrorMatches(c, input, ".*unexpected EOF.*")
}
go-git-5.13.2/plumbing/protocol/packp/advrefs_encode.go 0000664 0000000 0000000 00000010420 14744245500 0023044 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"fmt"
"io"
"sort"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
)
// Encode writes the AdvRefs encoding to a writer.
//
// All the payloads will end with a newline character. Capabilities,
// references and shallows are written in alphabetical order, except for
// peeled references that always follow their corresponding references.
func (a *AdvRefs) Encode(w io.Writer) error {
e := newAdvRefsEncoder(w)
return e.Encode(a)
}
type advRefsEncoder struct {
data *AdvRefs // data to encode
pe *pktline.Encoder // where to write the encoded data
firstRefName string // reference name to encode in the first pkt-line (HEAD if present)
firstRefHash plumbing.Hash // hash referenced to encode in the first pkt-line (HEAD if present)
sortedRefs []string // hash references to encode ordered by increasing order
err error // sticky error
}
func newAdvRefsEncoder(w io.Writer) *advRefsEncoder {
return &advRefsEncoder{
pe: pktline.NewEncoder(w),
}
}
func (e *advRefsEncoder) Encode(v *AdvRefs) error {
e.data = v
e.sortRefs()
e.setFirstRef()
for state := encodePrefix; state != nil; {
state = state(e)
}
return e.err
}
func (e *advRefsEncoder) sortRefs() {
if len(e.data.References) > 0 {
refs := make([]string, 0, len(e.data.References))
for refName := range e.data.References {
refs = append(refs, refName)
}
sort.Strings(refs)
e.sortedRefs = refs
}
}
func (e *advRefsEncoder) setFirstRef() {
if e.data.Head != nil {
e.firstRefName = head
e.firstRefHash = *e.data.Head
return
}
if len(e.sortedRefs) > 0 {
refName := e.sortedRefs[0]
e.firstRefName = refName
e.firstRefHash = e.data.References[refName]
}
}
type encoderStateFn func(*advRefsEncoder) encoderStateFn
func encodePrefix(e *advRefsEncoder) encoderStateFn {
for _, p := range e.data.Prefix {
if bytes.Equal(p, pktline.Flush) {
if e.err = e.pe.Flush(); e.err != nil {
return nil
}
continue
}
if e.err = e.pe.Encodef("%s\n", string(p)); e.err != nil {
return nil
}
}
return encodeFirstLine
}
// Adds the first pkt-line payload: head hash, head ref and capabilities.
// If HEAD ref is not found, the first reference ordered in increasing order will be used.
// If there aren't HEAD neither refs, the first line will be "PKT-LINE(zero-id SP "capabilities^{}" NUL capability-list)".
// See: https://github.com/git/git/blob/master/Documentation/technical/pack-protocol.txt
// See: https://github.com/git/git/blob/master/Documentation/technical/protocol-common.txt
func encodeFirstLine(e *advRefsEncoder) encoderStateFn {
const formatFirstLine = "%s %s\x00%s\n"
var firstLine string
capabilities := formatCaps(e.data.Capabilities)
if e.firstRefName == "" {
firstLine = fmt.Sprintf(formatFirstLine, plumbing.ZeroHash.String(), "capabilities^{}", capabilities)
} else {
firstLine = fmt.Sprintf(formatFirstLine, e.firstRefHash.String(), e.firstRefName, capabilities)
}
if e.err = e.pe.EncodeString(firstLine); e.err != nil {
return nil
}
return encodeRefs
}
func formatCaps(c *capability.List) string {
if c == nil {
return ""
}
return c.String()
}
// Adds the (sorted) refs: hash SP refname EOL
// and their peeled refs if any.
func encodeRefs(e *advRefsEncoder) encoderStateFn {
for _, r := range e.sortedRefs {
if r == e.firstRefName {
continue
}
hash := e.data.References[r]
if e.err = e.pe.Encodef("%s %s\n", hash.String(), r); e.err != nil {
return nil
}
if hash, ok := e.data.Peeled[r]; ok {
if e.err = e.pe.Encodef("%s %s^{}\n", hash.String(), r); e.err != nil {
return nil
}
}
}
return encodeShallow
}
// Adds the (sorted) shallows: "shallow" SP hash EOL
func encodeShallow(e *advRefsEncoder) encoderStateFn {
sorted := sortShallows(e.data.Shallows)
for _, hash := range sorted {
if e.err = e.pe.Encodef("shallow %s\n", hash); e.err != nil {
return nil
}
}
return encodeFlush
}
func sortShallows(c []plumbing.Hash) []string {
ret := []string{}
for _, h := range c {
ret = append(ret, h.String())
}
sort.Strings(ret)
return ret
}
func encodeFlush(e *advRefsEncoder) encoderStateFn {
e.err = e.pe.Flush()
return nil
}
go-git-5.13.2/plumbing/protocol/packp/advrefs_encode_test.go 0000664 0000000 0000000 00000017631 14744245500 0024116 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"strings"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
. "gopkg.in/check.v1"
)
type AdvRefsEncodeSuite struct{}
var _ = Suite(&AdvRefsEncodeSuite{})
func testEncode(c *C, input *AdvRefs, expected []byte) {
var buf bytes.Buffer
c.Assert(input.Encode(&buf), IsNil)
obtained := buf.Bytes()
comment := Commentf("\nobtained = %s\nexpected = %s\n", string(obtained), string(expected))
c.Assert(obtained, DeepEquals, expected, comment)
}
func (s *AdvRefsEncodeSuite) TestZeroValue(c *C) {
ar := &AdvRefs{}
expected := pktlines(c,
"0000000000000000000000000000000000000000 capabilities^{}\x00\n",
pktline.FlushString,
)
testEncode(c, ar, expected)
}
func (s *AdvRefsEncodeSuite) TestHead(c *C) {
hash := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
ar := &AdvRefs{
Head: &hash,
}
expected := pktlines(c,
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00\n",
pktline.FlushString,
)
testEncode(c, ar, expected)
}
func (s *AdvRefsEncodeSuite) TestCapsNoHead(c *C) {
capabilities := capability.NewList()
capabilities.Add(capability.MultiACK)
capabilities.Add(capability.OFSDelta)
capabilities.Add(capability.SymRef, "HEAD:/refs/heads/master")
ar := &AdvRefs{
Capabilities: capabilities,
}
expected := pktlines(c,
"0000000000000000000000000000000000000000 capabilities^{}\x00multi_ack ofs-delta symref=HEAD:/refs/heads/master\n",
pktline.FlushString,
)
testEncode(c, ar, expected)
}
func (s *AdvRefsEncodeSuite) TestCapsWithHead(c *C) {
hash := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
capabilities := capability.NewList()
capabilities.Add(capability.MultiACK)
capabilities.Add(capability.OFSDelta)
capabilities.Add(capability.SymRef, "HEAD:/refs/heads/master")
ar := &AdvRefs{
Head: &hash,
Capabilities: capabilities,
}
expected := pktlines(c,
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00multi_ack ofs-delta symref=HEAD:/refs/heads/master\n",
pktline.FlushString,
)
testEncode(c, ar, expected)
}
func (s *AdvRefsEncodeSuite) TestRefs(c *C) {
references := map[string]plumbing.Hash{
"refs/heads/master": plumbing.NewHash("a6930aaee06755d1bdcfd943fbf614e4d92bb0c7"),
"refs/tags/v2.6.12-tree": plumbing.NewHash("1111111111111111111111111111111111111111"),
"refs/tags/v2.7.13-tree": plumbing.NewHash("3333333333333333333333333333333333333333"),
"refs/tags/v2.6.13-tree": plumbing.NewHash("2222222222222222222222222222222222222222"),
"refs/tags/v2.6.11-tree": plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c"),
}
ar := &AdvRefs{
References: references,
}
expected := pktlines(c,
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\x00\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"1111111111111111111111111111111111111111 refs/tags/v2.6.12-tree\n",
"2222222222222222222222222222222222222222 refs/tags/v2.6.13-tree\n",
"3333333333333333333333333333333333333333 refs/tags/v2.7.13-tree\n",
pktline.FlushString,
)
testEncode(c, ar, expected)
}
func (s *AdvRefsEncodeSuite) TestPeeled(c *C) {
references := map[string]plumbing.Hash{
"refs/heads/master": plumbing.NewHash("a6930aaee06755d1bdcfd943fbf614e4d92bb0c7"),
"refs/tags/v2.6.12-tree": plumbing.NewHash("1111111111111111111111111111111111111111"),
"refs/tags/v2.7.13-tree": plumbing.NewHash("3333333333333333333333333333333333333333"),
"refs/tags/v2.6.13-tree": plumbing.NewHash("2222222222222222222222222222222222222222"),
"refs/tags/v2.6.11-tree": plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c"),
}
peeled := map[string]plumbing.Hash{
"refs/tags/v2.7.13-tree": plumbing.NewHash("4444444444444444444444444444444444444444"),
"refs/tags/v2.6.12-tree": plumbing.NewHash("5555555555555555555555555555555555555555"),
}
ar := &AdvRefs{
References: references,
Peeled: peeled,
}
expected := pktlines(c,
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\x00\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"1111111111111111111111111111111111111111 refs/tags/v2.6.12-tree\n",
"5555555555555555555555555555555555555555 refs/tags/v2.6.12-tree^{}\n",
"2222222222222222222222222222222222222222 refs/tags/v2.6.13-tree\n",
"3333333333333333333333333333333333333333 refs/tags/v2.7.13-tree\n",
"4444444444444444444444444444444444444444 refs/tags/v2.7.13-tree^{}\n",
pktline.FlushString,
)
testEncode(c, ar, expected)
}
func (s *AdvRefsEncodeSuite) TestShallow(c *C) {
shallows := []plumbing.Hash{
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("4444444444444444444444444444444444444444"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
}
ar := &AdvRefs{
Shallows: shallows,
}
expected := pktlines(c,
"0000000000000000000000000000000000000000 capabilities^{}\x00\n",
"shallow 1111111111111111111111111111111111111111\n",
"shallow 2222222222222222222222222222222222222222\n",
"shallow 3333333333333333333333333333333333333333\n",
"shallow 4444444444444444444444444444444444444444\n",
pktline.FlushString,
)
testEncode(c, ar, expected)
}
func (s *AdvRefsEncodeSuite) TestAll(c *C) {
hash := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
capabilities := capability.NewList()
capabilities.Add(capability.MultiACK)
capabilities.Add(capability.OFSDelta)
capabilities.Add(capability.SymRef, "HEAD:/refs/heads/master")
references := map[string]plumbing.Hash{
"refs/heads/master": plumbing.NewHash("a6930aaee06755d1bdcfd943fbf614e4d92bb0c7"),
"refs/tags/v2.6.12-tree": plumbing.NewHash("1111111111111111111111111111111111111111"),
"refs/tags/v2.7.13-tree": plumbing.NewHash("3333333333333333333333333333333333333333"),
"refs/tags/v2.6.13-tree": plumbing.NewHash("2222222222222222222222222222222222222222"),
"refs/tags/v2.6.11-tree": plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c"),
}
peeled := map[string]plumbing.Hash{
"refs/tags/v2.7.13-tree": plumbing.NewHash("4444444444444444444444444444444444444444"),
"refs/tags/v2.6.12-tree": plumbing.NewHash("5555555555555555555555555555555555555555"),
}
shallows := []plumbing.Hash{
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("4444444444444444444444444444444444444444"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
}
ar := &AdvRefs{
Head: &hash,
Capabilities: capabilities,
References: references,
Peeled: peeled,
Shallows: shallows,
}
expected := pktlines(c,
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00multi_ack ofs-delta symref=HEAD:/refs/heads/master\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"1111111111111111111111111111111111111111 refs/tags/v2.6.12-tree\n",
"5555555555555555555555555555555555555555 refs/tags/v2.6.12-tree^{}\n",
"2222222222222222222222222222222222222222 refs/tags/v2.6.13-tree\n",
"3333333333333333333333333333333333333333 refs/tags/v2.7.13-tree\n",
"4444444444444444444444444444444444444444 refs/tags/v2.7.13-tree^{}\n",
"shallow 1111111111111111111111111111111111111111\n",
"shallow 2222222222222222222222222222222222222222\n",
"shallow 3333333333333333333333333333333333333333\n",
"shallow 4444444444444444444444444444444444444444\n",
pktline.FlushString,
)
testEncode(c, ar, expected)
}
func (s *AdvRefsEncodeSuite) TestErrorTooLong(c *C) {
references := map[string]plumbing.Hash{
strings.Repeat("a", pktline.MaxPayloadSize): plumbing.NewHash("a6930aaee06755d1bdcfd943fbf614e4d92bb0c7"),
}
ar := &AdvRefs{
References: references,
}
var buf bytes.Buffer
err := ar.Encode(&buf)
c.Assert(err, ErrorMatches, ".*payload is too long.*")
}
go-git-5.13.2/plumbing/protocol/packp/advrefs_test.go 0000664 0000000 0000000 00000030340 14744245500 0022571 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
. "gopkg.in/check.v1"
)
type AdvRefSuite struct{}
var _ = Suite(&AdvRefSuite{})
func (s *AdvRefSuite) TestAddReferenceSymbolic(c *C) {
ref := plumbing.NewSymbolicReference("foo", "bar")
a := NewAdvRefs()
err := a.AddReference(ref)
c.Assert(err, IsNil)
values := a.Capabilities.Get(capability.SymRef)
c.Assert(values, HasLen, 1)
c.Assert(values[0], Equals, "foo:bar")
}
func (s *AdvRefSuite) TestAddReferenceHash(c *C) {
ref := plumbing.NewHashReference("foo", plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c"))
a := NewAdvRefs()
err := a.AddReference(ref)
c.Assert(err, IsNil)
c.Assert(a.References, HasLen, 1)
c.Assert(a.References["foo"].String(), Equals, "5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c")
}
func (s *AdvRefSuite) TestAllReferences(c *C) {
hash := plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c")
a := NewAdvRefs()
err := a.AddReference(plumbing.NewSymbolicReference("foo", "bar"))
c.Assert(err, IsNil)
err = a.AddReference(plumbing.NewHashReference("bar", hash))
c.Assert(err, IsNil)
refs, err := a.AllReferences()
c.Assert(err, IsNil)
iter, err := refs.IterReferences()
c.Assert(err, IsNil)
var count int
iter.ForEach(func(ref *plumbing.Reference) error {
count++
switch ref.Name() {
case "bar":
c.Assert(ref.Hash(), Equals, hash)
case "foo":
c.Assert(ref.Target().String(), Equals, "bar")
}
return nil
})
c.Assert(count, Equals, 2)
}
func (s *AdvRefSuite) TestAllReferencesBadSymref(c *C) {
a := NewAdvRefs()
err := a.Capabilities.Set(capability.SymRef, "foo")
c.Assert(err, IsNil)
_, err = a.AllReferences()
c.Assert(err, NotNil)
}
func (s *AdvRefSuite) TestIsEmpty(c *C) {
a := NewAdvRefs()
c.Assert(a.IsEmpty(), Equals, true)
}
func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToMaster(c *C) {
a := NewAdvRefs()
headHash := plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c")
a.Head = &headHash
ref := plumbing.NewHashReference(plumbing.Master, plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c"))
err := a.AddReference(ref)
c.Assert(err, IsNil)
storage, err := a.AllReferences()
c.Assert(err, IsNil)
head, err := storage.Reference(plumbing.HEAD)
c.Assert(err, IsNil)
c.Assert(head.Target(), Equals, ref.Name())
}
func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToOtherThanMaster(c *C) {
a := NewAdvRefs()
headHash := plumbing.NewHash("0000000000000000000000000000000000000000")
a.Head = &headHash
ref1 := plumbing.NewHashReference(plumbing.Master, plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c"))
ref2 := plumbing.NewHashReference("other/ref", plumbing.NewHash("0000000000000000000000000000000000000000"))
err := a.AddReference(ref1)
c.Assert(err, IsNil)
err = a.AddReference(ref2)
c.Assert(err, IsNil)
storage, err := a.AllReferences()
c.Assert(err, IsNil)
head, err := storage.Reference(plumbing.HEAD)
c.Assert(err, IsNil)
c.Assert(head.Hash(), Equals, ref2.Hash())
}
func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToNoRef(c *C) {
a := NewAdvRefs()
headHash := plumbing.NewHash("0000000000000000000000000000000000000000")
a.Head = &headHash
ref := plumbing.NewHashReference(plumbing.Master, plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c"))
err := a.AddReference(ref)
c.Assert(err, IsNil)
_, err = a.AllReferences()
c.Assert(err, NotNil)
}
func (s *AdvRefSuite) TestNoSymRefCapabilityHeadToNoMasterAlphabeticallyOrdered(c *C) {
a := NewAdvRefs()
headHash := plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c")
a.Head = &headHash
ref1 := plumbing.NewHashReference(plumbing.Master, plumbing.NewHash("0000000000000000000000000000000000000000"))
ref2 := plumbing.NewHashReference("aaaaaaaaaaaaaaa", plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c"))
ref3 := plumbing.NewHashReference("bbbbbbbbbbbbbbb", plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c"))
err := a.AddReference(ref1)
c.Assert(err, IsNil)
err = a.AddReference(ref3)
c.Assert(err, IsNil)
err = a.AddReference(ref2)
c.Assert(err, IsNil)
storage, err := a.AllReferences()
c.Assert(err, IsNil)
head, err := storage.Reference(plumbing.HEAD)
c.Assert(err, IsNil)
c.Assert(head.Target(), Equals, ref2.Name())
}
type AdvRefsDecodeEncodeSuite struct{}
var _ = Suite(&AdvRefsDecodeEncodeSuite{})
func (s *AdvRefsDecodeEncodeSuite) test(c *C, in []string, exp []string, isEmpty bool) {
var err error
var input io.Reader
{
var buf bytes.Buffer
p := pktline.NewEncoder(&buf)
err = p.EncodeString(in...)
c.Assert(err, IsNil)
input = &buf
}
var expected []byte
{
var buf bytes.Buffer
p := pktline.NewEncoder(&buf)
err = p.EncodeString(exp...)
c.Assert(err, IsNil)
expected = buf.Bytes()
}
var obtained []byte
{
ar := NewAdvRefs()
c.Assert(ar.Decode(input), IsNil)
c.Assert(ar.IsEmpty(), Equals, isEmpty)
var buf bytes.Buffer
c.Assert(ar.Encode(&buf), IsNil)
obtained = buf.Bytes()
}
c.Assert(string(obtained), DeepEquals, string(expected))
}
func (s *AdvRefsDecodeEncodeSuite) TestNoHead(c *C) {
input := []string{
"0000000000000000000000000000000000000000 capabilities^{}\x00",
pktline.FlushString,
}
expected := []string{
"0000000000000000000000000000000000000000 capabilities^{}\x00\n",
pktline.FlushString,
}
s.test(c, input, expected, true)
}
func (s *AdvRefsDecodeEncodeSuite) TestNoHeadSmart(c *C) {
input := []string{
"# service=git-upload-pack\n",
"0000000000000000000000000000000000000000 capabilities^{}\x00",
pktline.FlushString,
}
expected := []string{
"# service=git-upload-pack\n",
"0000000000000000000000000000000000000000 capabilities^{}\x00\n",
pktline.FlushString,
}
s.test(c, input, expected, true)
}
func (s *AdvRefsDecodeEncodeSuite) TestNoHeadSmartBug(c *C) {
input := []string{
"# service=git-upload-pack\n",
pktline.FlushString,
"0000000000000000000000000000000000000000 capabilities^{}\x00\n",
pktline.FlushString,
}
expected := []string{
"# service=git-upload-pack\n",
pktline.FlushString,
"0000000000000000000000000000000000000000 capabilities^{}\x00\n",
pktline.FlushString,
}
s.test(c, input, expected, true)
}
func (s *AdvRefsDecodeEncodeSuite) TestRefs(c *C) {
input := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree",
pktline.FlushString,
}
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree\n",
pktline.FlushString,
}
s.test(c, input, expected, false)
}
func (s *AdvRefsDecodeEncodeSuite) TestPeeled(c *C) {
input := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack",
"7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree\n",
"8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
pktline.FlushString,
}
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
"7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree\n",
"8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}\n",
pktline.FlushString,
}
s.test(c, input, expected, false)
}
func (s *AdvRefsDecodeEncodeSuite) TestAll(c *C) {
input := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
"7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree\n",
"8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}",
"shallow 1111111111111111111111111111111111111111",
"shallow 2222222222222222222222222222222222222222\n",
pktline.FlushString,
}
expected := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
"7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree\n",
"8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}\n",
"shallow 1111111111111111111111111111111111111111\n",
"shallow 2222222222222222222222222222222222222222\n",
pktline.FlushString,
}
s.test(c, input, expected, false)
}
func (s *AdvRefsDecodeEncodeSuite) TestAllSmart(c *C) {
input := []string{
"# service=git-upload-pack\n",
pktline.FlushString,
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
"7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree\n",
"8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}\n",
"shallow 1111111111111111111111111111111111111111\n",
"shallow 2222222222222222222222222222222222222222\n",
pktline.FlushString,
}
expected := []string{
"# service=git-upload-pack\n",
pktline.FlushString,
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
"7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree\n",
"8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}\n",
"shallow 1111111111111111111111111111111111111111\n",
"shallow 2222222222222222222222222222222222222222\n",
pktline.FlushString,
}
s.test(c, input, expected, false)
}
func (s *AdvRefsDecodeEncodeSuite) TestAllSmartBug(c *C) {
input := []string{
"# service=git-upload-pack\n",
pktline.FlushString,
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
"7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree\n",
"8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}\n",
"shallow 1111111111111111111111111111111111111111\n",
"shallow 2222222222222222222222222222222222222222\n",
pktline.FlushString,
}
expected := []string{
"# service=git-upload-pack\n",
pktline.FlushString,
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:/refs/heads/master ofs-delta multi_ack\n",
"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
"7777777777777777777777777777777777777777 refs/tags/v2.6.12-tree\n",
"8888888888888888888888888888888888888888 refs/tags/v2.6.12-tree^{}\n",
"shallow 1111111111111111111111111111111111111111\n",
"shallow 2222222222222222222222222222222222222222\n",
pktline.FlushString,
}
s.test(c, input, expected, false)
}
go-git-5.13.2/plumbing/protocol/packp/capability/ 0000775 0000000 0000000 00000000000 14744245500 0021672 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/protocol/packp/capability/capability.go 0000664 0000000 0000000 00000032513 14744245500 0024346 0 ustar 00root root 0000000 0000000 // Package capability defines the server and client capabilities.
package capability
import (
"fmt"
"os"
)
// Capability describes a server or client capability.
type Capability string
func (n Capability) String() string {
return string(n)
}
const (
// MultiACK capability allows the server to return "ACK obj-id continue" as
// soon as it finds a commit that it can use as a common base, between the
// client's wants and the client's have set.
//
// By sending this early, the server can potentially head off the client
// from walking any further down that particular branch of the client's
// repository history. The client may still need to walk down other
// branches, sending have lines for those, until the server has a
// complete cut across the DAG, or the client has said "done".
//
// Without multi_ack, a client sends have lines in --date-order until
// the server has found a common base. That means the client will send
// have lines that are already known by the server to be common, because
// they overlap in time with another branch that the server hasn't found
// a common base on yet.
//
// For example suppose the client has commits in caps that the server
// doesn't and the server has commits in lower case that the client
// doesn't, as in the following diagram:
//
// +---- u ---------------------- x
// / +----- y
// / /
// a -- b -- c -- d -- E -- F
// \
// +--- Q -- R -- S
//
// If the client wants x,y and starts out by saying have F,S, the server
// doesn't know what F,S is. Eventually the client says "have d" and
// the server sends "ACK d continue" to let the client know to stop
// walking down that line (so don't send c-b-a), but it's not done yet,
// it needs a base for x. The client keeps going with S-R-Q, until a
// gets reached, at which point the server has a clear base and it all
// ends.
//
// Without multi_ack the client would have sent that c-b-a chain anyway,
// interleaved with S-R-Q.
MultiACK Capability = "multi_ack"
// MultiACKDetailed is an extension of multi_ack that permits client to
// better understand the server's in-memory state.
MultiACKDetailed Capability = "multi_ack_detailed"
// NoDone should only be used with the smart HTTP protocol. If
// multi_ack_detailed and no-done are both present, then the sender is
// free to immediately send a pack following its first "ACK obj-id ready"
// message.
//
// Without no-done in the smart HTTP protocol, the server session would
// end and the client has to make another trip to send "done" before
// the server can send the pack. no-done removes the last round and
// thus slightly reduces latency.
NoDone Capability = "no-done"
// ThinPack is one with deltas which reference base objects not
// contained within the pack (but are known to exist at the receiving
// end). This can reduce the network traffic significantly, but it
// requires the receiving end to know how to "thicken" these packs by
// adding the missing bases to the pack.
//
// The upload-pack server advertises 'thin-pack' when it can generate
// and send a thin pack. A client requests the 'thin-pack' capability
// when it understands how to "thicken" it, notifying the server that
// it can receive such a pack. A client MUST NOT request the
// 'thin-pack' capability if it cannot turn a thin pack into a
// self-contained pack.
//
// Receive-pack, on the other hand, is assumed by default to be able to
// handle thin packs, but can ask the client not to use the feature by
// advertising the 'no-thin' capability. A client MUST NOT send a thin
// pack if the server advertises the 'no-thin' capability.
//
// The reasons for this asymmetry are historical. The receive-pack
// program did not exist until after the invention of thin packs, so
// historically the reference implementation of receive-pack always
// understood thin packs. Adding 'no-thin' later allowed receive-pack
// to disable the feature in a backwards-compatible manner.
ThinPack Capability = "thin-pack"
// Sideband means that server can send, and client understand multiplexed
// progress reports and error info interleaved with the packfile itself.
//
// These two options are mutually exclusive. A modern client always
// favors Sideband64k.
//
// Either mode indicates that the packfile data will be streamed broken
// up into packets of up to either 1000 bytes in the case of 'side_band',
// or 65520 bytes in the case of 'side_band_64k'. Each packet is made up
// of a leading 4-byte pkt-line length of how much data is in the packet,
// followed by a 1-byte stream code, followed by the actual data.
//
// The stream code can be one of:
//
// 1 - pack data
// 2 - progress messages
// 3 - fatal error message just before stream aborts
//
// The "side-band-64k" capability came about as a way for newer clients
// that can handle much larger packets to request packets that are
// actually crammed nearly full, while maintaining backward compatibility
// for the older clients.
//
// Further, with side-band and its up to 1000-byte messages, it's actually
// 999 bytes of payload and 1 byte for the stream code. With side-band-64k,
// same deal, you have up to 65519 bytes of data and 1 byte for the stream
// code.
//
// The client MUST send only maximum of one of "side-band" and "side-
// band-64k". Server MUST diagnose it as an error if client requests
// both.
Sideband Capability = "side-band"
Sideband64k Capability = "side-band-64k"
// OFSDelta server can send, and client understand PACKv2 with delta
// referring to its base by position in pack rather than by an obj-id. That
// is, they can send/read OBJ_OFS_DELTA (aka type 6) in a packfile.
OFSDelta Capability = "ofs-delta"
// Agent the server may optionally send this capability to notify the client
// that the server is running version `X`. The client may optionally return
// its own agent string by responding with an `agent=Y` capability (but it
// MUST NOT do so if the server did not mention the agent capability). The
// `X` and `Y` strings may contain any printable ASCII characters except
// space (i.e., the byte range 32 < x < 127), and are typically of the form
// "package/version" (e.g., "git/1.8.3.1"). The agent strings are purely
// informative for statistics and debugging purposes, and MUST NOT be used
// to programmatically assume the presence or absence of particular features.
Agent Capability = "agent"
// Shallow capability adds "deepen", "shallow" and "unshallow" commands to
// the fetch-pack/upload-pack protocol so clients can request shallow
// clones.
Shallow Capability = "shallow"
// DeepenSince adds "deepen-since" command to fetch-pack/upload-pack
// protocol so the client can request shallow clones that are cut at a
// specific time, instead of depth. Internally it's equivalent of doing
// "rev-list --max-age=" on the server side. "deepen-since"
// cannot be used with "deepen".
DeepenSince Capability = "deepen-since"
// DeepenNot adds "deepen-not" command to fetch-pack/upload-pack
// protocol so the client can request shallow clones that are cut at a
// specific revision, instead of depth. Internally it's equivalent of
// doing "rev-list --not " on the server side. "deepen-not"
// cannot be used with "deepen", but can be used with "deepen-since".
DeepenNot Capability = "deepen-not"
// DeepenRelative if this capability is requested by the client, the
// semantics of "deepen" command is changed. The "depth" argument is the
// depth from the current shallow boundary, instead of the depth from
// remote refs.
DeepenRelative Capability = "deepen-relative"
// NoProgress the client was started with "git clone -q" or something, and
// doesn't want that side band 2. Basically the client just says "I do not
// wish to receive stream 2 on sideband, so do not send it to me, and if
// you did, I will drop it on the floor anyway". However, the sideband
// channel 3 is still used for error responses.
NoProgress Capability = "no-progress"
// IncludeTag capability is about sending annotated tags if we are
// sending objects they point to. If we pack an object to the client, and
// a tag object points exactly at that object, we pack the tag object too.
// In general this allows a client to get all new annotated tags when it
// fetches a branch, in a single network connection.
//
// Clients MAY always send include-tag, hardcoding it into a request when
// the server advertises this capability. The decision for a client to
// request include-tag only has to do with the client's desires for tag
// data, whether or not a server had advertised objects in the
// refs/tags/* namespace.
//
// Servers MUST pack the tags if their referrant is packed and the client
// has requested include-tags.
//
// Clients MUST be prepared for the case where a server has ignored
// include-tag and has not actually sent tags in the pack. In such
// cases the client SHOULD issue a subsequent fetch to acquire the tags
// that include-tag would have otherwise given the client.
//
// The server SHOULD send include-tag, if it supports it, regardless
// of whether or not there are tags available.
IncludeTag Capability = "include-tag"
// ReportStatus the receive-pack process can receive a 'report-status'
// capability, which tells it that the client wants a report of what
// happened after a packfile upload and reference update. If the pushing
// client requests this capability, after unpacking and updating references
// the server will respond with whether the packfile unpacked successfully
// and if each reference was updated successfully. If any of those were not
// successful, it will send back an error message. See pack-protocol.txt
// for example messages.
ReportStatus Capability = "report-status"
// DeleteRefs If the server sends back this capability, it means that
// it is capable of accepting a zero-id value as the target
// value of a reference update. It is not sent back by the client, it
// simply informs the client that it can be sent zero-id values
// to delete references
DeleteRefs Capability = "delete-refs"
// Quiet If the receive-pack server advertises this capability, it is
// capable of silencing human-readable progress output which otherwise may
// be shown when processing the received pack. A send-pack client should
// respond with the 'quiet' capability to suppress server-side progress
// reporting if the local progress reporting is also being suppressed
// (e.g., via `push -q`, or if stderr does not go to a tty).
Quiet Capability = "quiet"
// Atomic If the server sends this capability it is capable of accepting
// atomic pushes. If the pushing client requests this capability, the server
// will update the refs in one atomic transaction. Either all refs are
// updated or none.
Atomic Capability = "atomic"
// PushOptions If the server sends this capability it is able to accept
// push options after the update commands have been sent, but before the
// packfile is streamed. If the pushing client requests this capability,
// the server will pass the options to the pre- and post- receive hooks
// that process this push request.
PushOptions Capability = "push-options"
// AllowTipSHA1InWant if the upload-pack server advertises this capability,
// fetch-pack may send "want" lines with SHA-1s that exist at the server but
// are not advertised by upload-pack.
AllowTipSHA1InWant Capability = "allow-tip-sha1-in-want"
// AllowReachableSHA1InWant if the upload-pack server advertises this
// capability, fetch-pack may send "want" lines with SHA-1s that exist at
// the server but are not advertised by upload-pack.
AllowReachableSHA1InWant Capability = "allow-reachable-sha1-in-want"
// PushCert the receive-pack server that advertises this capability is
// willing to accept a signed push certificate, and asks the to be
// included in the push certificate. A send-pack client MUST NOT
// send a push-cert packet unless the receive-pack server advertises
// this capability.
PushCert Capability = "push-cert"
// SymRef symbolic reference support for better negotiation.
SymRef Capability = "symref"
// ObjectFormat takes a hash algorithm as an argument, indicates that the
// server supports the given hash algorithms.
ObjectFormat Capability = "object-format"
// Filter if present, fetch-pack may send "filter" commands to request a
// partial clone or partial fetch and request that the server omit various objects from the packfile
Filter Capability = "filter"
)
const userAgent = "go-git/5.x"
// DefaultAgent provides the user agent string.
func DefaultAgent() string {
if envUserAgent, ok := os.LookupEnv("GO_GIT_USER_AGENT_EXTRA"); ok {
return fmt.Sprintf("%s %s", userAgent, envUserAgent)
}
return userAgent
}
var known = map[Capability]bool{
MultiACK: true, MultiACKDetailed: true, NoDone: true, ThinPack: true,
Sideband: true, Sideband64k: true, OFSDelta: true, Agent: true,
Shallow: true, DeepenSince: true, DeepenNot: true, DeepenRelative: true,
NoProgress: true, IncludeTag: true, ReportStatus: true, DeleteRefs: true,
Quiet: true, Atomic: true, PushOptions: true, AllowTipSHA1InWant: true,
AllowReachableSHA1InWant: true, PushCert: true, SymRef: true,
ObjectFormat: true, Filter: true,
}
var requiresArgument = map[Capability]bool{
Agent: true, PushCert: true, SymRef: true, ObjectFormat: true,
}
var multipleArgument = map[Capability]bool{
SymRef: true,
}
go-git-5.13.2/plumbing/protocol/packp/capability/capability_test.go 0000664 0000000 0000000 00000000737 14744245500 0025410 0 ustar 00root root 0000000 0000000 package capability
import (
"fmt"
"os"
check "gopkg.in/check.v1"
)
var _ = check.Suite(&SuiteCapabilities{})
func (s *SuiteCapabilities) TestDefaultAgent(c *check.C) {
os.Unsetenv("GO_GIT_USER_AGENT_EXTRA")
ua := DefaultAgent()
c.Assert(ua, check.Equals, userAgent)
}
func (s *SuiteCapabilities) TestEnvAgent(c *check.C) {
os.Setenv("GO_GIT_USER_AGENT_EXTRA", "abc xyz")
ua := DefaultAgent()
c.Assert(ua, check.Equals, fmt.Sprintf("%s %s", userAgent, "abc xyz"))
}
go-git-5.13.2/plumbing/protocol/packp/capability/list.go 0000664 0000000 0000000 00000010171 14744245500 0023174 0 ustar 00root root 0000000 0000000 package capability
import (
"bytes"
"errors"
"fmt"
"strings"
)
var (
// ErrArgumentsRequired is returned if no arguments are giving with a
// capability that requires arguments
ErrArgumentsRequired = errors.New("arguments required")
// ErrArguments is returned if arguments are given with a capabilities that
// not supports arguments
ErrArguments = errors.New("arguments not allowed")
// ErrEmptyArgument is returned when an empty value is given
ErrEmptyArgument = errors.New("empty argument")
// ErrMultipleArguments multiple argument given to a capabilities that not
// support it
ErrMultipleArguments = errors.New("multiple arguments not allowed")
)
// List represents a list of capabilities
type List struct {
m map[Capability]*entry
sort []string
}
type entry struct {
Name Capability
Values []string
}
// NewList returns a new List of capabilities
func NewList() *List {
return &List{
m: make(map[Capability]*entry),
}
}
// IsEmpty returns true if the List is empty
func (l *List) IsEmpty() bool {
return len(l.sort) == 0
}
// Decode decodes list of capabilities from raw into the list
func (l *List) Decode(raw []byte) error {
// git 1.x receive pack used to send a leading space on its
// git-receive-pack capabilities announcement. We just trim space to be
// tolerant to space changes in different versions.
raw = bytes.TrimSpace(raw)
if len(raw) == 0 {
return nil
}
for _, data := range bytes.Split(raw, []byte{' '}) {
pair := bytes.SplitN(data, []byte{'='}, 2)
c := Capability(pair[0])
if len(pair) == 1 {
if err := l.Add(c); err != nil {
return err
}
continue
}
if err := l.Add(c, string(pair[1])); err != nil {
return err
}
}
return nil
}
// Get returns the values for a capability
func (l *List) Get(capability Capability) []string {
if _, ok := l.m[capability]; !ok {
return nil
}
return l.m[capability].Values
}
// Set sets a capability removing the previous values
func (l *List) Set(capability Capability, values ...string) error {
if _, ok := l.m[capability]; ok {
l.m[capability].Values = l.m[capability].Values[:0]
}
return l.Add(capability, values...)
}
// Add adds a capability, values are optional
func (l *List) Add(c Capability, values ...string) error {
if err := l.validate(c, values); err != nil {
return err
}
if !l.Supports(c) {
l.m[c] = &entry{Name: c}
l.sort = append(l.sort, c.String())
}
if len(values) == 0 {
return nil
}
if known[c] && !multipleArgument[c] && len(l.m[c].Values) > 0 {
return ErrMultipleArguments
}
l.m[c].Values = append(l.m[c].Values, values...)
return nil
}
func (l *List) validateNoEmptyArgs(values []string) error {
for _, v := range values {
if v == "" {
return ErrEmptyArgument
}
}
return nil
}
func (l *List) validate(c Capability, values []string) error {
if !known[c] {
return l.validateNoEmptyArgs(values)
}
if requiresArgument[c] && len(values) == 0 {
return ErrArgumentsRequired
}
if !requiresArgument[c] && len(values) != 0 {
return ErrArguments
}
if !multipleArgument[c] && len(values) > 1 {
return ErrMultipleArguments
}
return l.validateNoEmptyArgs(values)
}
// Supports returns true if capability is present
func (l *List) Supports(capability Capability) bool {
_, ok := l.m[capability]
return ok
}
// Delete deletes a capability from the List
func (l *List) Delete(capability Capability) {
if !l.Supports(capability) {
return
}
delete(l.m, capability)
for i, c := range l.sort {
if c != string(capability) {
continue
}
l.sort = append(l.sort[:i], l.sort[i+1:]...)
return
}
}
// All returns a slice with all defined capabilities.
func (l *List) All() []Capability {
var cs []Capability
for _, key := range l.sort {
cs = append(cs, Capability(key))
}
return cs
}
// String generates the capabilities strings, the capabilities are sorted in
// insertion order
func (l *List) String() string {
var o []string
for _, key := range l.sort {
cap := l.m[Capability(key)]
if len(cap.Values) == 0 {
o = append(o, key)
continue
}
for _, value := range cap.Values {
o = append(o, fmt.Sprintf("%s=%s", key, value))
}
}
return strings.Join(o, " ")
}
go-git-5.13.2/plumbing/protocol/packp/capability/list_test.go 0000664 0000000 0000000 00000013223 14744245500 0024234 0 ustar 00root root 0000000 0000000 package capability
import (
"testing"
check "gopkg.in/check.v1"
)
func Test(t *testing.T) { check.TestingT(t) }
type SuiteCapabilities struct{}
var _ = check.Suite(&SuiteCapabilities{})
func (s *SuiteCapabilities) TestIsEmpty(c *check.C) {
cap := NewList()
c.Assert(cap.IsEmpty(), check.Equals, true)
}
func (s *SuiteCapabilities) TestDecode(c *check.C) {
cap := NewList()
err := cap.Decode([]byte("symref=foo symref=qux thin-pack"))
c.Assert(err, check.IsNil)
c.Assert(cap.m, check.HasLen, 2)
c.Assert(cap.Get(SymRef), check.DeepEquals, []string{"foo", "qux"})
c.Assert(cap.Get(ThinPack), check.IsNil)
}
func (s *SuiteCapabilities) TestDecodeWithLeadingSpace(c *check.C) {
cap := NewList()
err := cap.Decode([]byte(" report-status"))
c.Assert(err, check.IsNil)
c.Assert(cap.m, check.HasLen, 1)
c.Assert(cap.Supports(ReportStatus), check.Equals, true)
}
func (s *SuiteCapabilities) TestDecodeEmpty(c *check.C) {
cap := NewList()
err := cap.Decode(nil)
c.Assert(err, check.IsNil)
c.Assert(cap, check.DeepEquals, NewList())
}
func (s *SuiteCapabilities) TestDecodeWithErrArguments(c *check.C) {
cap := NewList()
err := cap.Decode([]byte("thin-pack=foo"))
c.Assert(err, check.Equals, ErrArguments)
}
func (s *SuiteCapabilities) TestDecodeWithEqual(c *check.C) {
cap := NewList()
err := cap.Decode([]byte("agent=foo=bar"))
c.Assert(err, check.IsNil)
c.Assert(cap.m, check.HasLen, 1)
c.Assert(cap.Get(Agent), check.DeepEquals, []string{"foo=bar"})
}
func (s *SuiteCapabilities) TestDecodeWithUnknownCapability(c *check.C) {
cap := NewList()
err := cap.Decode([]byte("foo"))
c.Assert(err, check.IsNil)
c.Assert(cap.Supports(Capability("foo")), check.Equals, true)
}
func (s *SuiteCapabilities) TestDecodeWithUnknownCapabilityWithArgument(c *check.C) {
cap := NewList()
err := cap.Decode([]byte("oldref=HEAD:refs/heads/v2 thin-pack"))
c.Assert(err, check.IsNil)
c.Assert(cap.m, check.HasLen, 2)
c.Assert(cap.Get("oldref"), check.DeepEquals, []string{"HEAD:refs/heads/v2"})
c.Assert(cap.Get(ThinPack), check.IsNil)
}
func (s *SuiteCapabilities) TestDecodeWithUnknownCapabilityWithMultipleArgument(c *check.C) {
cap := NewList()
err := cap.Decode([]byte("foo=HEAD:refs/heads/v2 foo=HEAD:refs/heads/v1 thin-pack"))
c.Assert(err, check.IsNil)
c.Assert(cap.m, check.HasLen, 2)
c.Assert(cap.Get("foo"), check.DeepEquals, []string{"HEAD:refs/heads/v2", "HEAD:refs/heads/v1"})
c.Assert(cap.Get(ThinPack), check.IsNil)
}
func (s *SuiteCapabilities) TestString(c *check.C) {
cap := NewList()
cap.Set(Agent, "bar")
cap.Set(SymRef, "foo:qux")
cap.Set(ThinPack)
c.Assert(cap.String(), check.Equals, "agent=bar symref=foo:qux thin-pack")
}
func (s *SuiteCapabilities) TestStringSort(c *check.C) {
cap := NewList()
cap.Set(Agent, "bar")
cap.Set(SymRef, "foo:qux")
cap.Set(ThinPack)
c.Assert(cap.String(), check.Equals, "agent=bar symref=foo:qux thin-pack")
}
func (s *SuiteCapabilities) TestSet(c *check.C) {
cap := NewList()
err := cap.Add(SymRef, "foo", "qux")
c.Assert(err, check.IsNil)
err = cap.Set(SymRef, "bar")
c.Assert(err, check.IsNil)
c.Assert(cap.m, check.HasLen, 1)
c.Assert(cap.Get(SymRef), check.DeepEquals, []string{"bar"})
}
func (s *SuiteCapabilities) TestSetEmpty(c *check.C) {
cap := NewList()
err := cap.Set(Agent, "bar")
c.Assert(err, check.IsNil)
c.Assert(cap.Get(Agent), check.HasLen, 1)
}
func (s *SuiteCapabilities) TestSetDuplicate(c *check.C) {
cap := NewList()
err := cap.Set(Agent, "baz")
c.Assert(err, check.IsNil)
err = cap.Set(Agent, "bar")
c.Assert(err, check.IsNil)
c.Assert(cap.String(), check.Equals, "agent=bar")
}
func (s *SuiteCapabilities) TestGetEmpty(c *check.C) {
cap := NewList()
c.Assert(cap.Get(Agent), check.HasLen, 0)
}
func (s *SuiteCapabilities) TestDelete(c *check.C) {
cap := NewList()
cap.Delete(SymRef)
err := cap.Add(Sideband)
c.Assert(err, check.IsNil)
err = cap.Set(SymRef, "bar")
c.Assert(err, check.IsNil)
err = cap.Set(Sideband64k)
c.Assert(err, check.IsNil)
cap.Delete(SymRef)
c.Assert(cap.String(), check.Equals, "side-band side-band-64k")
}
func (s *SuiteCapabilities) TestAdd(c *check.C) {
cap := NewList()
err := cap.Add(SymRef, "foo", "qux")
c.Assert(err, check.IsNil)
err = cap.Add(ThinPack)
c.Assert(err, check.IsNil)
c.Assert(cap.String(), check.Equals, "symref=foo symref=qux thin-pack")
}
func (s *SuiteCapabilities) TestAddUnknownCapability(c *check.C) {
cap := NewList()
err := cap.Add(Capability("foo"))
c.Assert(err, check.IsNil)
c.Assert(cap.Supports(Capability("foo")), check.Equals, true)
}
func (s *SuiteCapabilities) TestAddErrArgumentsRequired(c *check.C) {
cap := NewList()
err := cap.Add(SymRef)
c.Assert(err, check.Equals, ErrArgumentsRequired)
}
func (s *SuiteCapabilities) TestAddErrArgumentsNotAllowed(c *check.C) {
cap := NewList()
err := cap.Add(OFSDelta, "foo")
c.Assert(err, check.Equals, ErrArguments)
}
func (s *SuiteCapabilities) TestAddErrArguments(c *check.C) {
cap := NewList()
err := cap.Add(SymRef, "")
c.Assert(err, check.Equals, ErrEmptyArgument)
}
func (s *SuiteCapabilities) TestAddErrMultipleArguments(c *check.C) {
cap := NewList()
err := cap.Add(Agent, "foo")
c.Assert(err, check.IsNil)
err = cap.Add(Agent, "bar")
c.Assert(err, check.Equals, ErrMultipleArguments)
}
func (s *SuiteCapabilities) TestAddErrMultipleArgumentsAtTheSameTime(c *check.C) {
cap := NewList()
err := cap.Add(Agent, "foo", "bar")
c.Assert(err, check.Equals, ErrMultipleArguments)
}
func (s *SuiteCapabilities) TestAll(c *check.C) {
cap := NewList()
c.Assert(NewList().All(), check.IsNil)
cap.Add(Agent, "foo")
c.Assert(cap.All(), check.DeepEquals, []Capability{Agent})
cap.Add(OFSDelta)
c.Assert(cap.All(), check.DeepEquals, []Capability{Agent, OFSDelta})
}
go-git-5.13.2/plumbing/protocol/packp/common.go 0000664 0000000 0000000 00000002624 14744245500 0021374 0 ustar 00root root 0000000 0000000 package packp
import (
"fmt"
)
type stateFn func() stateFn
const (
// common
hashSize = 40
// advrefs
head = "HEAD"
noHead = "capabilities^{}"
)
var (
// common
sp = []byte(" ")
eol = []byte("\n")
// advertised-refs
null = []byte("\x00")
peeled = []byte("^{}")
noHeadMark = []byte(" capabilities^{}\x00")
// upload-request
want = []byte("want ")
shallow = []byte("shallow ")
deepen = []byte("deepen")
deepenCommits = []byte("deepen ")
deepenSince = []byte("deepen-since ")
deepenReference = []byte("deepen-not ")
// shallow-update
unshallow = []byte("unshallow ")
// server-response
ack = []byte("ACK")
nak = []byte("NAK")
// updreq
shallowNoSp = []byte("shallow")
)
func isFlush(payload []byte) bool {
return len(payload) == 0
}
var (
// ErrNilWriter is returned when a nil writer is passed to the encoder.
ErrNilWriter = fmt.Errorf("nil writer")
)
// ErrUnexpectedData represents an unexpected data decoding a message
type ErrUnexpectedData struct {
Msg string
Data []byte
}
// NewErrUnexpectedData returns a new ErrUnexpectedData containing the data and
// the message given
func NewErrUnexpectedData(msg string, data []byte) error {
return &ErrUnexpectedData{Msg: msg, Data: data}
}
func (err *ErrUnexpectedData) Error() string {
if len(err.Data) == 0 {
return err.Msg
}
return fmt.Sprintf("%s (%s)", err.Msg, err.Data)
}
go-git-5.13.2/plumbing/protocol/packp/common_test.go 0000664 0000000 0000000 00000001220 14744245500 0022422 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"io"
"testing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
// returns a byte slice with the pkt-lines for the given payloads.
func pktlines(c *C, payloads ...string) []byte {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(payloads...)
c.Assert(err, IsNil, Commentf("building pktlines for %v\n", payloads))
return buf.Bytes()
}
func toPktLines(c *C, payloads []string) io.Reader {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(payloads...)
c.Assert(err, IsNil)
return &buf
}
go-git-5.13.2/plumbing/protocol/packp/doc.go 0000664 0000000 0000000 00000064466 14744245500 0020665 0 ustar 00root root 0000000 0000000 package packp
/*
A nice way to trace the real data transmitted and received by git, use:
GIT_TRACE_PACKET=true git ls-remote http://github.com/src-d/go-git
GIT_TRACE_PACKET=true git clone http://github.com/src-d/go-git
Here follows a copy of the current protocol specification at the time of
this writing.
(Please notice that most http git servers will add a flush-pkt after the
first pkt-line when using HTTP smart.)
Documentation Common to Pack and Http Protocols
===============================================
ABNF Notation
-------------
ABNF notation as described by RFC 5234 is used within the protocol documents,
except the following replacement core rules are used:
----
HEXDIG = DIGIT / "a" / "b" / "c" / "d" / "e" / "f"
----
We also define the following common rules:
----
NUL = %x00
zero-id = 40*"0"
obj-id = 40*(HEXDIGIT)
refname = "HEAD"
refname /= "refs/"
----
A refname is a hierarchical octet string beginning with "refs/" and
not violating the 'git-check-ref-format' command's validation rules.
More specifically, they:
. They can include slash `/` for hierarchical (directory)
grouping, but no slash-separated component can begin with a
dot `.`.
. They must contain at least one `/`. This enforces the presence of a
category like `heads/`, `tags/` etc. but the actual names are not
restricted.
. They cannot have two consecutive dots `..` anywhere.
. They cannot have ASCII control characters (i.e. bytes whose
values are lower than \040, or \177 `DEL`), space, tilde `~`,
caret `^`, colon `:`, question-mark `?`, asterisk `*`,
or open bracket `[` anywhere.
. They cannot end with a slash `/` or a dot `.`.
. They cannot end with the sequence `.lock`.
. They cannot contain a sequence `@{`.
. They cannot contain a `\\`.
pkt-line Format
---------------
Much (but not all) of the payload is described around pkt-lines.
A pkt-line is a variable length binary string. The first four bytes
of the line, the pkt-len, indicates the total length of the line,
in hexadecimal. The pkt-len includes the 4 bytes used to contain
the length's hexadecimal representation.
A pkt-line MAY contain binary data, so implementors MUST ensure
pkt-line parsing/formatting routines are 8-bit clean.
A non-binary line SHOULD BE terminated by an LF, which if present
MUST be included in the total length. Receivers MUST treat pkt-lines
with non-binary data the same whether or not they contain the trailing
LF (stripping the LF if present, and not complaining when it is
missing).
The maximum length of a pkt-line's data component is 65516 bytes.
Implementations MUST NOT send pkt-line whose length exceeds 65520
(65516 bytes of payload + 4 bytes of length data).
Implementations SHOULD NOT send an empty pkt-line ("0004").
A pkt-line with a length field of 0 ("0000"), called a flush-pkt,
is a special case and MUST be handled differently than an empty
pkt-line ("0004").
----
pkt-line = data-pkt / flush-pkt
data-pkt = pkt-len pkt-payload
pkt-len = 4*(HEXDIG)
pkt-payload = (pkt-len - 4)*(OCTET)
flush-pkt = "0000"
----
Examples (as C-style strings):
----
pkt-line actual value
---------------------------------
"0006a\n" "a\n"
"0005a" "a"
"000bfoobar\n" "foobar\n"
"0004" ""
----
Packfile transfer protocols
===========================
Git supports transferring data in packfiles over the ssh://, git://, http:// and
file:// transports. There exist two sets of protocols, one for pushing
data from a client to a server and another for fetching data from a
server to a client. The three transports (ssh, git, file) use the same
protocol to transfer data. http is documented in http-protocol.txt.
The processes invoked in the canonical Git implementation are 'upload-pack'
on the server side and 'fetch-pack' on the client side for fetching data;
then 'receive-pack' on the server and 'send-pack' on the client for pushing
data. The protocol functions to have a server tell a client what is
currently on the server, then for the two to negotiate the smallest amount
of data to send in order to fully update one or the other.
pkt-line Format
---------------
The descriptions below build on the pkt-line format described in
protocol-common.txt. When the grammar indicate `PKT-LINE(...)`, unless
otherwise noted the usual pkt-line LF rules apply: the sender SHOULD
include a LF, but the receiver MUST NOT complain if it is not present.
Transports
----------
There are three transports over which the packfile protocol is
initiated. The Git transport is a simple, unauthenticated server that
takes the command (almost always 'upload-pack', though Git
servers can be configured to be globally writable, in which 'receive-
pack' initiation is also allowed) with which the client wishes to
communicate and executes it and connects it to the requesting
process.
In the SSH transport, the client just runs the 'upload-pack'
or 'receive-pack' process on the server over the SSH protocol and then
communicates with that invoked process over the SSH connection.
The file:// transport runs the 'upload-pack' or 'receive-pack'
process locally and communicates with it over a pipe.
Git Transport
-------------
The Git transport starts off by sending the command and repository
on the wire using the pkt-line format, followed by a NUL byte and a
hostname parameter, terminated by a NUL byte.
0032git-upload-pack /project.git\0host=myserver.com\0
--
git-proto-request = request-command SP pathname NUL [ host-parameter NUL ]
request-command = "git-upload-pack" / "git-receive-pack" /
"git-upload-archive" ; case sensitive
pathname = *( %x01-ff ) ; exclude NUL
host-parameter = "host=" hostname [ ":" port ]
--
Only host-parameter is allowed in the git-proto-request. Clients
MUST NOT attempt to send additional parameters. It is used for the
git-daemon name based virtual hosting. See --interpolated-path
option to git daemon, with the %H/%CH format characters.
Basically what the Git client is doing to connect to an 'upload-pack'
process on the server side over the Git protocol is this:
$ echo -e -n \
"0039git-upload-pack /schacon/gitbook.git\0host=example.com\0" |
nc -v example.com 9418
If the server refuses the request for some reasons, it could abort
gracefully with an error message.
----
error-line = PKT-LINE("ERR" SP explanation-text)
----
SSH Transport
-------------
Initiating the upload-pack or receive-pack processes over SSH is
executing the binary on the server via SSH remote execution.
It is basically equivalent to running this:
$ ssh git.example.com "git-upload-pack '/project.git'"
For a server to support Git pushing and pulling for a given user over
SSH, that user needs to be able to execute one or both of those
commands via the SSH shell that they are provided on login. On some
systems, that shell access is limited to only being able to run those
two commands, or even just one of them.
In an ssh:// format URI, it's absolute in the URI, so the '/' after
the host name (or port number) is sent as an argument, which is then
read by the remote git-upload-pack exactly as is, so it's effectively
an absolute path in the remote filesystem.
git clone ssh://user@example.com/project.git
|
v
ssh user@example.com "git-upload-pack '/project.git'"
In a "user@host:path" format URI, its relative to the user's home
directory, because the Git client will run:
git clone user@example.com:project.git
|
v
ssh user@example.com "git-upload-pack 'project.git'"
The exception is if a '~' is used, in which case
we execute it without the leading '/'.
ssh://user@example.com/~alice/project.git,
|
v
ssh user@example.com "git-upload-pack '~alice/project.git'"
A few things to remember here:
- The "command name" is spelled with dash (e.g. git-upload-pack), but
this can be overridden by the client;
- The repository path is always quoted with single quotes.
Fetching Data From a Server
---------------------------
When one Git repository wants to get data that a second repository
has, the first can 'fetch' from the second. This operation determines
what data the server has that the client does not then streams that
data down to the client in packfile format.
Reference Discovery
-------------------
When the client initially connects the server will immediately respond
with a listing of each reference it has (all branches and tags) along
with the object name that each reference currently points to.
$ echo -e -n "0039git-upload-pack /schacon/gitbook.git\0host=example.com\0" |
nc -v example.com 9418
00887217a7c7e582c46cec22a130adf4b9d7d950fba0 HEAD\0multi_ack thin-pack
side-band side-band-64k ofs-delta shallow no-progress include-tag
00441d3fcd5ced445d1abc402225c0b8a1299641f497 refs/heads/integration
003f7217a7c7e582c46cec22a130adf4b9d7d950fba0 refs/heads/master
003cb88d2441cac0977faf98efc80305012112238d9d refs/tags/v0.9
003c525128480b96c89e6418b1e40909bf6c5b2d580f refs/tags/v1.0
003fe92df48743b7bc7d26bcaabfddde0a1e20cae47c refs/tags/v1.0^{}
0000
The returned response is a pkt-line stream describing each ref and
its current value. The stream MUST be sorted by name according to
the C locale ordering.
If HEAD is a valid ref, HEAD MUST appear as the first advertised
ref. If HEAD is not a valid ref, HEAD MUST NOT appear in the
advertisement list at all, but other refs may still appear.
The stream MUST include capability declarations behind a NUL on the
first ref. The peeled value of a ref (that is "ref^{}") MUST be
immediately after the ref itself, if presented. A conforming server
MUST peel the ref if it's an annotated tag.
----
advertised-refs = (no-refs / list-of-refs)
*shallow
flush-pkt
no-refs = PKT-LINE(zero-id SP "capabilities^{}"
NUL capability-list)
list-of-refs = first-ref *other-ref
first-ref = PKT-LINE(obj-id SP refname
NUL capability-list)
other-ref = PKT-LINE(other-tip / other-peeled)
other-tip = obj-id SP refname
other-peeled = obj-id SP refname "^{}"
shallow = PKT-LINE("shallow" SP obj-id)
capability-list = capability *(SP capability)
capability = 1*(LC_ALPHA / DIGIT / "-" / "_")
LC_ALPHA = %x61-7A
----
Server and client MUST use lowercase for obj-id, both MUST treat obj-id
as case-insensitive.
See protocol-capabilities.txt for a list of allowed server capabilities
and descriptions.
Packfile Negotiation
--------------------
After reference and capabilities discovery, the client can decide to
terminate the connection by sending a flush-pkt, telling the server it can
now gracefully terminate, and disconnect, when it does not need any pack
data. This can happen with the ls-remote command, and also can happen when
the client already is up-to-date.
Otherwise, it enters the negotiation phase, where the client and
server determine what the minimal packfile necessary for transport is,
by telling the server what objects it wants, its shallow objects
(if any), and the maximum commit depth it wants (if any). The client
will also send a list of the capabilities it wants to be in effect,
out of what the server said it could do with the first 'want' line.
----
upload-request = want-list
*shallow-line
*1depth-request
flush-pkt
want-list = first-want
*additional-want
shallow-line = PKT-LINE("shallow" SP obj-id)
depth-request = PKT-LINE("deepen" SP depth) /
PKT-LINE("deepen-since" SP timestamp) /
PKT-LINE("deepen-not" SP ref)
first-want = PKT-LINE("want" SP obj-id SP capability-list)
additional-want = PKT-LINE("want" SP obj-id)
depth = 1*DIGIT
----
Clients MUST send all the obj-ids it wants from the reference
discovery phase as 'want' lines. Clients MUST send at least one
'want' command in the request body. Clients MUST NOT mention an
obj-id in a 'want' command which did not appear in the response
obtained through ref discovery.
The client MUST write all obj-ids which it only has shallow copies
of (meaning that it does not have the parents of a commit) as
'shallow' lines so that the server is aware of the limitations of
the client's history.
The client now sends the maximum commit history depth it wants for
this transaction, which is the number of commits it wants from the
tip of the history, if any, as a 'deepen' line. A depth of 0 is the
same as not making a depth request. The client does not want to receive
any commits beyond this depth, nor does it want objects needed only to
complete those commits. Commits whose parents are not received as a
result are defined as shallow and marked as such in the server. This
information is sent back to the client in the next step.
Once all the 'want's and 'shallow's (and optional 'deepen') are
transferred, clients MUST send a flush-pkt, to tell the server side
that it is done sending the list.
Otherwise, if the client sent a positive depth request, the server
will determine which commits will and will not be shallow and
send this information to the client. If the client did not request
a positive depth, this step is skipped.
----
shallow-update = *shallow-line
*unshallow-line
flush-pkt
shallow-line = PKT-LINE("shallow" SP obj-id)
unshallow-line = PKT-LINE("unshallow" SP obj-id)
----
If the client has requested a positive depth, the server will compute
the set of commits which are no deeper than the desired depth. The set
of commits start at the client's wants.
The server writes 'shallow' lines for each
commit whose parents will not be sent as a result. The server writes
an 'unshallow' line for each commit which the client has indicated is
shallow, but is no longer shallow at the currently requested depth
(that is, its parents will now be sent). The server MUST NOT mark
as unshallow anything which the client has not indicated was shallow.
Now the client will send a list of the obj-ids it has using 'have'
lines, so the server can make a packfile that only contains the objects
that the client needs. In multi_ack mode, the canonical implementation
will send up to 32 of these at a time, then will send a flush-pkt. The
canonical implementation will skip ahead and send the next 32 immediately,
so that there is always a block of 32 "in-flight on the wire" at a time.
----
upload-haves = have-list
compute-end
have-list = *have-line
have-line = PKT-LINE("have" SP obj-id)
compute-end = flush-pkt / PKT-LINE("done")
----
If the server reads 'have' lines, it then will respond by ACKing any
of the obj-ids the client said it had that the server also has. The
server will ACK obj-ids differently depending on which ack mode is
chosen by the client.
In multi_ack mode:
* the server will respond with 'ACK obj-id continue' for any common
commits.
* once the server has found an acceptable common base commit and is
ready to make a packfile, it will blindly ACK all 'have' obj-ids
back to the client.
* the server will then send a 'NAK' and then wait for another response
from the client - either a 'done' or another list of 'have' lines.
In multi_ack_detailed mode:
* the server will differentiate the ACKs where it is signaling
that it is ready to send data with 'ACK obj-id ready' lines, and
signals the identified common commits with 'ACK obj-id common' lines.
Without either multi_ack or multi_ack_detailed:
* upload-pack sends "ACK obj-id" on the first common object it finds.
After that it says nothing until the client gives it a "done".
* upload-pack sends "NAK" on a flush-pkt if no common object
has been found yet. If one has been found, and thus an ACK
was already sent, it's silent on the flush-pkt.
After the client has gotten enough ACK responses that it can determine
that the server has enough information to send an efficient packfile
(in the canonical implementation, this is determined when it has received
enough ACKs that it can color everything left in the --date-order queue
as common with the server, or the --date-order queue is empty), or the
client determines that it wants to give up (in the canonical implementation,
this is determined when the client sends 256 'have' lines without getting
any of them ACKed by the server - meaning there is nothing in common and
the server should just send all of its objects), then the client will send
a 'done' command. The 'done' command signals to the server that the client
is ready to receive its packfile data.
However, the 256 limit *only* turns on in the canonical client
implementation if we have received at least one "ACK %s continue"
during a prior round. This helps to ensure that at least one common
ancestor is found before we give up entirely.
Once the 'done' line is read from the client, the server will either
send a final 'ACK obj-id' or it will send a 'NAK'. 'obj-id' is the object
name of the last commit determined to be common. The server only sends
ACK after 'done' if there is at least one common base and multi_ack or
multi_ack_detailed is enabled. The server always sends NAK after 'done'
if there is no common base found.
Then the server will start sending its packfile data.
----
server-response = *ack_multi ack / nak
ack_multi = PKT-LINE("ACK" SP obj-id ack_status)
ack_status = "continue" / "common" / "ready"
ack = PKT-LINE("ACK" SP obj-id)
nak = PKT-LINE("NAK")
----
A simple clone may look like this (with no 'have' lines):
----
C: 0054want 74730d410fcb6603ace96f1dc55ea6196122532d multi_ack \
side-band-64k ofs-delta\n
C: 0032want 7d1665144a3a975c05f1f43902ddaf084e784dbe\n
C: 0032want 5a3f6be755bbb7deae50065988cbfa1ffa9ab68a\n
C: 0032want 7e47fe2bd8d01d481f44d7af0531bd93d3b21c01\n
C: 0032want 74730d410fcb6603ace96f1dc55ea6196122532d\n
C: 0000
C: 0009done\n
S: 0008NAK\n
S: [PACKFILE]
----
An incremental update (fetch) response might look like this:
----
C: 0054want 74730d410fcb6603ace96f1dc55ea6196122532d multi_ack \
side-band-64k ofs-delta\n
C: 0032want 7d1665144a3a975c05f1f43902ddaf084e784dbe\n
C: 0032want 5a3f6be755bbb7deae50065988cbfa1ffa9ab68a\n
C: 0000
C: 0032have 7e47fe2bd8d01d481f44d7af0531bd93d3b21c01\n
C: [30 more have lines]
C: 0032have 74730d410fcb6603ace96f1dc55ea6196122532d\n
C: 0000
S: 003aACK 7e47fe2bd8d01d481f44d7af0531bd93d3b21c01 continue\n
S: 003aACK 74730d410fcb6603ace96f1dc55ea6196122532d continue\n
S: 0008NAK\n
C: 0009done\n
S: 0031ACK 74730d410fcb6603ace96f1dc55ea6196122532d\n
S: [PACKFILE]
----
Packfile Data
-------------
Now that the client and server have finished negotiation about what
the minimal amount of data that needs to be sent to the client is, the server
will construct and send the required data in packfile format.
See pack-format.txt for what the packfile itself actually looks like.
If 'side-band' or 'side-band-64k' capabilities have been specified by
the client, the server will send the packfile data multiplexed.
Each packet starting with the packet-line length of the amount of data
that follows, followed by a single byte specifying the sideband the
following data is coming in on.
In 'side-band' mode, it will send up to 999 data bytes plus 1 control
code, for a total of up to 1000 bytes in a pkt-line. In 'side-band-64k'
mode it will send up to 65519 data bytes plus 1 control code, for a
total of up to 65520 bytes in a pkt-line.
The sideband byte will be a '1', '2' or a '3'. Sideband '1' will contain
packfile data, sideband '2' will be used for progress information that the
client will generally print to stderr and sideband '3' is used for error
information.
If no 'side-band' capability was specified, the server will stream the
entire packfile without multiplexing.
Pushing Data To a Server
------------------------
Pushing data to a server will invoke the 'receive-pack' process on the
server, which will allow the client to tell it which references it should
update and then send all the data the server will need for those new
references to be complete. Once all the data is received and validated,
the server will then update its references to what the client specified.
Authentication
--------------
The protocol itself contains no authentication mechanisms. That is to be
handled by the transport, such as SSH, before the 'receive-pack' process is
invoked. If 'receive-pack' is configured over the Git transport, those
repositories will be writable by anyone who can access that port (9418) as
that transport is unauthenticated.
Reference Discovery
-------------------
The reference discovery phase is done nearly the same way as it is in the
fetching protocol. Each reference obj-id and name on the server is sent
in packet-line format to the client, followed by a flush-pkt. The only
real difference is that the capability listing is different - the only
possible values are 'report-status', 'delete-refs', 'ofs-delta' and
'push-options'.
Reference Update Request and Packfile Transfer
----------------------------------------------
Once the client knows what references the server is at, it can send a
list of reference update requests. For each reference on the server
that it wants to update, it sends a line listing the obj-id currently on
the server, the obj-id the client would like to update it to and the name
of the reference.
This list is followed by a flush-pkt. Then the push options are transmitted
one per packet followed by another flush-pkt. After that the packfile that
should contain all the objects that the server will need to complete the new
references will be sent.
----
update-request = *shallow ( command-list | push-cert ) [packfile]
shallow = PKT-LINE("shallow" SP obj-id)
command-list = PKT-LINE(command NUL capability-list)
*PKT-LINE(command)
flush-pkt
command = create / delete / update
create = zero-id SP new-id SP name
delete = old-id SP zero-id SP name
update = old-id SP new-id SP name
old-id = obj-id
new-id = obj-id
push-cert = PKT-LINE("push-cert" NUL capability-list LF)
PKT-LINE("certificate version 0.1" LF)
PKT-LINE("pusher" SP ident LF)
PKT-LINE("pushee" SP url LF)
PKT-LINE("nonce" SP nonce LF)
PKT-LINE(LF)
*PKT-LINE(command LF)
*PKT-LINE(gpg-signature-lines LF)
PKT-LINE("push-cert-end" LF)
packfile = "PACK" 28*(OCTET)
----
If the receiving end does not support delete-refs, the sending end MUST
NOT ask for delete command.
If the receiving end does not support push-cert, the sending end
MUST NOT send a push-cert command. When a push-cert command is
sent, command-list MUST NOT be sent; the commands recorded in the
push certificate is used instead.
The packfile MUST NOT be sent if the only command used is 'delete'.
A packfile MUST be sent if either create or update command is used,
even if the server already has all the necessary objects. In this
case the client MUST send an empty packfile. The only time this
is likely to happen is if the client is creating
a new branch or a tag that points to an existing obj-id.
The server will receive the packfile, unpack it, then validate each
reference that is being updated that it hasn't changed while the request
was being processed (the obj-id is still the same as the old-id), and
it will run any update hooks to make sure that the update is acceptable.
If all of that is fine, the server will then update the references.
Push Certificate
----------------
A push certificate begins with a set of header lines. After the
header and an empty line, the protocol commands follow, one per
line. Note that the trailing LF in push-cert PKT-LINEs is _not_
optional; it must be present.
Currently, the following header fields are defined:
`pusher` ident::
Identify the GPG key in "Human Readable Name "
format.
`pushee` url::
The repository URL (anonymized, if the URL contains
authentication material) the user who ran `git push`
intended to push into.
`nonce` nonce::
The 'nonce' string the receiving repository asked the
pushing user to include in the certificate, to prevent
replay attacks.
The GPG signature lines are a detached signature for the contents
recorded in the push certificate before the signature block begins.
The detached signature is used to certify that the commands were
given by the pusher, who must be the signer.
Report Status
-------------
After receiving the pack data from the sender, the receiver sends a
report if 'report-status' capability is in effect.
It is a short listing of what happened in that update. It will first
list the status of the packfile unpacking as either 'unpack ok' or
'unpack [error]'. Then it will list the status for each of the references
that it tried to update. Each line is either 'ok [refname]' if the
update was successful, or 'ng [refname] [error]' if the update was not.
----
report-status = unpack-status
1*(command-status)
flush-pkt
unpack-status = PKT-LINE("unpack" SP unpack-result)
unpack-result = "ok" / error-msg
command-status = command-ok / command-fail
command-ok = PKT-LINE("ok" SP refname)
command-fail = PKT-LINE("ng" SP refname SP error-msg)
error-msg = 1*(OCTECT) ; where not "ok"
----
Updates can be unsuccessful for a number of reasons. The reference can have
changed since the reference discovery phase was originally sent, meaning
someone pushed in the meantime. The reference being pushed could be a
non-fast-forward reference and the update hooks or configuration could be
set to not allow that, etc. Also, some references can be updated while others
can be rejected.
An example client/server communication might look like this:
----
S: 007c74730d410fcb6603ace96f1dc55ea6196122532d refs/heads/local\0report-status delete-refs ofs-delta\n
S: 003e7d1665144a3a975c05f1f43902ddaf084e784dbe refs/heads/debug\n
S: 003f74730d410fcb6603ace96f1dc55ea6196122532d refs/heads/master\n
S: 003f74730d410fcb6603ace96f1dc55ea6196122532d refs/heads/team\n
S: 0000
C: 003e7d1665144a3a975c05f1f43902ddaf084e784dbe 74730d410fcb6603ace96f1dc55ea6196122532d refs/heads/debug\n
C: 003e74730d410fcb6603ace96f1dc55ea6196122532d 5a3f6be755bbb7deae50065988cbfa1ffa9ab68a refs/heads/master\n
C: 0000
C: [PACKDATA]
S: 000eunpack ok\n
S: 0018ok refs/heads/debug\n
S: 002ang refs/heads/master non-fast-forward\n
----
*/
go-git-5.13.2/plumbing/protocol/packp/filter.go 0000664 0000000 0000000 00000004424 14744245500 0021371 0 ustar 00root root 0000000 0000000 package packp
import (
"errors"
"fmt"
"github.com/go-git/go-git/v5/plumbing"
"net/url"
"strings"
)
var ErrUnsupportedObjectFilterType = errors.New("unsupported object filter type")
// Filter values enable the partial clone capability which causes
// the server to omit objects that match the filter.
//
// See [Git's documentation] for more details.
//
// [Git's documentation]: https://github.com/git/git/blob/e02ecfcc534e2021aae29077a958dd11c3897e4c/Documentation/rev-list-options.txt#L948
type Filter string
type BlobLimitPrefix string
const (
BlobLimitPrefixNone BlobLimitPrefix = ""
BlobLimitPrefixKibi BlobLimitPrefix = "k"
BlobLimitPrefixMebi BlobLimitPrefix = "m"
BlobLimitPrefixGibi BlobLimitPrefix = "g"
)
// FilterBlobNone omits all blobs.
func FilterBlobNone() Filter {
return "blob:none"
}
// FilterBlobLimit omits blobs of size at least n bytes (when prefix is
// BlobLimitPrefixNone), n kibibytes (when prefix is BlobLimitPrefixKibi),
// n mebibytes (when prefix is BlobLimitPrefixMebi) or n gibibytes (when
// prefix is BlobLimitPrefixGibi). n can be zero, in which case all blobs
// will be omitted.
func FilterBlobLimit(n uint64, prefix BlobLimitPrefix) Filter {
return Filter(fmt.Sprintf("blob:limit=%d%s", n, prefix))
}
// FilterTreeDepth omits all blobs and trees whose depth from the root tree
// is larger or equal to depth.
func FilterTreeDepth(depth uint64) Filter {
return Filter(fmt.Sprintf("tree:%d", depth))
}
// FilterObjectType omits all objects which are not of the requested type t.
// Supported types are TagObject, CommitObject, TreeObject and BlobObject.
func FilterObjectType(t plumbing.ObjectType) (Filter, error) {
switch t {
case plumbing.TagObject:
fallthrough
case plumbing.CommitObject:
fallthrough
case plumbing.TreeObject:
fallthrough
case plumbing.BlobObject:
return Filter(fmt.Sprintf("object:type=%s", t.String())), nil
default:
return "", fmt.Errorf("%w: %s", ErrUnsupportedObjectFilterType, t.String())
}
}
// FilterCombine combines multiple Filter values together.
func FilterCombine(filters ...Filter) Filter {
var escapedFilters []string
for _, filter := range filters {
escapedFilters = append(escapedFilters, url.QueryEscape(string(filter)))
}
return Filter(fmt.Sprintf("combine:%s", strings.Join(escapedFilters, "+")))
}
go-git-5.13.2/plumbing/protocol/packp/filter_test.go 0000664 0000000 0000000 00000003347 14744245500 0022433 0 ustar 00root root 0000000 0000000 package packp
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/stretchr/testify/require"
"testing"
)
func TestFilterBlobNone(t *testing.T) {
require.EqualValues(t, "blob:none", FilterBlobNone())
}
func TestFilterBlobLimit(t *testing.T) {
require.EqualValues(t, "blob:limit=0", FilterBlobLimit(0, BlobLimitPrefixNone))
require.EqualValues(t, "blob:limit=1000", FilterBlobLimit(1000, BlobLimitPrefixNone))
require.EqualValues(t, "blob:limit=4k", FilterBlobLimit(4, BlobLimitPrefixKibi))
require.EqualValues(t, "blob:limit=4m", FilterBlobLimit(4, BlobLimitPrefixMebi))
require.EqualValues(t, "blob:limit=4g", FilterBlobLimit(4, BlobLimitPrefixGibi))
}
func TestFilterTreeDepth(t *testing.T) {
require.EqualValues(t, "tree:0", FilterTreeDepth(0))
require.EqualValues(t, "tree:1", FilterTreeDepth(1))
require.EqualValues(t, "tree:2", FilterTreeDepth(2))
}
func TestFilterObjectType(t *testing.T) {
filter, err := FilterObjectType(plumbing.TagObject)
require.NoError(t, err)
require.EqualValues(t, "object:type=tag", filter)
filter, err = FilterObjectType(plumbing.CommitObject)
require.NoError(t, err)
require.EqualValues(t, "object:type=commit", filter)
filter, err = FilterObjectType(plumbing.TreeObject)
require.NoError(t, err)
require.EqualValues(t, "object:type=tree", filter)
filter, err = FilterObjectType(plumbing.BlobObject)
require.NoError(t, err)
require.EqualValues(t, "object:type=blob", filter)
_, err = FilterObjectType(plumbing.InvalidObject)
require.Error(t, err)
_, err = FilterObjectType(plumbing.OFSDeltaObject)
require.Error(t, err)
}
func TestFilterCombine(t *testing.T) {
require.EqualValues(t, "combine:tree%3A2+blob%3Anone",
FilterCombine(
FilterTreeDepth(2),
FilterBlobNone(),
),
)
}
go-git-5.13.2/plumbing/protocol/packp/gitproto.go 0000664 0000000 0000000 00000004666 14744245500 0021763 0 ustar 00root root 0000000 0000000 package packp
import (
"fmt"
"io"
"strings"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
)
var (
// ErrInvalidGitProtoRequest is returned by Decode if the input is not a
// valid git protocol request.
ErrInvalidGitProtoRequest = fmt.Errorf("invalid git protocol request")
)
// GitProtoRequest is a command request for the git protocol.
// It is used to send the command, endpoint, and extra parameters to the
// remote.
// See https://git-scm.com/docs/pack-protocol#_git_transport
type GitProtoRequest struct {
RequestCommand string
Pathname string
// Optional
Host string
// Optional
ExtraParams []string
}
// validate validates the request.
func (g *GitProtoRequest) validate() error {
if g.RequestCommand == "" {
return fmt.Errorf("%w: empty request command", ErrInvalidGitProtoRequest)
}
if g.Pathname == "" {
return fmt.Errorf("%w: empty pathname", ErrInvalidGitProtoRequest)
}
return nil
}
// Encode encodes the request into the writer.
func (g *GitProtoRequest) Encode(w io.Writer) error {
if w == nil {
return ErrNilWriter
}
if err := g.validate(); err != nil {
return err
}
p := pktline.NewEncoder(w)
req := fmt.Sprintf("%s %s\x00", g.RequestCommand, g.Pathname)
if host := g.Host; host != "" {
req += fmt.Sprintf("host=%s\x00", host)
}
if len(g.ExtraParams) > 0 {
req += "\x00"
for _, param := range g.ExtraParams {
req += param + "\x00"
}
}
if err := p.Encode([]byte(req)); err != nil {
return err
}
return nil
}
// Decode decodes the request from the reader.
func (g *GitProtoRequest) Decode(r io.Reader) error {
s := pktline.NewScanner(r)
if !s.Scan() {
err := s.Err()
if err == nil {
return ErrInvalidGitProtoRequest
}
return err
}
line := string(s.Bytes())
if len(line) == 0 {
return io.EOF
}
if line[len(line)-1] != 0 {
return fmt.Errorf("%w: missing null terminator", ErrInvalidGitProtoRequest)
}
parts := strings.SplitN(line, " ", 2)
if len(parts) != 2 {
return fmt.Errorf("%w: short request", ErrInvalidGitProtoRequest)
}
g.RequestCommand = parts[0]
params := strings.Split(parts[1], string(null))
if len(params) < 1 {
return fmt.Errorf("%w: missing pathname", ErrInvalidGitProtoRequest)
}
g.Pathname = params[0]
if len(params) > 1 {
g.Host = strings.TrimPrefix(params[1], "host=")
}
if len(params) > 2 {
for _, param := range params[2:] {
if param != "" {
g.ExtraParams = append(g.ExtraParams, param)
}
}
}
return nil
}
go-git-5.13.2/plumbing/protocol/packp/gitproto_test.go 0000664 0000000 0000000 00000004404 14744245500 0023010 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"testing"
)
func TestEncodeEmptyGitProtoRequest(t *testing.T) {
var buf bytes.Buffer
var p GitProtoRequest
err := p.Encode(&buf)
if err == nil {
t.Fatal("expected error")
}
}
func TestEncodeGitProtoRequest(t *testing.T) {
var buf bytes.Buffer
p := GitProtoRequest{
RequestCommand: "command",
Pathname: "pathname",
Host: "host",
ExtraParams: []string{"param1", "param2"},
}
err := p.Encode(&buf)
if err != nil {
t.Fatal(err)
}
expected := "002ecommand pathname\x00host=host\x00\x00param1\x00param2\x00"
if buf.String() != expected {
t.Fatalf("expected %q, got %q", expected, buf.String())
}
}
func TestEncodeInvalidGitProtoRequest(t *testing.T) {
var buf bytes.Buffer
p := GitProtoRequest{
RequestCommand: "command",
}
err := p.Encode(&buf)
if err == nil {
t.Fatal("expected error")
}
}
func TestDecodeEmptyGitProtoRequest(t *testing.T) {
var buf bytes.Buffer
var p GitProtoRequest
err := p.Decode(&buf)
if err == nil {
t.Fatal("expected error")
}
}
func TestDecodeGitProtoRequest(t *testing.T) {
var buf bytes.Buffer
buf.WriteString("002ecommand pathname\x00host=host\x00\x00param1\x00param2\x00")
var p GitProtoRequest
err := p.Decode(&buf)
if err != nil {
t.Fatal(err)
}
expected := GitProtoRequest{
RequestCommand: "command",
Pathname: "pathname",
Host: "host",
ExtraParams: []string{"param1", "param2"},
}
if p.RequestCommand != expected.RequestCommand {
t.Fatalf("expected %q, got %q", expected.RequestCommand, p.RequestCommand)
}
if p.Pathname != expected.Pathname {
t.Fatalf("expected %q, got %q", expected.Pathname, p.Pathname)
}
if p.Host != expected.Host {
t.Fatalf("expected %q, got %q", expected.Host, p.Host)
}
if len(p.ExtraParams) != len(expected.ExtraParams) {
t.Fatalf("expected %d, got %d", len(expected.ExtraParams), len(p.ExtraParams))
}
}
func TestDecodeInvalidGitProtoRequest(t *testing.T) {
var buf bytes.Buffer
buf.WriteString("0026command \x00host=host\x00\x00param1\x00param2")
var p GitProtoRequest
err := p.Decode(&buf)
if err == nil {
t.Fatal("expected error")
}
}
func TestValidateEmptyGitProtoRequest(t *testing.T) {
var p GitProtoRequest
err := p.validate()
if err == nil {
t.Fatal("expected error")
}
}
go-git-5.13.2/plumbing/protocol/packp/report_status.go 0000664 0000000 0000000 00000006571 14744245500 0023027 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"fmt"
"io"
"strings"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
)
const (
ok = "ok"
)
// ReportStatus is a report status message, as used in the git-receive-pack
// process whenever the 'report-status' capability is negotiated.
type ReportStatus struct {
UnpackStatus string
CommandStatuses []*CommandStatus
}
// NewReportStatus creates a new ReportStatus message.
func NewReportStatus() *ReportStatus {
return &ReportStatus{}
}
// Error returns the first error if any.
func (s *ReportStatus) Error() error {
if s.UnpackStatus != ok {
return fmt.Errorf("unpack error: %s", s.UnpackStatus)
}
for _, s := range s.CommandStatuses {
if err := s.Error(); err != nil {
return err
}
}
return nil
}
// Encode writes the report status to a writer.
func (s *ReportStatus) Encode(w io.Writer) error {
e := pktline.NewEncoder(w)
if err := e.Encodef("unpack %s\n", s.UnpackStatus); err != nil {
return err
}
for _, cs := range s.CommandStatuses {
if err := cs.encode(w); err != nil {
return err
}
}
return e.Flush()
}
// Decode reads from the given reader and decodes a report-status message. It
// does not read more input than what is needed to fill the report status.
func (s *ReportStatus) Decode(r io.Reader) error {
scan := pktline.NewScanner(r)
if err := s.scanFirstLine(scan); err != nil {
return err
}
if err := s.decodeReportStatus(scan.Bytes()); err != nil {
return err
}
flushed := false
for scan.Scan() {
b := scan.Bytes()
if isFlush(b) {
flushed = true
break
}
if err := s.decodeCommandStatus(b); err != nil {
return err
}
}
if !flushed {
return fmt.Errorf("missing flush")
}
return scan.Err()
}
func (s *ReportStatus) scanFirstLine(scan *pktline.Scanner) error {
if scan.Scan() {
return nil
}
if scan.Err() != nil {
return scan.Err()
}
return io.ErrUnexpectedEOF
}
func (s *ReportStatus) decodeReportStatus(b []byte) error {
if isFlush(b) {
return fmt.Errorf("premature flush")
}
b = bytes.TrimSuffix(b, eol)
line := string(b)
fields := strings.SplitN(line, " ", 2)
if len(fields) != 2 || fields[0] != "unpack" {
return fmt.Errorf("malformed unpack status: %s", line)
}
s.UnpackStatus = fields[1]
return nil
}
func (s *ReportStatus) decodeCommandStatus(b []byte) error {
b = bytes.TrimSuffix(b, eol)
line := string(b)
fields := strings.SplitN(line, " ", 3)
status := ok
if len(fields) == 3 && fields[0] == "ng" {
status = fields[2]
} else if len(fields) != 2 || fields[0] != "ok" {
return fmt.Errorf("malformed command status: %s", line)
}
cs := &CommandStatus{
ReferenceName: plumbing.ReferenceName(fields[1]),
Status: status,
}
s.CommandStatuses = append(s.CommandStatuses, cs)
return nil
}
// CommandStatus is the status of a reference in a report status.
// See ReportStatus struct.
type CommandStatus struct {
ReferenceName plumbing.ReferenceName
Status string
}
// Error returns the error, if any.
func (s *CommandStatus) Error() error {
if s.Status == ok {
return nil
}
return fmt.Errorf("command error on %s: %s",
s.ReferenceName.String(), s.Status)
}
func (s *CommandStatus) encode(w io.Writer) error {
e := pktline.NewEncoder(w)
if s.Error() == nil {
return e.Encodef("ok %s\n", s.ReferenceName.String())
}
return e.Encodef("ng %s %s\n", s.ReferenceName.String(), s.Status)
}
go-git-5.13.2/plumbing/protocol/packp/report_status_test.go 0000664 0000000 0000000 00000015034 14744245500 0024060 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
. "gopkg.in/check.v1"
)
type ReportStatusSuite struct{}
var _ = Suite(&ReportStatusSuite{})
func (s *ReportStatusSuite) TestError(c *C) {
rs := NewReportStatus()
rs.UnpackStatus = "ok"
c.Assert(rs.Error(), IsNil)
rs.UnpackStatus = "OK"
c.Assert(rs.Error(), ErrorMatches, "unpack error: OK")
rs.UnpackStatus = ""
c.Assert(rs.Error(), ErrorMatches, "unpack error: ")
cs := &CommandStatus{ReferenceName: plumbing.ReferenceName("ref")}
rs.UnpackStatus = "ok"
rs.CommandStatuses = append(rs.CommandStatuses, cs)
cs.Status = "ok"
c.Assert(rs.Error(), IsNil)
cs.Status = "OK"
c.Assert(rs.Error(), ErrorMatches, "command error on ref: OK")
cs.Status = ""
c.Assert(rs.Error(), ErrorMatches, "command error on ref: ")
}
func (s *ReportStatusSuite) testEncodeDecodeOk(c *C, rs *ReportStatus, lines ...string) {
s.testDecodeOk(c, rs, lines...)
s.testEncodeOk(c, rs, lines...)
}
func (s *ReportStatusSuite) testDecodeOk(c *C, expected *ReportStatus, lines ...string) {
r := toPktLines(c, lines)
rs := NewReportStatus()
c.Assert(rs.Decode(r), IsNil)
c.Assert(rs, DeepEquals, expected)
}
func (s *ReportStatusSuite) testDecodeError(c *C, errorMatch string, lines ...string) {
r := toPktLines(c, lines)
rs := NewReportStatus()
c.Assert(rs.Decode(r), ErrorMatches, errorMatch)
}
func (s *ReportStatusSuite) testEncodeOk(c *C, input *ReportStatus, lines ...string) {
expected := pktlines(c, lines...)
var buf bytes.Buffer
c.Assert(input.Encode(&buf), IsNil)
obtained := buf.Bytes()
comment := Commentf("\nobtained = %s\nexpected = %s\n", string(obtained), string(expected))
c.Assert(obtained, DeepEquals, expected, comment)
}
func (s *ReportStatusSuite) TestEncodeDecodeOkOneReference(c *C) {
rs := NewReportStatus()
rs.UnpackStatus = "ok"
rs.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}}
s.testEncodeDecodeOk(c, rs,
"unpack ok\n",
"ok refs/heads/master\n",
pktline.FlushString,
)
}
func (s *ReportStatusSuite) TestEncodeDecodeOkOneReferenceFailed(c *C) {
rs := NewReportStatus()
rs.UnpackStatus = "my error"
rs.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "command error",
}}
s.testEncodeDecodeOk(c, rs,
"unpack my error\n",
"ng refs/heads/master command error\n",
pktline.FlushString,
)
}
func (s *ReportStatusSuite) TestEncodeDecodeOkMoreReferences(c *C) {
rs := NewReportStatus()
rs.UnpackStatus = "ok"
rs.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}, {
ReferenceName: plumbing.ReferenceName("refs/heads/a"),
Status: "ok",
}, {
ReferenceName: plumbing.ReferenceName("refs/heads/b"),
Status: "ok",
}}
s.testEncodeDecodeOk(c, rs,
"unpack ok\n",
"ok refs/heads/master\n",
"ok refs/heads/a\n",
"ok refs/heads/b\n",
pktline.FlushString,
)
}
func (s *ReportStatusSuite) TestEncodeDecodeOkMoreReferencesFailed(c *C) {
rs := NewReportStatus()
rs.UnpackStatus = "my error"
rs.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}, {
ReferenceName: plumbing.ReferenceName("refs/heads/a"),
Status: "command error",
}, {
ReferenceName: plumbing.ReferenceName("refs/heads/b"),
Status: "ok",
}}
s.testEncodeDecodeOk(c, rs,
"unpack my error\n",
"ok refs/heads/master\n",
"ng refs/heads/a command error\n",
"ok refs/heads/b\n",
pktline.FlushString,
)
}
func (s *ReportStatusSuite) TestEncodeDecodeOkNoReferences(c *C) {
expected := NewReportStatus()
expected.UnpackStatus = "ok"
s.testEncodeDecodeOk(c, expected,
"unpack ok\n",
pktline.FlushString,
)
}
func (s *ReportStatusSuite) TestEncodeDecodeOkNoReferencesFailed(c *C) {
rs := NewReportStatus()
rs.UnpackStatus = "my error"
s.testEncodeDecodeOk(c, rs,
"unpack my error\n",
pktline.FlushString,
)
}
func (s *ReportStatusSuite) TestDecodeErrorOneReferenceNoFlush(c *C) {
expected := NewReportStatus()
expected.UnpackStatus = "ok"
expected.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}}
s.testDecodeError(c, "missing flush",
"unpack ok\n",
"ok refs/heads/master\n",
)
}
func (s *ReportStatusSuite) TestDecodeErrorEmpty(c *C) {
expected := NewReportStatus()
expected.UnpackStatus = "ok"
expected.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}}
s.testDecodeError(c, "unexpected EOF")
}
func (s *ReportStatusSuite) TestDecodeErrorMalformed(c *C) {
expected := NewReportStatus()
expected.UnpackStatus = "ok"
expected.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}}
s.testDecodeError(c, "malformed unpack status: unpackok",
"unpackok\n",
pktline.FlushString,
)
}
func (s *ReportStatusSuite) TestDecodeErrorMalformed2(c *C) {
expected := NewReportStatus()
expected.UnpackStatus = "ok"
expected.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}}
s.testDecodeError(c, "malformed unpack status: UNPACK OK",
"UNPACK OK\n",
pktline.FlushString,
)
}
func (s *ReportStatusSuite) TestDecodeErrorMalformedCommandStatus(c *C) {
expected := NewReportStatus()
expected.UnpackStatus = "ok"
expected.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}}
s.testDecodeError(c, "malformed command status: ko refs/heads/master",
"unpack ok\n",
"ko refs/heads/master\n",
pktline.FlushString,
)
}
func (s *ReportStatusSuite) TestDecodeErrorMalformedCommandStatus2(c *C) {
expected := NewReportStatus()
expected.UnpackStatus = "ok"
expected.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}}
s.testDecodeError(c, "malformed command status: ng refs/heads/master",
"unpack ok\n",
"ng refs/heads/master\n",
pktline.FlushString,
)
}
func (s *ReportStatusSuite) TestDecodeErrorPrematureFlush(c *C) {
expected := NewReportStatus()
expected.UnpackStatus = "ok"
expected.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}}
s.testDecodeError(c, "premature flush",
pktline.FlushString,
)
}
go-git-5.13.2/plumbing/protocol/packp/shallowupd.go 0000664 0000000 0000000 00000003402 14744245500 0022261 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
)
const (
shallowLineLen = 48
unshallowLineLen = 50
)
type ShallowUpdate struct {
Shallows []plumbing.Hash
Unshallows []plumbing.Hash
}
func (r *ShallowUpdate) Decode(reader io.Reader) error {
s := pktline.NewScanner(reader)
for s.Scan() {
line := s.Bytes()
line = bytes.TrimSpace(line)
var err error
switch {
case bytes.HasPrefix(line, shallow):
err = r.decodeShallowLine(line)
case bytes.HasPrefix(line, unshallow):
err = r.decodeUnshallowLine(line)
case bytes.Equal(line, pktline.Flush):
return nil
}
if err != nil {
return err
}
}
return s.Err()
}
func (r *ShallowUpdate) decodeShallowLine(line []byte) error {
hash, err := r.decodeLine(line, shallow, shallowLineLen)
if err != nil {
return err
}
r.Shallows = append(r.Shallows, hash)
return nil
}
func (r *ShallowUpdate) decodeUnshallowLine(line []byte) error {
hash, err := r.decodeLine(line, unshallow, unshallowLineLen)
if err != nil {
return err
}
r.Unshallows = append(r.Unshallows, hash)
return nil
}
func (r *ShallowUpdate) decodeLine(line, prefix []byte, expLen int) (plumbing.Hash, error) {
if len(line) != expLen {
return plumbing.ZeroHash, fmt.Errorf("malformed %s%q", prefix, line)
}
raw := string(line[expLen-40 : expLen])
return plumbing.NewHash(raw), nil
}
func (r *ShallowUpdate) Encode(w io.Writer) error {
e := pktline.NewEncoder(w)
for _, h := range r.Shallows {
if err := e.Encodef("%s%s\n", shallow, h.String()); err != nil {
return err
}
}
for _, h := range r.Unshallows {
if err := e.Encodef("%s%s\n", unshallow, h.String()); err != nil {
return err
}
}
return e.Flush()
}
go-git-5.13.2/plumbing/protocol/packp/shallowupd_test.go 0000664 0000000 0000000 00000010055 14744245500 0023322 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
type ShallowUpdateSuite struct{}
var _ = Suite(&ShallowUpdateSuite{})
func (s *ShallowUpdateSuite) TestDecodeWithLF(c *C) {
raw := "" +
"0035shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" +
"0035shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" +
"0000"
su := &ShallowUpdate{}
err := su.Decode(bytes.NewBufferString(raw))
c.Assert(err, IsNil)
plumbing.HashesSort(su.Shallows)
c.Assert(su.Unshallows, HasLen, 0)
c.Assert(su.Shallows, HasLen, 2)
c.Assert(su.Shallows, DeepEquals, []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
})
}
func (s *ShallowUpdateSuite) TestDecode(c *C) {
raw := "" +
"0034shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
"0034shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" +
"0000"
su := &ShallowUpdate{}
err := su.Decode(bytes.NewBufferString(raw))
c.Assert(err, IsNil)
plumbing.HashesSort(su.Shallows)
c.Assert(su.Unshallows, HasLen, 0)
c.Assert(su.Shallows, HasLen, 2)
c.Assert(su.Shallows, DeepEquals, []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
})
}
func (s *ShallowUpdateSuite) TestDecodeUnshallow(c *C) {
raw := "" +
"0036unshallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
"0036unshallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" +
"0000"
su := &ShallowUpdate{}
err := su.Decode(bytes.NewBufferString(raw))
c.Assert(err, IsNil)
plumbing.HashesSort(su.Unshallows)
c.Assert(su.Shallows, HasLen, 0)
c.Assert(su.Unshallows, HasLen, 2)
c.Assert(su.Unshallows, DeepEquals, []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
})
}
func (s *ShallowUpdateSuite) TestDecodeMalformed(c *C) {
raw := "" +
"0035unshallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +
"0000"
su := &ShallowUpdate{}
err := su.Decode(bytes.NewBufferString(raw))
c.Assert(err, NotNil)
}
func (s *ShallowUpdateSuite) TestEncodeEmpty(c *C) {
su := &ShallowUpdate{}
buf := bytes.NewBuffer(nil)
c.Assert(su.Encode(buf), IsNil)
c.Assert(buf.String(), Equals, "0000")
}
func (s *ShallowUpdateSuite) TestEncode(c *C) {
su := &ShallowUpdate{
Shallows: []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
},
Unshallows: []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
},
}
buf := bytes.NewBuffer(nil)
c.Assert(su.Encode(buf), IsNil)
expected := "" +
"0035shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" +
"0035shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" +
"0037unshallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" +
"0037unshallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" +
"0000"
c.Assert(buf.String(), Equals, expected)
}
func (s *ShallowUpdateSuite) TestEncodeShallow(c *C) {
su := &ShallowUpdate{
Shallows: []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
},
}
buf := bytes.NewBuffer(nil)
c.Assert(su.Encode(buf), IsNil)
expected := "" +
"0035shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" +
"0035shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" +
"0000"
c.Assert(buf.String(), Equals, expected)
}
func (s *ShallowUpdateSuite) TestEncodeUnshallow(c *C) {
su := &ShallowUpdate{
Unshallows: []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
},
}
buf := bytes.NewBuffer(nil)
c.Assert(su.Encode(buf), IsNil)
expected := "" +
"0037unshallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" +
"0037unshallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" +
"0000"
c.Assert(buf.String(), Equals, expected)
}
go-git-5.13.2/plumbing/protocol/packp/sideband/ 0000775 0000000 0000000 00000000000 14744245500 0021322 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/protocol/packp/sideband/common.go 0000664 0000000 0000000 00000001442 14744245500 0023142 0 ustar 00root root 0000000 0000000 package sideband
// Type sideband type "side-band" or "side-band-64k"
type Type int8
const (
// Sideband legacy sideband type up to 1000-byte messages
Sideband Type = iota
// Sideband64k sideband type up to 65519-byte messages
Sideband64k Type = iota
// MaxPackedSize for Sideband type
MaxPackedSize = 1000
// MaxPackedSize64k for Sideband64k type
MaxPackedSize64k = 65520
)
// Channel sideband channel
type Channel byte
// WithPayload encode the payload as a message
func (ch Channel) WithPayload(payload []byte) []byte {
return append([]byte{byte(ch)}, payload...)
}
const (
// PackData packfile content
PackData Channel = 1
// ProgressMessage progress messages
ProgressMessage Channel = 2
// ErrorMessage fatal error message just before stream aborts
ErrorMessage Channel = 3
)
go-git-5.13.2/plumbing/protocol/packp/sideband/demux.go 0000664 0000000 0000000 00000006264 14744245500 0023003 0 ustar 00root root 0000000 0000000 package sideband
import (
"errors"
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
)
// ErrMaxPackedExceeded returned by Read, if the maximum packed size is exceeded
var ErrMaxPackedExceeded = errors.New("max. packed size exceeded")
// Progress where the progress information is stored
type Progress interface {
io.Writer
}
// Demuxer demultiplexes the progress reports and error info interleaved with the
// packfile itself.
//
// A sideband has three different channels the main one, called PackData, contains
// the packfile data; the ErrorMessage channel, that contains server errors; and
// the last one, ProgressMessage channel, containing information about the ongoing
// task happening in the server (optional, can be suppressed sending NoProgress
// or Quiet capabilities to the server)
//
// In order to demultiplex the data stream, method `Read` should be called to
// retrieve the PackData channel, the incoming data from the ProgressMessage is
// written at `Progress` (if any), if any message is retrieved from the
// ErrorMessage channel an error is returned and we can assume that the
// connection has been closed.
type Demuxer struct {
t Type
r io.Reader
s *pktline.Scanner
max int
pending []byte
// Progress is where the progress messages are stored
Progress Progress
}
// NewDemuxer returns a new Demuxer for the given t and read from r
func NewDemuxer(t Type, r io.Reader) *Demuxer {
max := MaxPackedSize64k
if t == Sideband {
max = MaxPackedSize
}
return &Demuxer{
t: t,
r: r,
max: max,
s: pktline.NewScanner(r),
}
}
// Read reads up to len(p) bytes from the PackData channel into p, an error can
// be return if an error happens when reading or if a message is sent in the
// ErrorMessage channel.
//
// When a ProgressMessage is read, is not copy to b, instead of this is written
// to the Progress
func (d *Demuxer) Read(b []byte) (n int, err error) {
var read, req int
req = len(b)
for read < req {
n, err := d.doRead(b[read:req])
read += n
if err != nil {
return read, err
}
}
return read, nil
}
func (d *Demuxer) doRead(b []byte) (int, error) {
read, err := d.nextPackData()
size := len(read)
wanted := len(b)
if size > wanted {
d.pending = read[wanted:]
}
if wanted > size {
wanted = size
}
size = copy(b, read[:wanted])
return size, err
}
func (d *Demuxer) nextPackData() ([]byte, error) {
content := d.getPending()
if len(content) != 0 {
return content, nil
}
if !d.s.Scan() {
if err := d.s.Err(); err != nil {
return nil, err
}
return nil, io.EOF
}
content = d.s.Bytes()
size := len(content)
if size == 0 {
return nil, io.EOF
} else if size > d.max {
return nil, ErrMaxPackedExceeded
}
switch Channel(content[0]) {
case PackData:
return content[1:], nil
case ProgressMessage:
if d.Progress != nil {
_, err := d.Progress.Write(content[1:])
return nil, err
}
case ErrorMessage:
return nil, fmt.Errorf("unexpected error: %s", content[1:])
default:
return nil, fmt.Errorf("unknown channel %s", content)
}
return nil, nil
}
func (d *Demuxer) getPending() (b []byte) {
if len(d.pending) == 0 {
return nil
}
content := d.pending
d.pending = nil
return content
}
go-git-5.13.2/plumbing/protocol/packp/sideband/demux_test.go 0000664 0000000 0000000 00000011725 14744245500 0024040 0 ustar 00root root 0000000 0000000 package sideband
import (
"bytes"
"errors"
"io"
"testing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type SidebandSuite struct{}
var _ = Suite(&SidebandSuite{})
func (s *SidebandSuite) TestDecode(c *C) {
expected := []byte("abcdefghijklmnopqrstuvwxyz")
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
e.Encode(PackData.WithPayload(expected[0:8]))
e.Encode(ProgressMessage.WithPayload([]byte{'F', 'O', 'O', '\n'}))
e.Encode(PackData.WithPayload(expected[8:16]))
e.Encode(PackData.WithPayload(expected[16:26]))
content := make([]byte, 26)
d := NewDemuxer(Sideband64k, buf)
n, err := io.ReadFull(d, content)
c.Assert(err, IsNil)
c.Assert(n, Equals, 26)
c.Assert(content, DeepEquals, expected)
}
func (s *SidebandSuite) TestDecodeMoreThanContain(c *C) {
expected := []byte("abcdefghijklmnopqrstuvwxyz")
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
e.Encode(PackData.WithPayload(expected))
content := make([]byte, 42)
d := NewDemuxer(Sideband64k, buf)
n, err := io.ReadFull(d, content)
c.Assert(err, Equals, io.ErrUnexpectedEOF)
c.Assert(n, Equals, 26)
c.Assert(content[0:26], DeepEquals, expected)
}
func (s *SidebandSuite) TestDecodeWithError(c *C) {
expected := []byte("abcdefghijklmnopqrstuvwxyz")
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
e.Encode(PackData.WithPayload(expected[0:8]))
e.Encode(ErrorMessage.WithPayload([]byte{'F', 'O', 'O', '\n'}))
e.Encode(PackData.WithPayload(expected[8:16]))
e.Encode(PackData.WithPayload(expected[16:26]))
content := make([]byte, 26)
d := NewDemuxer(Sideband64k, buf)
n, err := io.ReadFull(d, content)
c.Assert(err, ErrorMatches, "unexpected error: FOO\n")
c.Assert(n, Equals, 8)
c.Assert(content[0:8], DeepEquals, expected[0:8])
}
type mockReader struct{}
func (r *mockReader) Read([]byte) (int, error) { return 0, errors.New("foo") }
func (s *SidebandSuite) TestDecodeFromFailingReader(c *C) {
content := make([]byte, 26)
d := NewDemuxer(Sideband64k, &mockReader{})
n, err := io.ReadFull(d, content)
c.Assert(err, ErrorMatches, "foo")
c.Assert(n, Equals, 0)
}
func (s *SidebandSuite) TestDecodeWithProgress(c *C) {
expected := []byte("abcdefghijklmnopqrstuvwxyz")
input := bytes.NewBuffer(nil)
e := pktline.NewEncoder(input)
e.Encode(PackData.WithPayload(expected[0:8]))
e.Encode(ProgressMessage.WithPayload([]byte{'F', 'O', 'O', '\n'}))
e.Encode(PackData.WithPayload(expected[8:16]))
e.Encode(PackData.WithPayload(expected[16:26]))
output := bytes.NewBuffer(nil)
content := make([]byte, 26)
d := NewDemuxer(Sideband64k, input)
d.Progress = output
n, err := io.ReadFull(d, content)
c.Assert(err, IsNil)
c.Assert(n, Equals, 26)
c.Assert(content, DeepEquals, expected)
progress, err := io.ReadAll(output)
c.Assert(err, IsNil)
c.Assert(progress, DeepEquals, []byte{'F', 'O', 'O', '\n'})
}
func (s *SidebandSuite) TestDecodeFlushEOF(c *C) {
expected := []byte("abcdefghijklmnopqrstuvwxyz")
input := bytes.NewBuffer(nil)
e := pktline.NewEncoder(input)
e.Encode(PackData.WithPayload(expected[0:8]))
e.Encode(ProgressMessage.WithPayload([]byte{'F', 'O', 'O', '\n'}))
e.Encode(PackData.WithPayload(expected[8:16]))
e.Encode(PackData.WithPayload(expected[16:26]))
e.Flush()
e.Encode(PackData.WithPayload([]byte("bar\n")))
output := bytes.NewBuffer(nil)
content := bytes.NewBuffer(nil)
d := NewDemuxer(Sideband64k, input)
d.Progress = output
n, err := content.ReadFrom(d)
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(26))
c.Assert(content.Bytes(), DeepEquals, expected)
progress, err := io.ReadAll(output)
c.Assert(err, IsNil)
c.Assert(progress, DeepEquals, []byte{'F', 'O', 'O', '\n'})
}
func (s *SidebandSuite) TestDecodeWithUnknownChannel(c *C) {
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
e.Encode([]byte{'4', 'F', 'O', 'O', '\n'})
content := make([]byte, 26)
d := NewDemuxer(Sideband64k, buf)
n, err := io.ReadFull(d, content)
c.Assert(err, ErrorMatches, "unknown channel 4FOO\n")
c.Assert(n, Equals, 0)
}
func (s *SidebandSuite) TestDecodeWithPending(c *C) {
expected := []byte("abcdefghijklmnopqrstuvwxyz")
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
e.Encode(PackData.WithPayload(expected[0:8]))
e.Encode(PackData.WithPayload(expected[8:16]))
e.Encode(PackData.WithPayload(expected[16:26]))
content := make([]byte, 13)
d := NewDemuxer(Sideband64k, buf)
n, err := io.ReadFull(d, content)
c.Assert(err, IsNil)
c.Assert(n, Equals, 13)
c.Assert(content, DeepEquals, expected[0:13])
n, err = d.Read(content)
c.Assert(err, IsNil)
c.Assert(n, Equals, 13)
c.Assert(content, DeepEquals, expected[13:26])
}
func (s *SidebandSuite) TestDecodeErrMaxPacked(c *C) {
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
e.Encode(PackData.WithPayload(bytes.Repeat([]byte{'0'}, MaxPackedSize+1)))
content := make([]byte, 13)
d := NewDemuxer(Sideband, buf)
n, err := io.ReadFull(d, content)
c.Assert(err, Equals, ErrMaxPackedExceeded)
c.Assert(n, Equals, 0)
}
go-git-5.13.2/plumbing/protocol/packp/sideband/doc.go 0000664 0000000 0000000 00000002513 14744245500 0022417 0 ustar 00root root 0000000 0000000 // Package sideband implements a sideband mutiplex/demultiplexer
package sideband
// If 'side-band' or 'side-band-64k' capabilities have been specified by
// the client, the server will send the packfile data multiplexed.
//
// Either mode indicates that the packfile data will be streamed broken
// up into packets of up to either 1000 bytes in the case of 'side_band',
// or 65520 bytes in the case of 'side_band_64k'. Each packet is made up
// of a leading 4-byte pkt-line length of how much data is in the packet,
// followed by a 1-byte stream code, followed by the actual data.
//
// The stream code can be one of:
//
// 1 - pack data
// 2 - progress messages
// 3 - fatal error message just before stream aborts
//
// The "side-band-64k" capability came about as a way for newer clients
// that can handle much larger packets to request packets that are
// actually crammed nearly full, while maintaining backward compatibility
// for the older clients.
//
// Further, with side-band and its up to 1000-byte messages, it's actually
// 999 bytes of payload and 1 byte for the stream code. With side-band-64k,
// same deal, you have up to 65519 bytes of data and 1 byte for the stream
// code.
//
// The client MUST send only maximum of one of "side-band" and "side-
// band-64k". Server MUST diagnose it as an error if client requests
// both.
go-git-5.13.2/plumbing/protocol/packp/sideband/muxer.go 0000664 0000000 0000000 00000002726 14744245500 0023020 0 ustar 00root root 0000000 0000000 package sideband
import (
"io"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
)
// Muxer multiplex the packfile along with the progress messages and the error
// information. The multiplex is perform using pktline format.
type Muxer struct {
max int
e *pktline.Encoder
}
const chLen = 1
// NewMuxer returns a new Muxer for the given t that writes on w.
//
// If t is equal to `Sideband` the max pack size is set to MaxPackedSize, in any
// other value is given, max pack is set to MaxPackedSize64k, that is the
// maximum length of a line in pktline format.
func NewMuxer(t Type, w io.Writer) *Muxer {
max := MaxPackedSize64k
if t == Sideband {
max = MaxPackedSize
}
return &Muxer{
max: max - chLen,
e: pktline.NewEncoder(w),
}
}
// Write writes p in the PackData channel
func (m *Muxer) Write(p []byte) (int, error) {
return m.WriteChannel(PackData, p)
}
// WriteChannel writes p in the given channel. This method can be used with any
// channel, but is recommend use it only for the ProgressMessage and
// ErrorMessage channels and use Write for the PackData channel
func (m *Muxer) WriteChannel(t Channel, p []byte) (int, error) {
wrote := 0
size := len(p)
for wrote < size {
n, err := m.doWrite(t, p[wrote:])
wrote += n
if err != nil {
return wrote, err
}
}
return wrote, nil
}
func (m *Muxer) doWrite(ch Channel, p []byte) (int, error) {
sz := len(p)
if sz > m.max {
sz = m.max
}
return sz, m.e.Encode(ch.WithPayload(p[:sz]))
}
go-git-5.13.2/plumbing/protocol/packp/sideband/muxer_test.go 0000664 0000000 0000000 00000001613 14744245500 0024051 0 ustar 00root root 0000000 0000000 package sideband
import (
"bytes"
. "gopkg.in/check.v1"
)
func (s *SidebandSuite) TestMuxerWrite(c *C) {
buf := bytes.NewBuffer(nil)
m := NewMuxer(Sideband, buf)
n, err := m.Write(bytes.Repeat([]byte{'F'}, (MaxPackedSize-1)*2))
c.Assert(err, IsNil)
c.Assert(n, Equals, 1998)
c.Assert(buf.Len(), Equals, 2008)
}
func (s *SidebandSuite) TestMuxerWriteChannelMultipleChannels(c *C) {
buf := bytes.NewBuffer(nil)
m := NewMuxer(Sideband, buf)
n, err := m.WriteChannel(PackData, bytes.Repeat([]byte{'D'}, 4))
c.Assert(err, IsNil)
c.Assert(n, Equals, 4)
n, err = m.WriteChannel(ProgressMessage, bytes.Repeat([]byte{'P'}, 4))
c.Assert(err, IsNil)
c.Assert(n, Equals, 4)
n, err = m.WriteChannel(PackData, bytes.Repeat([]byte{'D'}, 4))
c.Assert(err, IsNil)
c.Assert(n, Equals, 4)
c.Assert(buf.Len(), Equals, 27)
c.Assert(buf.String(), Equals, "0009\x01DDDD0009\x02PPPP0009\x01DDDD")
}
go-git-5.13.2/plumbing/protocol/packp/srvresp.go 0000664 0000000 0000000 00000006672 14744245500 0021617 0 ustar 00root root 0000000 0000000 package packp
import (
"bufio"
"bytes"
"errors"
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
)
const ackLineLen = 44
// ServerResponse object acknowledgement from upload-pack service
type ServerResponse struct {
ACKs []plumbing.Hash
}
// Decode decodes the response into the struct, isMultiACK should be true, if
// the request was done with multi_ack or multi_ack_detailed capabilities.
func (r *ServerResponse) Decode(reader *bufio.Reader, isMultiACK bool) error {
s := pktline.NewScanner(reader)
for s.Scan() {
line := s.Bytes()
if err := r.decodeLine(line); err != nil {
return err
}
// we need to detect when the end of a response header and the beginning
// of a packfile header happened, some requests to the git daemon
// produces a duplicate ACK header even when multi_ack is not supported.
stop, err := r.stopReading(reader)
if err != nil {
return err
}
if stop {
break
}
}
// isMultiACK is true when the remote server advertises the related
// capabilities when they are not in transport.UnsupportedCapabilities.
//
// Users may decide to remove multi_ack and multi_ack_detailed from the
// unsupported capabilities list, which allows them to do initial clones
// from Azure DevOps.
//
// Follow-up fetches may error, therefore errors are wrapped with additional
// information highlighting that this capabilities are not supported by go-git.
//
// TODO: Implement support for multi_ack or multi_ack_detailed responses.
err := s.Err()
if err != nil && isMultiACK {
return fmt.Errorf("multi_ack and multi_ack_detailed are not supported: %w", err)
}
return err
}
// stopReading detects when a valid command such as ACK or NAK is found to be
// read in the buffer without moving the read pointer.
func (r *ServerResponse) stopReading(reader *bufio.Reader) (bool, error) {
ahead, err := reader.Peek(7)
if err == io.EOF {
return true, nil
}
if err != nil {
return false, err
}
if len(ahead) > 4 && r.isValidCommand(ahead[0:3]) {
return false, nil
}
if len(ahead) == 7 && r.isValidCommand(ahead[4:]) {
return false, nil
}
return true, nil
}
func (r *ServerResponse) isValidCommand(b []byte) bool {
commands := [][]byte{ack, nak}
for _, c := range commands {
if bytes.Equal(b, c) {
return true
}
}
return false
}
func (r *ServerResponse) decodeLine(line []byte) error {
if len(line) == 0 {
return fmt.Errorf("unexpected flush")
}
if len(line) >= 3 {
if bytes.Equal(line[0:3], ack) {
return r.decodeACKLine(line)
}
if bytes.Equal(line[0:3], nak) {
return nil
}
}
return fmt.Errorf("unexpected content %q", string(line))
}
func (r *ServerResponse) decodeACKLine(line []byte) error {
if len(line) < ackLineLen {
return fmt.Errorf("malformed ACK %q", line)
}
sp := bytes.Index(line, []byte(" "))
if sp+41 > len(line) {
return fmt.Errorf("malformed ACK %q", line)
}
h := plumbing.NewHash(string(line[sp+1 : sp+41]))
r.ACKs = append(r.ACKs, h)
return nil
}
// Encode encodes the ServerResponse into a writer.
func (r *ServerResponse) Encode(w io.Writer, isMultiACK bool) error {
if len(r.ACKs) > 1 && !isMultiACK {
// For further information, refer to comments in the Decode func above.
return errors.New("multi_ack and multi_ack_detailed are not supported")
}
e := pktline.NewEncoder(w)
if len(r.ACKs) == 0 {
return e.Encodef("%s\n", nak)
}
return e.Encodef("%s %s\n", ack, r.ACKs[0].String())
}
go-git-5.13.2/plumbing/protocol/packp/srvresp_test.go 0000664 0000000 0000000 00000006713 14744245500 0022652 0 ustar 00root root 0000000 0000000 package packp
import (
"bufio"
"bytes"
"fmt"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
type ServerResponseSuite struct{}
var _ = Suite(&ServerResponseSuite{})
func (s *ServerResponseSuite) TestDecodeNAK(c *C) {
raw := "0008NAK\n"
sr := &ServerResponse{}
err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false)
c.Assert(err, IsNil)
c.Assert(sr.ACKs, HasLen, 0)
}
func (s *ServerResponseSuite) TestDecodeNewLine(c *C) {
raw := "\n"
sr := &ServerResponse{}
err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false)
c.Assert(err, NotNil)
c.Assert(err.Error(), Equals, "invalid pkt-len found")
}
func (s *ServerResponseSuite) TestDecodeEmpty(c *C) {
raw := ""
sr := &ServerResponse{}
err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false)
c.Assert(err, IsNil)
}
func (s *ServerResponseSuite) TestDecodePartial(c *C) {
raw := "000600\n"
sr := &ServerResponse{}
err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false)
c.Assert(err, NotNil)
c.Assert(err.Error(), Equals, fmt.Sprintf("unexpected content %q", "00"))
}
func (s *ServerResponseSuite) TestDecodeACK(c *C) {
raw := "0031ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e5\n"
sr := &ServerResponse{}
err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false)
c.Assert(err, IsNil)
c.Assert(sr.ACKs, HasLen, 1)
c.Assert(sr.ACKs[0], Equals, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
}
func (s *ServerResponseSuite) TestDecodeMultipleACK(c *C) {
raw := "" +
"0031ACK 1111111111111111111111111111111111111111\n" +
"0031ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e5\n" +
"00080PACK\n"
sr := &ServerResponse{}
err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false)
c.Assert(err, IsNil)
c.Assert(sr.ACKs, HasLen, 2)
c.Assert(sr.ACKs[0], Equals, plumbing.NewHash("1111111111111111111111111111111111111111"))
c.Assert(sr.ACKs[1], Equals, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
}
func (s *ServerResponseSuite) TestDecodeMultipleACKWithSideband(c *C) {
raw := "" +
"0031ACK 1111111111111111111111111111111111111111\n" +
"0031ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e5\n" +
"00080aaaa\n"
sr := &ServerResponse{}
err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false)
c.Assert(err, IsNil)
c.Assert(sr.ACKs, HasLen, 2)
c.Assert(sr.ACKs[0], Equals, plumbing.NewHash("1111111111111111111111111111111111111111"))
c.Assert(sr.ACKs[1], Equals, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
}
func (s *ServerResponseSuite) TestDecodeMalformed(c *C) {
raw := "0029ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e\n"
sr := &ServerResponse{}
err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), false)
c.Assert(err, NotNil)
}
// multi_ack isn't fully implemented, this ensures that Decode ignores that fact,
// as in some circumstances that's OK to assume so.
//
// TODO: Review as part of multi_ack implementation.
func (s *ServerResponseSuite) TestDecodeMultiACK(c *C) {
raw := "" +
"0031ACK 1111111111111111111111111111111111111111\n" +
"0031ACK 6ecf0ef2c2dffb796033e5a02219af86ec6584e5\n" +
"00080PACK\n"
sr := &ServerResponse{}
err := sr.Decode(bufio.NewReader(bytes.NewBufferString(raw)), true)
c.Assert(err, IsNil)
c.Assert(sr.ACKs, HasLen, 2)
c.Assert(sr.ACKs[0], Equals, plumbing.NewHash("1111111111111111111111111111111111111111"))
c.Assert(sr.ACKs[1], Equals, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
}
go-git-5.13.2/plumbing/protocol/packp/ulreq.go 0000664 0000000 0000000 00000011627 14744245500 0021237 0 ustar 00root root 0000000 0000000 package packp
import (
"fmt"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
)
// UploadRequest values represent the information transmitted on a
// upload-request message. Values from this type are not zero-value
// safe, use the New function instead.
// This is a low level type, use UploadPackRequest instead.
type UploadRequest struct {
Capabilities *capability.List
Wants []plumbing.Hash
Shallows []plumbing.Hash
Depth Depth
Filter Filter
}
// Depth values stores the desired depth of the requested packfile: see
// DepthCommit, DepthSince and DepthReference.
type Depth interface {
isDepth()
IsZero() bool
}
// DepthCommits values stores the maximum number of requested commits in
// the packfile. Zero means infinite. A negative value will have
// undefined consequences.
type DepthCommits int
func (d DepthCommits) isDepth() {}
func (d DepthCommits) IsZero() bool {
return d == 0
}
// DepthSince values requests only commits newer than the specified time.
type DepthSince time.Time
func (d DepthSince) isDepth() {}
func (d DepthSince) IsZero() bool {
return time.Time(d).IsZero()
}
// DepthReference requests only commits not to found in the specified reference.
type DepthReference string
func (d DepthReference) isDepth() {}
func (d DepthReference) IsZero() bool {
return string(d) == ""
}
// NewUploadRequest returns a pointer to a new UploadRequest value, ready to be
// used. It has no capabilities, wants or shallows and an infinite depth. Please
// note that to encode an upload-request it has to have at least one wanted hash.
func NewUploadRequest() *UploadRequest {
return &UploadRequest{
Capabilities: capability.NewList(),
Wants: []plumbing.Hash{},
Shallows: []plumbing.Hash{},
Depth: DepthCommits(0),
}
}
// NewUploadRequestFromCapabilities returns a pointer to a new UploadRequest
// value, the request capabilities are filled with the most optimal ones, based
// on the adv value (advertised capabilities), the UploadRequest generated it
// has no wants or shallows and an infinite depth.
func NewUploadRequestFromCapabilities(adv *capability.List) *UploadRequest {
r := NewUploadRequest()
if adv.Supports(capability.MultiACKDetailed) {
r.Capabilities.Set(capability.MultiACKDetailed)
} else if adv.Supports(capability.MultiACK) {
r.Capabilities.Set(capability.MultiACK)
}
if adv.Supports(capability.Sideband64k) {
r.Capabilities.Set(capability.Sideband64k)
} else if adv.Supports(capability.Sideband) {
r.Capabilities.Set(capability.Sideband)
}
if adv.Supports(capability.ThinPack) {
r.Capabilities.Set(capability.ThinPack)
}
if adv.Supports(capability.OFSDelta) {
r.Capabilities.Set(capability.OFSDelta)
}
if adv.Supports(capability.Agent) {
r.Capabilities.Set(capability.Agent, capability.DefaultAgent())
}
return r
}
// Validate validates the content of UploadRequest, following the next rules:
// - Wants MUST have at least one reference
// - capability.Shallow MUST be present if Shallows is not empty
// - is a non-zero DepthCommits is given capability.Shallow MUST be present
// - is a DepthSince is given capability.Shallow MUST be present
// - is a DepthReference is given capability.DeepenNot MUST be present
// - MUST contain only maximum of one of capability.Sideband and capability.Sideband64k
// - MUST contain only maximum of one of capability.MultiACK and capability.MultiACKDetailed
func (req *UploadRequest) Validate() error {
if len(req.Wants) == 0 {
return fmt.Errorf("want can't be empty")
}
if err := req.validateRequiredCapabilities(); err != nil {
return err
}
if err := req.validateConflictCapabilities(); err != nil {
return err
}
return nil
}
func (req *UploadRequest) validateRequiredCapabilities() error {
msg := "missing capability %s"
if len(req.Shallows) != 0 && !req.Capabilities.Supports(capability.Shallow) {
return fmt.Errorf(msg, capability.Shallow)
}
switch req.Depth.(type) {
case DepthCommits:
if req.Depth != DepthCommits(0) {
if !req.Capabilities.Supports(capability.Shallow) {
return fmt.Errorf(msg, capability.Shallow)
}
}
case DepthSince:
if !req.Capabilities.Supports(capability.DeepenSince) {
return fmt.Errorf(msg, capability.DeepenSince)
}
case DepthReference:
if !req.Capabilities.Supports(capability.DeepenNot) {
return fmt.Errorf(msg, capability.DeepenNot)
}
}
return nil
}
func (req *UploadRequest) validateConflictCapabilities() error {
msg := "capabilities %s and %s are mutually exclusive"
if req.Capabilities.Supports(capability.Sideband) &&
req.Capabilities.Supports(capability.Sideband64k) {
return fmt.Errorf(msg, capability.Sideband, capability.Sideband64k)
}
if req.Capabilities.Supports(capability.MultiACK) &&
req.Capabilities.Supports(capability.MultiACKDetailed) {
return fmt.Errorf(msg, capability.MultiACK, capability.MultiACKDetailed)
}
return nil
}
go-git-5.13.2/plumbing/protocol/packp/ulreq_decode.go 0000664 0000000 0000000 00000012543 14744245500 0022540 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"encoding/hex"
"fmt"
"io"
"strconv"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
)
// Decode reads the next upload-request form its input and
// stores it in the UploadRequest.
func (req *UploadRequest) Decode(r io.Reader) error {
d := newUlReqDecoder(r)
return d.Decode(req)
}
type ulReqDecoder struct {
s *pktline.Scanner // a pkt-line scanner from the input stream
line []byte // current pkt-line contents, use parser.nextLine() to make it advance
nLine int // current pkt-line number for debugging, begins at 1
err error // sticky error, use the parser.error() method to fill this out
data *UploadRequest // parsed data is stored here
}
func newUlReqDecoder(r io.Reader) *ulReqDecoder {
return &ulReqDecoder{
s: pktline.NewScanner(r),
}
}
func (d *ulReqDecoder) Decode(v *UploadRequest) error {
d.data = v
for state := d.decodeFirstWant; state != nil; {
state = state()
}
return d.err
}
// fills out the parser sticky error
func (d *ulReqDecoder) error(format string, a ...interface{}) {
msg := fmt.Sprintf(
"pkt-line %d: %s", d.nLine,
fmt.Sprintf(format, a...),
)
d.err = NewErrUnexpectedData(msg, d.line)
}
// Reads a new pkt-line from the scanner, makes its payload available as
// p.line and increments p.nLine. A successful invocation returns true,
// otherwise, false is returned and the sticky error is filled out
// accordingly. Trims eols at the end of the payloads.
func (d *ulReqDecoder) nextLine() bool {
d.nLine++
if !d.s.Scan() {
if d.err = d.s.Err(); d.err != nil {
return false
}
d.error("EOF")
return false
}
d.line = d.s.Bytes()
d.line = bytes.TrimSuffix(d.line, eol)
return true
}
// Expected format: want [ capabilities]
func (d *ulReqDecoder) decodeFirstWant() stateFn {
if ok := d.nextLine(); !ok {
return nil
}
if !bytes.HasPrefix(d.line, want) {
d.error("missing 'want ' prefix")
return nil
}
d.line = bytes.TrimPrefix(d.line, want)
hash, ok := d.readHash()
if !ok {
return nil
}
d.data.Wants = append(d.data.Wants, hash)
return d.decodeCaps
}
func (d *ulReqDecoder) readHash() (plumbing.Hash, bool) {
if len(d.line) < hashSize {
d.err = fmt.Errorf("malformed hash: %v", d.line)
return plumbing.ZeroHash, false
}
var hash plumbing.Hash
if _, err := hex.Decode(hash[:], d.line[:hashSize]); err != nil {
d.error("invalid hash text: %s", err)
return plumbing.ZeroHash, false
}
d.line = d.line[hashSize:]
return hash, true
}
// Expected format: sp cap1 sp cap2 sp cap3...
func (d *ulReqDecoder) decodeCaps() stateFn {
d.line = bytes.TrimPrefix(d.line, sp)
if err := d.data.Capabilities.Decode(d.line); err != nil {
d.error("invalid capabilities: %s", err)
}
return d.decodeOtherWants
}
// Expected format: want
func (d *ulReqDecoder) decodeOtherWants() stateFn {
if ok := d.nextLine(); !ok {
return nil
}
if bytes.HasPrefix(d.line, shallow) {
return d.decodeShallow
}
if bytes.HasPrefix(d.line, deepen) {
return d.decodeDeepen
}
if len(d.line) == 0 {
return nil
}
if !bytes.HasPrefix(d.line, want) {
d.error("unexpected payload while expecting a want: %q", d.line)
return nil
}
d.line = bytes.TrimPrefix(d.line, want)
hash, ok := d.readHash()
if !ok {
return nil
}
d.data.Wants = append(d.data.Wants, hash)
return d.decodeOtherWants
}
// Expected format: shallow
func (d *ulReqDecoder) decodeShallow() stateFn {
if bytes.HasPrefix(d.line, deepen) {
return d.decodeDeepen
}
if len(d.line) == 0 {
return nil
}
if !bytes.HasPrefix(d.line, shallow) {
d.error("unexpected payload while expecting a shallow: %q", d.line)
return nil
}
d.line = bytes.TrimPrefix(d.line, shallow)
hash, ok := d.readHash()
if !ok {
return nil
}
d.data.Shallows = append(d.data.Shallows, hash)
if ok := d.nextLine(); !ok {
return nil
}
return d.decodeShallow
}
// Expected format: deepen / deepen-since / deepen-not [
func (d *ulReqDecoder) decodeDeepen() stateFn {
if bytes.HasPrefix(d.line, deepenCommits) {
return d.decodeDeepenCommits
}
if bytes.HasPrefix(d.line, deepenSince) {
return d.decodeDeepenSince
}
if bytes.HasPrefix(d.line, deepenReference) {
return d.decodeDeepenReference
}
if len(d.line) == 0 {
return nil
}
d.error("unexpected deepen specification: %q", d.line)
return nil
}
func (d *ulReqDecoder) decodeDeepenCommits() stateFn {
d.line = bytes.TrimPrefix(d.line, deepenCommits)
var n int
if n, d.err = strconv.Atoi(string(d.line)); d.err != nil {
return nil
}
if n < 0 {
d.err = fmt.Errorf("negative depth")
return nil
}
d.data.Depth = DepthCommits(n)
return d.decodeFlush
}
func (d *ulReqDecoder) decodeDeepenSince() stateFn {
d.line = bytes.TrimPrefix(d.line, deepenSince)
var secs int64
secs, d.err = strconv.ParseInt(string(d.line), 10, 64)
if d.err != nil {
return nil
}
t := time.Unix(secs, 0).UTC()
d.data.Depth = DepthSince(t)
return d.decodeFlush
}
func (d *ulReqDecoder) decodeDeepenReference() stateFn {
d.line = bytes.TrimPrefix(d.line, deepenReference)
d.data.Depth = DepthReference(string(d.line))
return d.decodeFlush
}
func (d *ulReqDecoder) decodeFlush() stateFn {
if ok := d.nextLine(); !ok {
return nil
}
if len(d.line) != 0 {
d.err = fmt.Errorf("unexpected payload while expecting a flush-pkt: %q", d.line)
}
return nil
}
go-git-5.13.2/plumbing/protocol/packp/ulreq_decode_test.go 0000664 0000000 0000000 00000041202 14744245500 0023571 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"io"
"sort"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
. "gopkg.in/check.v1"
)
type UlReqDecodeSuite struct{}
var _ = Suite(&UlReqDecodeSuite{})
func (s *UlReqDecodeSuite) TestEmpty(c *C) {
ur := NewUploadRequest()
var buf bytes.Buffer
d := newUlReqDecoder(&buf)
err := d.Decode(ur)
c.Assert(err, ErrorMatches, "pkt-line 1: EOF")
}
func (s *UlReqDecodeSuite) TestNoWant(c *C) {
payloads := []string{
"foobar",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*missing 'want '.*")
}
func (s *UlReqDecodeSuite) testDecoderErrorMatches(c *C, input io.Reader, pattern string) {
ur := NewUploadRequest()
d := newUlReqDecoder(input)
err := d.Decode(ur)
c.Assert(err, ErrorMatches, pattern)
}
func (s *UlReqDecodeSuite) TestInvalidFirstHash(c *C) {
payloads := []string{
"want 6ecf0ef2c2dffb796alberto2219af86ec6584e5\n",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*invalid hash.*")
}
func (s *UlReqDecodeSuite) TestWantOK(c *C) {
payloads := []string{
"want 1111111111111111111111111111111111111111",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
c.Assert(ur.Wants, DeepEquals, []plumbing.Hash{
plumbing.NewHash("1111111111111111111111111111111111111111"),
})
}
func (s *UlReqDecodeSuite) testDecodeOK(c *C, payloads []string) *UploadRequest {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(payloads...)
c.Assert(err, IsNil)
ur := NewUploadRequest()
d := newUlReqDecoder(&buf)
err = d.Decode(ur)
c.Assert(err, IsNil)
return ur
}
func (s *UlReqDecodeSuite) TestWantWithCapabilities(c *C) {
payloads := []string{
"want 1111111111111111111111111111111111111111 ofs-delta multi_ack",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
c.Assert(ur.Wants, DeepEquals, []plumbing.Hash{
plumbing.NewHash("1111111111111111111111111111111111111111")})
c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true)
c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true)
}
func (s *UlReqDecodeSuite) TestManyWantsNoCapabilities(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333",
"want 4444444444444444444444444444444444444444",
"want 1111111111111111111111111111111111111111",
"want 2222222222222222222222222222222222222222",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
expected := []plumbing.Hash{
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("4444444444444444444444444444444444444444"),
}
sort.Sort(byHash(ur.Wants))
sort.Sort(byHash(expected))
c.Assert(ur.Wants, DeepEquals, expected)
}
type byHash []plumbing.Hash
func (a byHash) Len() int { return len(a) }
func (a byHash) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a byHash) Less(i, j int) bool {
ii := [hash.Size]byte(a[i])
jj := [hash.Size]byte(a[j])
return bytes.Compare(ii[:], jj[:]) < 0
}
func (s *UlReqDecodeSuite) TestManyWantsBadWant(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333",
"want 4444444444444444444444444444444444444444",
"foo",
"want 2222222222222222222222222222222222222222",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
}
func (s *UlReqDecodeSuite) TestManyWantsInvalidHash(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333",
"want 4444444444444444444444444444444444444444",
"want 1234567890abcdef",
"want 2222222222222222222222222222222222222222",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*malformed hash.*")
}
func (s *UlReqDecodeSuite) TestManyWantsWithCapabilities(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"want 4444444444444444444444444444444444444444",
"want 1111111111111111111111111111111111111111",
"want 2222222222222222222222222222222222222222",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
expected := []plumbing.Hash{
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("4444444444444444444444444444444444444444"),
}
sort.Sort(byHash(ur.Wants))
sort.Sort(byHash(expected))
c.Assert(ur.Wants, DeepEquals, expected)
c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true)
c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true)
}
func (s *UlReqDecodeSuite) TestSingleShallowSingleWant(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
expectedWants := []plumbing.Hash{
plumbing.NewHash("3333333333333333333333333333333333333333"),
}
expectedShallows := []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
}
c.Assert(ur.Wants, DeepEquals, expectedWants)
c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true)
c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true)
c.Assert(ur.Shallows, DeepEquals, expectedShallows)
}
func (s *UlReqDecodeSuite) TestSingleShallowManyWants(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"want 4444444444444444444444444444444444444444",
"want 1111111111111111111111111111111111111111",
"want 2222222222222222222222222222222222222222",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
expectedWants := []plumbing.Hash{
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("4444444444444444444444444444444444444444"),
}
sort.Sort(byHash(expectedWants))
expectedShallows := []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
}
sort.Sort(byHash(ur.Wants))
c.Assert(ur.Wants, DeepEquals, expectedWants)
c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true)
c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true)
c.Assert(ur.Shallows, DeepEquals, expectedShallows)
}
func (s *UlReqDecodeSuite) TestManyShallowSingleWant(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"shallow cccccccccccccccccccccccccccccccccccccccc",
"shallow dddddddddddddddddddddddddddddddddddddddd",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
expectedWants := []plumbing.Hash{
plumbing.NewHash("3333333333333333333333333333333333333333"),
}
expectedShallows := []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
plumbing.NewHash("cccccccccccccccccccccccccccccccccccccccc"),
plumbing.NewHash("dddddddddddddddddddddddddddddddddddddddd"),
}
sort.Sort(byHash(expectedShallows))
c.Assert(ur.Wants, DeepEquals, expectedWants)
c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true)
c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true)
sort.Sort(byHash(ur.Shallows))
c.Assert(ur.Shallows, DeepEquals, expectedShallows)
}
func (s *UlReqDecodeSuite) TestManyShallowManyWants(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"want 4444444444444444444444444444444444444444",
"want 1111111111111111111111111111111111111111",
"want 2222222222222222222222222222222222222222",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"shallow cccccccccccccccccccccccccccccccccccccccc",
"shallow dddddddddddddddddddddddddddddddddddddddd",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
expectedWants := []plumbing.Hash{
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("4444444444444444444444444444444444444444"),
}
sort.Sort(byHash(expectedWants))
expectedShallows := []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
plumbing.NewHash("cccccccccccccccccccccccccccccccccccccccc"),
plumbing.NewHash("dddddddddddddddddddddddddddddddddddddddd"),
}
sort.Sort(byHash(expectedShallows))
sort.Sort(byHash(ur.Wants))
c.Assert(ur.Wants, DeepEquals, expectedWants)
c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true)
c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true)
sort.Sort(byHash(ur.Shallows))
c.Assert(ur.Shallows, DeepEquals, expectedShallows)
}
func (s *UlReqDecodeSuite) TestMalformedShallow(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"shalow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
}
func (s *UlReqDecodeSuite) TestMalformedShallowHash(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*malformed hash.*")
}
func (s *UlReqDecodeSuite) TestMalformedShallowManyShallows(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"shalow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"shallow cccccccccccccccccccccccccccccccccccccccc",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
}
func (s *UlReqDecodeSuite) TestMalformedDeepenSpec(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"deepen-foo 34",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*unexpected deepen.*")
}
func (s *UlReqDecodeSuite) TestMalformedDeepenSingleWant(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"depth 32",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
}
func (s *UlReqDecodeSuite) TestMalformedDeepenMultiWant(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"want 2222222222222222222222222222222222222222",
"depth 32",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
}
func (s *UlReqDecodeSuite) TestMalformedDeepenWithSingleShallow(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"shallow 2222222222222222222222222222222222222222",
"depth 32",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
}
func (s *UlReqDecodeSuite) TestMalformedDeepenWithMultiShallow(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"shallow 2222222222222222222222222222222222222222",
"shallow 5555555555555555555555555555555555555555",
"depth 32",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
}
func (s *UlReqDecodeSuite) TestDeepenCommits(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"deepen 1234",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
c.Assert(ur.Depth, FitsTypeOf, DepthCommits(0))
commits, ok := ur.Depth.(DepthCommits)
c.Assert(ok, Equals, true)
c.Assert(int(commits), Equals, 1234)
}
func (s *UlReqDecodeSuite) TestDeepenCommitsInfiniteImplicit(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"deepen 0",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
c.Assert(ur.Depth, FitsTypeOf, DepthCommits(0))
commits, ok := ur.Depth.(DepthCommits)
c.Assert(ok, Equals, true)
c.Assert(int(commits), Equals, 0)
}
func (s *UlReqDecodeSuite) TestDeepenCommitsInfiniteExplicit(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
c.Assert(ur.Depth, FitsTypeOf, DepthCommits(0))
commits, ok := ur.Depth.(DepthCommits)
c.Assert(ok, Equals, true)
c.Assert(int(commits), Equals, 0)
}
func (s *UlReqDecodeSuite) TestMalformedDeepenCommits(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"deepen -32",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*negative depth.*")
}
func (s *UlReqDecodeSuite) TestDeepenCommitsEmpty(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"deepen ",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*invalid syntax.*")
}
func (s *UlReqDecodeSuite) TestDeepenSince(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"deepen-since 1420167845", // 2015-01-02T03:04:05+00:00
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
expected := time.Date(2015, time.January, 2, 3, 4, 5, 0, time.UTC)
c.Assert(ur.Depth, FitsTypeOf, DepthSince(time.Now()))
since, ok := ur.Depth.(DepthSince)
c.Assert(ok, Equals, true)
c.Assert(time.Time(since).Equal(expected), Equals, true,
Commentf("obtained=%s\nexpected=%s", time.Time(since), expected))
}
func (s *UlReqDecodeSuite) TestDeepenReference(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"deepen-not refs/heads/master",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
expected := "refs/heads/master"
c.Assert(ur.Depth, FitsTypeOf, DepthReference(""))
reference, ok := ur.Depth.(DepthReference)
c.Assert(ok, Equals, true)
c.Assert(string(reference), Equals, expected)
}
func (s *UlReqDecodeSuite) TestAll(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"want 4444444444444444444444444444444444444444",
"want 1111111111111111111111111111111111111111",
"want 2222222222222222222222222222222222222222",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"shallow cccccccccccccccccccccccccccccccccccccccc",
"shallow dddddddddddddddddddddddddddddddddddddddd",
"deepen 1234",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
expectedWants := []plumbing.Hash{
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("4444444444444444444444444444444444444444"),
}
sort.Sort(byHash(expectedWants))
sort.Sort(byHash(ur.Wants))
c.Assert(ur.Wants, DeepEquals, expectedWants)
c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true)
c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true)
expectedShallows := []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
plumbing.NewHash("cccccccccccccccccccccccccccccccccccccccc"),
plumbing.NewHash("dddddddddddddddddddddddddddddddddddddddd"),
}
sort.Sort(byHash(expectedShallows))
sort.Sort(byHash(ur.Shallows))
c.Assert(ur.Shallows, DeepEquals, expectedShallows)
c.Assert(ur.Depth, FitsTypeOf, DepthCommits(0))
commits, ok := ur.Depth.(DepthCommits)
c.Assert(ok, Equals, true)
c.Assert(int(commits), Equals, 1234)
}
func (s *UlReqDecodeSuite) TestExtraData(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"deepen 32",
"foo",
pktline.FlushString,
}
r := toPktLines(c, payloads)
s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
}
go-git-5.13.2/plumbing/protocol/packp/ulreq_encode.go 0000664 0000000 0000000 00000006427 14744245500 0022556 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"fmt"
"io"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
)
// Encode writes the UlReq encoding of u to the stream.
//
// All the payloads will end with a newline character. Wants and
// shallows are sorted alphabetically. A depth of 0 means no depth
// request is sent.
func (req *UploadRequest) Encode(w io.Writer) error {
e := newUlReqEncoder(w)
return e.Encode(req)
}
type ulReqEncoder struct {
pe *pktline.Encoder // where to write the encoded data
data *UploadRequest // the data to encode
err error // sticky error
}
func newUlReqEncoder(w io.Writer) *ulReqEncoder {
return &ulReqEncoder{
pe: pktline.NewEncoder(w),
}
}
func (e *ulReqEncoder) Encode(v *UploadRequest) error {
e.data = v
if len(v.Wants) == 0 {
return fmt.Errorf("empty wants provided")
}
plumbing.HashesSort(e.data.Wants)
for state := e.encodeFirstWant; state != nil; {
state = state()
}
return e.err
}
func (e *ulReqEncoder) encodeFirstWant() stateFn {
var err error
if e.data.Capabilities.IsEmpty() {
err = e.pe.Encodef("want %s\n", e.data.Wants[0])
} else {
err = e.pe.Encodef(
"want %s %s\n",
e.data.Wants[0],
e.data.Capabilities.String(),
)
}
if err != nil {
e.err = fmt.Errorf("encoding first want line: %s", err)
return nil
}
return e.encodeAdditionalWants
}
func (e *ulReqEncoder) encodeAdditionalWants() stateFn {
last := e.data.Wants[0]
for _, w := range e.data.Wants[1:] {
if bytes.Equal(last[:], w[:]) {
continue
}
if err := e.pe.Encodef("want %s\n", w); err != nil {
e.err = fmt.Errorf("encoding want %q: %s", w, err)
return nil
}
last = w
}
return e.encodeShallows
}
func (e *ulReqEncoder) encodeShallows() stateFn {
plumbing.HashesSort(e.data.Shallows)
var last plumbing.Hash
for _, s := range e.data.Shallows {
if bytes.Equal(last[:], s[:]) {
continue
}
if err := e.pe.Encodef("shallow %s\n", s); err != nil {
e.err = fmt.Errorf("encoding shallow %q: %s", s, err)
return nil
}
last = s
}
return e.encodeDepth
}
func (e *ulReqEncoder) encodeDepth() stateFn {
switch depth := e.data.Depth.(type) {
case DepthCommits:
if depth != 0 {
commits := int(depth)
if err := e.pe.Encodef("deepen %d\n", commits); err != nil {
e.err = fmt.Errorf("encoding depth %d: %s", depth, err)
return nil
}
}
case DepthSince:
when := time.Time(depth).UTC()
if err := e.pe.Encodef("deepen-since %d\n", when.Unix()); err != nil {
e.err = fmt.Errorf("encoding depth %s: %s", when, err)
return nil
}
case DepthReference:
reference := string(depth)
if err := e.pe.Encodef("deepen-not %s\n", reference); err != nil {
e.err = fmt.Errorf("encoding depth %s: %s", reference, err)
return nil
}
default:
e.err = fmt.Errorf("unsupported depth type")
return nil
}
return e.encodeFilter
}
func (e *ulReqEncoder) encodeFilter() stateFn {
if filter := e.data.Filter; filter != "" {
if err := e.pe.Encodef("filter %s\n", filter); err != nil {
e.err = fmt.Errorf("encoding filter %s: %s", filter, err)
return nil
}
}
return e.encodeFlush
}
func (e *ulReqEncoder) encodeFlush() stateFn {
if err := e.pe.Flush(); err != nil {
e.err = fmt.Errorf("encoding flush-pkt: %s", err)
return nil
}
return nil
}
go-git-5.13.2/plumbing/protocol/packp/ulreq_encode_test.go 0000664 0000000 0000000 00000025376 14744245500 0023621 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"runtime"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
. "gopkg.in/check.v1"
)
type UlReqEncodeSuite struct{}
var _ = Suite(&UlReqEncodeSuite{})
func testUlReqEncode(c *C, ur *UploadRequest, expectedPayloads []string) {
var buf bytes.Buffer
e := newUlReqEncoder(&buf)
err := e.Encode(ur)
c.Assert(err, IsNil)
obtained := buf.Bytes()
expected := pktlines(c, expectedPayloads...)
comment := Commentf("\nobtained = %s\nexpected = %s\n", string(obtained), string(expected))
c.Assert(obtained, DeepEquals, expected, comment)
}
func testUlReqEncodeError(c *C, ur *UploadRequest, expectedErrorRegEx string) {
var buf bytes.Buffer
e := newUlReqEncoder(&buf)
err := e.Encode(ur)
c.Assert(err, ErrorMatches, expectedErrorRegEx)
}
func (s *UlReqEncodeSuite) TestZeroValue(c *C) {
ur := NewUploadRequest()
expectedErrorRegEx := ".*empty wants.*"
testUlReqEncodeError(c, ur, expectedErrorRegEx)
}
func (s *UlReqEncodeSuite) TestOneWant(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
expected := []string{
"want 1111111111111111111111111111111111111111\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *UlReqEncodeSuite) TestOneWantWithCapabilities(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
ur.Capabilities.Add(capability.MultiACK)
ur.Capabilities.Add(capability.OFSDelta)
ur.Capabilities.Add(capability.Sideband)
ur.Capabilities.Add(capability.SymRef, "HEAD:/refs/heads/master")
ur.Capabilities.Add(capability.ThinPack)
expected := []string{
"want 1111111111111111111111111111111111111111 multi_ack ofs-delta side-band symref=HEAD:/refs/heads/master thin-pack\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *UlReqEncodeSuite) TestWants(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants,
plumbing.NewHash("4444444444444444444444444444444444444444"),
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
plumbing.NewHash("5555555555555555555555555555555555555555"),
)
expected := []string{
"want 1111111111111111111111111111111111111111\n",
"want 2222222222222222222222222222222222222222\n",
"want 3333333333333333333333333333333333333333\n",
"want 4444444444444444444444444444444444444444\n",
"want 5555555555555555555555555555555555555555\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *UlReqEncodeSuite) TestWantsDuplicates(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants,
plumbing.NewHash("4444444444444444444444444444444444444444"),
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
plumbing.NewHash("1111111111111111111111111111111111111111"),
)
expected := []string{
"want 1111111111111111111111111111111111111111\n",
"want 2222222222222222222222222222222222222222\n",
"want 3333333333333333333333333333333333333333\n",
"want 4444444444444444444444444444444444444444\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *UlReqEncodeSuite) TestWantsWithCapabilities(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants,
plumbing.NewHash("4444444444444444444444444444444444444444"),
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
plumbing.NewHash("5555555555555555555555555555555555555555"),
)
ur.Capabilities.Add(capability.MultiACK)
ur.Capabilities.Add(capability.OFSDelta)
ur.Capabilities.Add(capability.Sideband)
ur.Capabilities.Add(capability.SymRef, "HEAD:/refs/heads/master")
ur.Capabilities.Add(capability.ThinPack)
expected := []string{
"want 1111111111111111111111111111111111111111 multi_ack ofs-delta side-band symref=HEAD:/refs/heads/master thin-pack\n",
"want 2222222222222222222222222222222222222222\n",
"want 3333333333333333333333333333333333333333\n",
"want 4444444444444444444444444444444444444444\n",
"want 5555555555555555555555555555555555555555\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *UlReqEncodeSuite) TestShallow(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
ur.Capabilities.Add(capability.MultiACK)
ur.Shallows = append(ur.Shallows, plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
expected := []string{
"want 1111111111111111111111111111111111111111 multi_ack\n",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *UlReqEncodeSuite) TestManyShallows(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
ur.Capabilities.Add(capability.MultiACK)
ur.Shallows = append(ur.Shallows,
plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
plumbing.NewHash("dddddddddddddddddddddddddddddddddddddddd"),
plumbing.NewHash("cccccccccccccccccccccccccccccccccccccccc"),
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
)
expected := []string{
"want 1111111111111111111111111111111111111111 multi_ack\n",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n",
"shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n",
"shallow cccccccccccccccccccccccccccccccccccccccc\n",
"shallow dddddddddddddddddddddddddddddddddddddddd\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *UlReqEncodeSuite) TestShallowsDuplicate(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
ur.Capabilities.Add(capability.MultiACK)
ur.Shallows = append(ur.Shallows,
plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
plumbing.NewHash("cccccccccccccccccccccccccccccccccccccccc"),
plumbing.NewHash("cccccccccccccccccccccccccccccccccccccccc"),
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
)
expected := []string{
"want 1111111111111111111111111111111111111111 multi_ack\n",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n",
"shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n",
"shallow cccccccccccccccccccccccccccccccccccccccc\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *UlReqEncodeSuite) TestDepthCommits(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
ur.Depth = DepthCommits(1234)
expected := []string{
"want 1111111111111111111111111111111111111111\n",
"deepen 1234\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *UlReqEncodeSuite) TestDepthSinceUTC(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
since := time.Date(2015, time.January, 2, 3, 4, 5, 0, time.UTC)
ur.Depth = DepthSince(since)
expected := []string{
"want 1111111111111111111111111111111111111111\n",
"deepen-since 1420167845\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *UlReqEncodeSuite) TestDepthSinceNonUTC(c *C) {
if runtime.GOOS == "js" {
c.Skip("time.LoadLocation not supported in wasm")
}
ur := NewUploadRequest()
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
berlin, err := time.LoadLocation("Europe/Berlin")
c.Assert(err, IsNil)
since := time.Date(2015, time.January, 2, 3, 4, 5, 0, berlin)
// since value is 2015-01-02 03:04:05 +0100 UTC (Europe/Berlin) or
// 2015-01-02 02:04:05 +0000 UTC, which is 1420164245 Unix seconds.
ur.Depth = DepthSince(since)
expected := []string{
"want 1111111111111111111111111111111111111111\n",
"deepen-since 1420164245\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *UlReqEncodeSuite) TestDepthReference(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
ur.Depth = DepthReference("refs/heads/feature-foo")
expected := []string{
"want 1111111111111111111111111111111111111111\n",
"deepen-not refs/heads/feature-foo\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *UlReqEncodeSuite) TestFilter(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
ur.Filter = FilterTreeDepth(0)
expected := []string{
"want 1111111111111111111111111111111111111111\n",
"filter tree:0\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *UlReqEncodeSuite) TestAll(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants,
plumbing.NewHash("4444444444444444444444444444444444444444"),
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
plumbing.NewHash("5555555555555555555555555555555555555555"),
)
ur.Capabilities.Add(capability.MultiACK)
ur.Capabilities.Add(capability.OFSDelta)
ur.Capabilities.Add(capability.Sideband)
ur.Capabilities.Add(capability.SymRef, "HEAD:/refs/heads/master")
ur.Capabilities.Add(capability.ThinPack)
ur.Shallows = append(ur.Shallows, plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
ur.Shallows = append(ur.Shallows, plumbing.NewHash("dddddddddddddddddddddddddddddddddddddddd"))
ur.Shallows = append(ur.Shallows, plumbing.NewHash("cccccccccccccccccccccccccccccccccccccccc"))
ur.Shallows = append(ur.Shallows, plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
since := time.Date(2015, time.January, 2, 3, 4, 5, 0, time.UTC)
ur.Depth = DepthSince(since)
expected := []string{
"want 1111111111111111111111111111111111111111 multi_ack ofs-delta side-band symref=HEAD:/refs/heads/master thin-pack\n",
"want 2222222222222222222222222222222222222222\n",
"want 3333333333333333333333333333333333333333\n",
"want 4444444444444444444444444444444444444444\n",
"want 5555555555555555555555555555555555555555\n",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n",
"shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n",
"shallow cccccccccccccccccccccccccccccccccccccccc\n",
"shallow dddddddddddddddddddddddddddddddddddddddd\n",
"deepen-since 1420167845\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
go-git-5.13.2/plumbing/protocol/packp/ulreq_test.go 0000664 0000000 0000000 00000005666 14744245500 0022304 0 ustar 00root root 0000000 0000000 package packp
import (
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
. "gopkg.in/check.v1"
)
type UlReqSuite struct{}
var _ = Suite(&UlReqSuite{})
func (s *UlReqSuite) TestNewUploadRequestFromCapabilities(c *C) {
cap := capability.NewList()
cap.Set(capability.Sideband)
cap.Set(capability.Sideband64k)
cap.Set(capability.MultiACK)
cap.Set(capability.MultiACKDetailed)
cap.Set(capability.ThinPack)
cap.Set(capability.OFSDelta)
cap.Set(capability.Agent, "foo")
r := NewUploadRequestFromCapabilities(cap)
c.Assert(r.Capabilities.String(), Equals,
"multi_ack_detailed side-band-64k thin-pack ofs-delta agent=go-git/5.x",
)
}
func (s *UlReqSuite) TestValidateWants(c *C) {
r := NewUploadRequest()
err := r.Validate()
c.Assert(err, NotNil)
r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
err = r.Validate()
c.Assert(err, IsNil)
}
func (s *UlReqSuite) TestValidateShallows(c *C) {
r := NewUploadRequest()
r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
r.Shallows = append(r.Shallows, plumbing.NewHash("2222222222222222222222222222222222222222"))
err := r.Validate()
c.Assert(err, NotNil)
r.Capabilities.Set(capability.Shallow)
err = r.Validate()
c.Assert(err, IsNil)
}
func (s *UlReqSuite) TestValidateDepthCommits(c *C) {
r := NewUploadRequest()
r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
r.Depth = DepthCommits(42)
err := r.Validate()
c.Assert(err, NotNil)
r.Capabilities.Set(capability.Shallow)
err = r.Validate()
c.Assert(err, IsNil)
}
func (s *UlReqSuite) TestValidateDepthReference(c *C) {
r := NewUploadRequest()
r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
r.Depth = DepthReference("1111111111111111111111111111111111111111")
err := r.Validate()
c.Assert(err, NotNil)
r.Capabilities.Set(capability.DeepenNot)
err = r.Validate()
c.Assert(err, IsNil)
}
func (s *UlReqSuite) TestValidateDepthSince(c *C) {
r := NewUploadRequest()
r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
r.Depth = DepthSince(time.Now())
err := r.Validate()
c.Assert(err, NotNil)
r.Capabilities.Set(capability.DeepenSince)
err = r.Validate()
c.Assert(err, IsNil)
}
func (s *UlReqSuite) TestValidateConflictSideband(c *C) {
r := NewUploadRequest()
r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
r.Capabilities.Set(capability.Sideband)
r.Capabilities.Set(capability.Sideband64k)
err := r.Validate()
c.Assert(err, NotNil)
}
func (s *UlReqSuite) TestValidateConflictMultiACK(c *C) {
r := NewUploadRequest()
r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
r.Capabilities.Set(capability.MultiACK)
r.Capabilities.Set(capability.MultiACKDetailed)
err := r.Validate()
c.Assert(err, NotNil)
}
go-git-5.13.2/plumbing/protocol/packp/updreq.go 0000664 0000000 0000000 00000005441 14744245500 0021404 0 ustar 00root root 0000000 0000000 package packp
import (
"errors"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband"
)
var (
ErrEmptyCommands = errors.New("commands cannot be empty")
ErrMalformedCommand = errors.New("malformed command")
)
// ReferenceUpdateRequest values represent reference upload requests.
// Values from this type are not zero-value safe, use the New function instead.
type ReferenceUpdateRequest struct {
Capabilities *capability.List
Commands []*Command
Options []*Option
Shallow *plumbing.Hash
// Packfile contains an optional packfile reader.
Packfile io.ReadCloser
// Progress receives sideband progress messages from the server
Progress sideband.Progress
}
// New returns a pointer to a new ReferenceUpdateRequest value.
func NewReferenceUpdateRequest() *ReferenceUpdateRequest {
return &ReferenceUpdateRequest{
// TODO: Add support for push-cert
Capabilities: capability.NewList(),
Commands: nil,
}
}
// NewReferenceUpdateRequestFromCapabilities returns a pointer to a new
// ReferenceUpdateRequest value, the request capabilities are filled with the
// most optimal ones, based on the adv value (advertised capabilities), the
// ReferenceUpdateRequest contains no commands
//
// It does set the following capabilities:
// - agent
// - report-status
// - ofs-delta
// - ref-delta
// - delete-refs
// It leaves up to the user to add the following capabilities later:
// - atomic
// - ofs-delta
// - side-band
// - side-band-64k
// - quiet
// - push-cert
func NewReferenceUpdateRequestFromCapabilities(adv *capability.List) *ReferenceUpdateRequest {
r := NewReferenceUpdateRequest()
if adv.Supports(capability.Agent) {
r.Capabilities.Set(capability.Agent, capability.DefaultAgent())
}
if adv.Supports(capability.ReportStatus) {
r.Capabilities.Set(capability.ReportStatus)
}
return r
}
func (req *ReferenceUpdateRequest) validate() error {
if len(req.Commands) == 0 {
return ErrEmptyCommands
}
for _, c := range req.Commands {
if err := c.validate(); err != nil {
return err
}
}
return nil
}
type Action string
const (
Create Action = "create"
Update Action = "update"
Delete Action = "delete"
Invalid Action = "invalid"
)
type Command struct {
Name plumbing.ReferenceName
Old plumbing.Hash
New plumbing.Hash
}
func (c *Command) Action() Action {
if c.Old == plumbing.ZeroHash && c.New == plumbing.ZeroHash {
return Invalid
}
if c.Old == plumbing.ZeroHash {
return Create
}
if c.New == plumbing.ZeroHash {
return Delete
}
return Update
}
func (c *Command) validate() error {
if c.Action() == Invalid {
return ErrMalformedCommand
}
return nil
}
type Option struct {
Key string
Value string
}
go-git-5.13.2/plumbing/protocol/packp/updreq_decode.go 0000664 0000000 0000000 00000012023 14744245500 0022701 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"encoding/hex"
"errors"
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
)
var (
shallowLineLength = len(shallow) + hashSize
minCommandLength = hashSize*2 + 2 + 1
minCommandAndCapsLength = minCommandLength + 1
)
var (
ErrEmpty = errors.New("empty update-request message")
errNoCommands = errors.New("unexpected EOF before any command")
errMissingCapabilitiesDelimiter = errors.New("capabilities delimiter not found")
)
func errMalformedRequest(reason string) error {
return fmt.Errorf("malformed request: %s", reason)
}
func errInvalidHashSize(got int) error {
return fmt.Errorf("invalid hash size: expected %d, got %d",
hashSize, got)
}
func errInvalidHash(err error) error {
return fmt.Errorf("invalid hash: %s", err.Error())
}
func errInvalidShallowLineLength(got int) error {
return errMalformedRequest(fmt.Sprintf(
"invalid shallow line length: expected %d, got %d",
shallowLineLength, got))
}
func errInvalidCommandCapabilitiesLineLength(got int) error {
return errMalformedRequest(fmt.Sprintf(
"invalid command and capabilities line length: expected at least %d, got %d",
minCommandAndCapsLength, got))
}
func errInvalidCommandLineLength(got int) error {
return errMalformedRequest(fmt.Sprintf(
"invalid command line length: expected at least %d, got %d",
minCommandLength, got))
}
func errInvalidShallowObjId(err error) error {
return errMalformedRequest(
fmt.Sprintf("invalid shallow object id: %s", err.Error()))
}
func errInvalidOldObjId(err error) error {
return errMalformedRequest(
fmt.Sprintf("invalid old object id: %s", err.Error()))
}
func errInvalidNewObjId(err error) error {
return errMalformedRequest(
fmt.Sprintf("invalid new object id: %s", err.Error()))
}
func errMalformedCommand(err error) error {
return errMalformedRequest(fmt.Sprintf(
"malformed command: %s", err.Error()))
}
// Decode reads the next update-request message form the reader and wr
func (req *ReferenceUpdateRequest) Decode(r io.Reader) error {
var rc io.ReadCloser
var ok bool
rc, ok = r.(io.ReadCloser)
if !ok {
rc = io.NopCloser(r)
}
d := &updReqDecoder{r: rc, s: pktline.NewScanner(r)}
return d.Decode(req)
}
type updReqDecoder struct {
r io.ReadCloser
s *pktline.Scanner
req *ReferenceUpdateRequest
}
func (d *updReqDecoder) Decode(req *ReferenceUpdateRequest) error {
d.req = req
funcs := []func() error{
d.scanLine,
d.decodeShallow,
d.decodeCommandAndCapabilities,
d.decodeCommands,
d.setPackfile,
req.validate,
}
for _, f := range funcs {
if err := f(); err != nil {
return err
}
}
return nil
}
func (d *updReqDecoder) scanLine() error {
if ok := d.s.Scan(); !ok {
return d.scanErrorOr(ErrEmpty)
}
return nil
}
func (d *updReqDecoder) decodeShallow() error {
b := d.s.Bytes()
if !bytes.HasPrefix(b, shallowNoSp) {
return nil
}
if len(b) != shallowLineLength {
return errInvalidShallowLineLength(len(b))
}
h, err := parseHash(string(b[len(shallow):]))
if err != nil {
return errInvalidShallowObjId(err)
}
if ok := d.s.Scan(); !ok {
return d.scanErrorOr(errNoCommands)
}
d.req.Shallow = &h
return nil
}
func (d *updReqDecoder) decodeCommands() error {
for {
b := d.s.Bytes()
if bytes.Equal(b, pktline.Flush) {
return nil
}
c, err := parseCommand(b)
if err != nil {
return err
}
d.req.Commands = append(d.req.Commands, c)
if ok := d.s.Scan(); !ok {
return d.s.Err()
}
}
}
func (d *updReqDecoder) decodeCommandAndCapabilities() error {
b := d.s.Bytes()
i := bytes.IndexByte(b, 0)
if i == -1 {
return errMissingCapabilitiesDelimiter
}
if len(b) < minCommandAndCapsLength {
return errInvalidCommandCapabilitiesLineLength(len(b))
}
cmd, err := parseCommand(b[:i])
if err != nil {
return err
}
d.req.Commands = append(d.req.Commands, cmd)
if err := d.req.Capabilities.Decode(b[i+1:]); err != nil {
return err
}
if err := d.scanLine(); err != nil {
return err
}
return nil
}
func (d *updReqDecoder) setPackfile() error {
d.req.Packfile = d.r
return nil
}
func parseCommand(b []byte) (*Command, error) {
if len(b) < minCommandLength {
return nil, errInvalidCommandLineLength(len(b))
}
var (
os, ns string
n plumbing.ReferenceName
)
if _, err := fmt.Sscanf(string(b), "%s %s %s", &os, &ns, &n); err != nil {
return nil, errMalformedCommand(err)
}
oh, err := parseHash(os)
if err != nil {
return nil, errInvalidOldObjId(err)
}
nh, err := parseHash(ns)
if err != nil {
return nil, errInvalidNewObjId(err)
}
return &Command{Old: oh, New: nh, Name: n}, nil
}
func parseHash(s string) (plumbing.Hash, error) {
if len(s) != hashSize {
return plumbing.ZeroHash, errInvalidHashSize(len(s))
}
if _, err := hex.DecodeString(s); err != nil {
return plumbing.ZeroHash, errInvalidHash(err)
}
h := plumbing.NewHash(s)
return h, nil
}
func (d *updReqDecoder) scanErrorOr(origErr error) error {
if err := d.s.Err(); err != nil {
return err
}
return origErr
}
go-git-5.13.2/plumbing/protocol/packp/updreq_decode_test.go 0000664 0000000 0000000 00000027243 14744245500 0023752 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
. "gopkg.in/check.v1"
)
type UpdReqDecodeSuite struct{}
var _ = Suite(&UpdReqDecodeSuite{})
func (s *UpdReqDecodeSuite) TestEmpty(c *C) {
r := NewReferenceUpdateRequest()
var buf bytes.Buffer
c.Assert(r.Decode(&buf), Equals, ErrEmpty)
c.Assert(r, DeepEquals, NewReferenceUpdateRequest())
}
func (s *UpdReqDecodeSuite) TestInvalidPktlines(c *C) {
r := NewReferenceUpdateRequest()
input := bytes.NewReader([]byte("xxxxxxxxxx"))
c.Assert(r.Decode(input), ErrorMatches, "invalid pkt-len found")
}
func (s *UpdReqDecodeSuite) TestInvalidShadow(c *C) {
payloads := []string{
"shallow",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid shallow line length: expected 48, got 7$")
payloads = []string{
"shallow ",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid shallow line length: expected 48, got 8$")
payloads = []string{
"shallow 1ecf0ef2c2dffb796033e5a02219af86ec65",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid shallow line length: expected 48, got 44$")
payloads = []string{
"shallow 1ecf0ef2c2dffb796033e5a02219af86ec6584e54",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid shallow line length: expected 48, got 49$")
payloads = []string{
"shallow 1ecf0ef2c2dffb796033e5a02219af86ec6584eu",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid shallow object id: invalid hash: .*")
}
func (s *UpdReqDecodeSuite) TestMalformedCommand(c *C) {
payloads := []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5x2ecf0ef2c2dffb796033e5a02219af86ec6584e5xmyref\x00",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: malformed command: EOF$")
payloads = []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5x2ecf0ef2c2dffb796033e5a02219af86ec6584e5xmyref",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: malformed command: EOF$")
}
func (s *UpdReqDecodeSuite) TestInvalidCommandInvalidHash(c *C) {
payloads := []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid old object id: invalid hash size: expected 40, got 39$")
payloads = []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e myref\x00",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid new object id: invalid hash size: expected 40, got 39$")
payloads = []string{
"1ecf0ef2c2dffb796033e5a02219af86e 2ecf0ef2c2dffb796033e5a02219af86ec6 m\x00",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid command and capabilities line length: expected at least 84, got 72$")
payloads = []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584eu 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid old object id: invalid hash: .*$")
payloads = []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584eu myref\x00",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid new object id: invalid hash: .*$")
}
func (s *UpdReqDecodeSuite) TestInvalidCommandMissingNullDelimiter(c *C) {
payloads := []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "capabilities delimiter not found")
}
func (s *UpdReqDecodeSuite) TestInvalidCommandMissingName(c *C) {
payloads := []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5\x00",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid command and capabilities line length: expected at least 84, got 82$")
payloads = []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 \x00",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid command and capabilities line length: expected at least 84, got 83$")
payloads = []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid command line length: expected at least 83, got 81$")
payloads = []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 ",
pktline.FlushString,
}
s.testDecoderErrorMatches(c, toPktLines(c, payloads), "^malformed request: invalid command line length: expected at least 83, got 82$")
}
func (s *UpdReqDecodeSuite) TestOneUpdateCommand(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
name := plumbing.ReferenceName("myref")
expected := NewReferenceUpdateRequest()
expected.Commands = []*Command{
{Name: name, Old: hash1, New: hash2},
}
expected.Packfile = io.NopCloser(bytes.NewReader([]byte{}))
payloads := []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
}
s.testDecodeOkExpected(c, expected, payloads)
}
func (s *UpdReqDecodeSuite) TestMultipleCommands(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
expected := NewReferenceUpdateRequest()
expected.Commands = []*Command{
{Name: plumbing.ReferenceName("myref1"), Old: hash1, New: hash2},
{Name: plumbing.ReferenceName("myref2"), Old: plumbing.ZeroHash, New: hash2},
{Name: plumbing.ReferenceName("myref3"), Old: hash1, New: plumbing.ZeroHash},
}
expected.Packfile = io.NopCloser(bytes.NewReader([]byte{}))
payloads := []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00",
"0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3",
pktline.FlushString,
}
s.testDecodeOkExpected(c, expected, payloads)
}
func (s *UpdReqDecodeSuite) TestMultipleCommandsAndCapabilities(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
expected := NewReferenceUpdateRequest()
expected.Commands = []*Command{
{Name: plumbing.ReferenceName("myref1"), Old: hash1, New: hash2},
{Name: plumbing.ReferenceName("myref2"), Old: plumbing.ZeroHash, New: hash2},
{Name: plumbing.ReferenceName("myref3"), Old: hash1, New: plumbing.ZeroHash},
}
expected.Capabilities.Add("shallow")
expected.Packfile = io.NopCloser(bytes.NewReader([]byte{}))
payloads := []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00shallow",
"0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3",
pktline.FlushString,
}
s.testDecodeOkExpected(c, expected, payloads)
}
func (s *UpdReqDecodeSuite) TestMultipleCommandsAndCapabilitiesShallow(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
expected := NewReferenceUpdateRequest()
expected.Commands = []*Command{
{Name: plumbing.ReferenceName("myref1"), Old: hash1, New: hash2},
{Name: plumbing.ReferenceName("myref2"), Old: plumbing.ZeroHash, New: hash2},
{Name: plumbing.ReferenceName("myref3"), Old: hash1, New: plumbing.ZeroHash},
}
expected.Capabilities.Add("shallow")
expected.Shallow = &hash1
expected.Packfile = io.NopCloser(bytes.NewReader([]byte{}))
payloads := []string{
"shallow 1ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00shallow",
"0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3",
pktline.FlushString,
}
s.testDecodeOkExpected(c, expected, payloads)
}
func (s *UpdReqDecodeSuite) TestWithPackfile(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
name := plumbing.ReferenceName("myref")
expected := NewReferenceUpdateRequest()
expected.Commands = []*Command{
{Name: name, Old: hash1, New: hash2},
}
packfileContent := []byte("PACKabc")
expected.Packfile = io.NopCloser(bytes.NewReader(packfileContent))
payloads := []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
}
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
c.Assert(e.EncodeString(payloads...), IsNil)
buf.Write(packfileContent)
s.testDecodeOkRaw(c, expected, buf.Bytes())
}
func (s *UpdReqDecodeSuite) testDecoderErrorMatches(c *C, input io.Reader, pattern string) {
r := NewReferenceUpdateRequest()
c.Assert(r.Decode(input), ErrorMatches, pattern)
}
func (s *UpdReqDecodeSuite) testDecodeOK(c *C, payloads []string) *ReferenceUpdateRequest {
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
err := e.EncodeString(payloads...)
c.Assert(err, IsNil)
r := NewReferenceUpdateRequest()
c.Assert(r.Decode(&buf), IsNil)
return r
}
func (s *UpdReqDecodeSuite) testDecodeOkRaw(c *C, expected *ReferenceUpdateRequest, raw []byte) {
req := NewReferenceUpdateRequest()
c.Assert(req.Decode(bytes.NewBuffer(raw)), IsNil)
c.Assert(req.Packfile, NotNil)
s.compareReaders(c, req.Packfile, expected.Packfile)
req.Packfile = nil
expected.Packfile = nil
c.Assert(req, DeepEquals, expected)
}
func (s *UpdReqDecodeSuite) testDecodeOkExpected(c *C, expected *ReferenceUpdateRequest, payloads []string) {
req := s.testDecodeOK(c, payloads)
c.Assert(req.Packfile, NotNil)
s.compareReaders(c, req.Packfile, expected.Packfile)
req.Packfile = nil
expected.Packfile = nil
c.Assert(req, DeepEquals, expected)
}
func (s *UpdReqDecodeSuite) compareReaders(c *C, a io.ReadCloser, b io.ReadCloser) {
pba, err := io.ReadAll(a)
c.Assert(err, IsNil)
c.Assert(a.Close(), IsNil)
pbb, err := io.ReadAll(b)
c.Assert(err, IsNil)
c.Assert(b.Close(), IsNil)
c.Assert(pba, DeepEquals, pbb)
}
go-git-5.13.2/plumbing/protocol/packp/updreq_encode.go 0000664 0000000 0000000 00000003413 14744245500 0022716 0 ustar 00root root 0000000 0000000 package packp
import (
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
)
// Encode writes the ReferenceUpdateRequest encoding to the stream.
func (req *ReferenceUpdateRequest) Encode(w io.Writer) error {
if err := req.validate(); err != nil {
return err
}
e := pktline.NewEncoder(w)
if err := req.encodeShallow(e, req.Shallow); err != nil {
return err
}
if err := req.encodeCommands(e, req.Commands, req.Capabilities); err != nil {
return err
}
if req.Capabilities.Supports(capability.PushOptions) {
if err := req.encodeOptions(e, req.Options); err != nil {
return err
}
}
if req.Packfile != nil {
if _, err := io.Copy(w, req.Packfile); err != nil {
return err
}
return req.Packfile.Close()
}
return nil
}
func (req *ReferenceUpdateRequest) encodeShallow(e *pktline.Encoder,
h *plumbing.Hash) error {
if h == nil {
return nil
}
objId := []byte(h.String())
return e.Encodef("%s%s", shallow, objId)
}
func (req *ReferenceUpdateRequest) encodeCommands(e *pktline.Encoder,
cmds []*Command, cap *capability.List) error {
if err := e.Encodef("%s\x00%s",
formatCommand(cmds[0]), cap.String()); err != nil {
return err
}
for _, cmd := range cmds[1:] {
if err := e.Encodef(formatCommand(cmd)); err != nil {
return err
}
}
return e.Flush()
}
func formatCommand(cmd *Command) string {
o := cmd.Old.String()
n := cmd.New.String()
return fmt.Sprintf("%s %s %s", o, n, cmd.Name)
}
func (req *ReferenceUpdateRequest) encodeOptions(e *pktline.Encoder,
opts []*Option) error {
for _, opt := range opts {
if err := e.Encodef("%s=%s", opt.Key, opt.Value); err != nil {
return err
}
}
return e.Flush()
}
go-git-5.13.2/plumbing/protocol/packp/updreq_encode_test.go 0000664 0000000 0000000 00000014156 14744245500 0023763 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
. "gopkg.in/check.v1"
)
type UpdReqEncodeSuite struct{}
var _ = Suite(&UpdReqEncodeSuite{})
func (s *UpdReqEncodeSuite) testEncode(c *C, input *ReferenceUpdateRequest,
expected []byte) {
var buf bytes.Buffer
c.Assert(input.Encode(&buf), IsNil)
obtained := buf.Bytes()
comment := Commentf("\nobtained = %s\nexpected = %s\n", string(obtained), string(expected))
c.Assert(obtained, DeepEquals, expected, comment)
}
func (s *UpdReqEncodeSuite) TestZeroValue(c *C) {
r := &ReferenceUpdateRequest{}
var buf bytes.Buffer
c.Assert(r.Encode(&buf), Equals, ErrEmptyCommands)
r = NewReferenceUpdateRequest()
c.Assert(r.Encode(&buf), Equals, ErrEmptyCommands)
}
func (s *UpdReqEncodeSuite) TestOneUpdateCommand(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
name := plumbing.ReferenceName("myref")
r := NewReferenceUpdateRequest()
r.Commands = []*Command{
{Name: name, Old: hash1, New: hash2},
}
expected := pktlines(c,
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
)
s.testEncode(c, r, expected)
}
func (s *UpdReqEncodeSuite) TestMultipleCommands(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
r := NewReferenceUpdateRequest()
r.Commands = []*Command{
{Name: plumbing.ReferenceName("myref1"), Old: hash1, New: hash2},
{Name: plumbing.ReferenceName("myref2"), Old: plumbing.ZeroHash, New: hash2},
{Name: plumbing.ReferenceName("myref3"), Old: hash1, New: plumbing.ZeroHash},
}
expected := pktlines(c,
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00",
"0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3",
pktline.FlushString,
)
s.testEncode(c, r, expected)
}
func (s *UpdReqEncodeSuite) TestMultipleCommandsAndCapabilities(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
r := NewReferenceUpdateRequest()
r.Commands = []*Command{
{Name: plumbing.ReferenceName("myref1"), Old: hash1, New: hash2},
{Name: plumbing.ReferenceName("myref2"), Old: plumbing.ZeroHash, New: hash2},
{Name: plumbing.ReferenceName("myref3"), Old: hash1, New: plumbing.ZeroHash},
}
r.Capabilities.Add("shallow")
expected := pktlines(c,
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00shallow",
"0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3",
pktline.FlushString,
)
s.testEncode(c, r, expected)
}
func (s *UpdReqEncodeSuite) TestMultipleCommandsAndCapabilitiesShallow(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
r := NewReferenceUpdateRequest()
r.Commands = []*Command{
{Name: plumbing.ReferenceName("myref1"), Old: hash1, New: hash2},
{Name: plumbing.ReferenceName("myref2"), Old: plumbing.ZeroHash, New: hash2},
{Name: plumbing.ReferenceName("myref3"), Old: hash1, New: plumbing.ZeroHash},
}
r.Capabilities.Add("shallow")
r.Shallow = &hash1
expected := pktlines(c,
"shallow 1ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00shallow",
"0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3",
pktline.FlushString,
)
s.testEncode(c, r, expected)
}
func (s *UpdReqEncodeSuite) TestWithPackfile(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
name := plumbing.ReferenceName("myref")
packfileContent := []byte("PACKabc")
packfileReader := bytes.NewReader(packfileContent)
packfileReadCloser := io.NopCloser(packfileReader)
r := NewReferenceUpdateRequest()
r.Commands = []*Command{
{Name: name, Old: hash1, New: hash2},
}
r.Packfile = packfileReadCloser
expected := pktlines(c,
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
)
expected = append(expected, packfileContent...)
s.testEncode(c, r, expected)
}
func (s *UpdReqEncodeSuite) TestPushOptions(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
name := plumbing.ReferenceName("myref")
r := NewReferenceUpdateRequest()
r.Capabilities.Set(capability.PushOptions)
r.Commands = []*Command{
{Name: name, Old: hash1, New: hash2},
}
r.Options = []*Option{
{Key: "SomeKey", Value: "SomeValue"},
{Key: "AnotherKey", Value: "AnotherValue"},
}
expected := pktlines(c,
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00push-options",
pktline.FlushString,
"SomeKey=SomeValue",
"AnotherKey=AnotherValue",
pktline.FlushString,
)
s.testEncode(c, r, expected)
}
func (s *UpdReqEncodeSuite) TestPushAtomic(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
name := plumbing.ReferenceName("myref")
r := NewReferenceUpdateRequest()
r.Capabilities.Set(capability.Atomic)
r.Commands = []*Command{
{Name: name, Old: hash1, New: hash2},
}
expected := pktlines(c,
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00atomic",
pktline.FlushString,
)
s.testEncode(c, r, expected)
}
go-git-5.13.2/plumbing/protocol/packp/updreq_test.go 0000664 0000000 0000000 00000001725 14744245500 0022444 0 ustar 00root root 0000000 0000000 package packp
import (
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
. "gopkg.in/check.v1"
)
type UpdReqSuite struct{}
var _ = Suite(&UpdReqSuite{})
func (s *UpdReqSuite) TestNewReferenceUpdateRequestFromCapabilities(c *C) {
cap := capability.NewList()
cap.Set(capability.Sideband)
cap.Set(capability.Sideband64k)
cap.Set(capability.Quiet)
cap.Set(capability.ReportStatus)
cap.Set(capability.DeleteRefs)
cap.Set(capability.PushCert, "foo")
cap.Set(capability.Atomic)
cap.Set(capability.Agent, "foo")
r := NewReferenceUpdateRequestFromCapabilities(cap)
c.Assert(r.Capabilities.String(), Equals,
"agent=go-git/5.x report-status",
)
cap = capability.NewList()
cap.Set(capability.Agent, "foo")
r = NewReferenceUpdateRequestFromCapabilities(cap)
c.Assert(r.Capabilities.String(), Equals, "agent=go-git/5.x")
cap = capability.NewList()
r = NewReferenceUpdateRequestFromCapabilities(cap)
c.Assert(r.Capabilities.String(), Equals, "")
}
go-git-5.13.2/plumbing/protocol/packp/uppackreq.go 0000664 0000000 0000000 00000004753 14744245500 0022104 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
)
// UploadPackRequest represents a upload-pack request.
// Zero-value is not safe, use NewUploadPackRequest instead.
type UploadPackRequest struct {
UploadRequest
UploadHaves
}
// NewUploadPackRequest creates a new UploadPackRequest and returns a pointer.
func NewUploadPackRequest() *UploadPackRequest {
ur := NewUploadRequest()
return &UploadPackRequest{
UploadHaves: UploadHaves{},
UploadRequest: *ur,
}
}
// NewUploadPackRequestFromCapabilities creates a new UploadPackRequest and
// returns a pointer. The request capabilities are filled with the most optimal
// ones, based on the adv value (advertised capabilities), the UploadPackRequest
// it has no wants, haves or shallows and an infinite depth
func NewUploadPackRequestFromCapabilities(adv *capability.List) *UploadPackRequest {
ur := NewUploadRequestFromCapabilities(adv)
return &UploadPackRequest{
UploadHaves: UploadHaves{},
UploadRequest: *ur,
}
}
// IsEmpty returns whether a request is empty - it is empty if Haves are contained
// in the Wants, or if Wants length is zero, and we don't have any shallows
func (r *UploadPackRequest) IsEmpty() bool {
return isSubset(r.Wants, r.Haves) && len(r.Shallows) == 0
}
func isSubset(needle []plumbing.Hash, haystack []plumbing.Hash) bool {
for _, h := range needle {
found := false
for _, oh := range haystack {
if h == oh {
found = true
break
}
}
if !found {
return false
}
}
return true
}
// UploadHaves is a message to signal the references that a client has in a
// upload-pack. Do not use this directly. Use UploadPackRequest request instead.
type UploadHaves struct {
Haves []plumbing.Hash
}
// Encode encodes the UploadHaves into the Writer. If flush is true, a flush
// command will be encoded at the end of the writer content.
func (u *UploadHaves) Encode(w io.Writer, flush bool) error {
e := pktline.NewEncoder(w)
plumbing.HashesSort(u.Haves)
var last plumbing.Hash
for _, have := range u.Haves {
if bytes.Equal(last[:], have[:]) {
continue
}
if err := e.Encodef("have %s\n", have); err != nil {
return fmt.Errorf("sending haves for %q: %s", have, err)
}
last = have
}
if flush && len(u.Haves) != 0 {
if err := e.Flush(); err != nil {
return fmt.Errorf("sending flush-pkt after haves: %s", err)
}
}
return nil
}
go-git-5.13.2/plumbing/protocol/packp/uppackreq_test.go 0000664 0000000 0000000 00000005062 14744245500 0023135 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
. "gopkg.in/check.v1"
)
type UploadPackRequestSuite struct{}
var _ = Suite(&UploadPackRequestSuite{})
func (s *UploadPackRequestSuite) TestNewUploadPackRequestFromCapabilities(c *C) {
cap := capability.NewList()
cap.Set(capability.Agent, "foo")
r := NewUploadPackRequestFromCapabilities(cap)
c.Assert(r.Capabilities.String(), Equals, "agent=go-git/5.x")
}
func (s *UploadPackRequestSuite) TestIsEmpty(c *C) {
r := NewUploadPackRequest()
r.Wants = append(r.Wants, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c"))
r.Wants = append(r.Wants, plumbing.NewHash("2b41ef280fdb67a9b250678686a0c3e03b0a9989"))
r.Haves = append(r.Haves, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
c.Assert(r.IsEmpty(), Equals, false)
r = NewUploadPackRequest()
r.Wants = append(r.Wants, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c"))
r.Wants = append(r.Wants, plumbing.NewHash("2b41ef280fdb67a9b250678686a0c3e03b0a9989"))
r.Haves = append(r.Haves, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c"))
c.Assert(r.IsEmpty(), Equals, false)
r = NewUploadPackRequest()
r.Wants = append(r.Wants, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c"))
r.Haves = append(r.Haves, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c"))
c.Assert(r.IsEmpty(), Equals, true)
r = NewUploadPackRequest()
r.Wants = append(r.Wants, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c"))
r.Haves = append(r.Haves, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c"))
r.Shallows = append(r.Shallows, plumbing.NewHash("2b41ef280fdb67a9b250678686a0c3e03b0a9989"))
c.Assert(r.IsEmpty(), Equals, false)
}
type UploadHavesSuite struct{}
var _ = Suite(&UploadHavesSuite{})
func (s *UploadHavesSuite) TestEncode(c *C) {
uh := &UploadHaves{}
uh.Haves = append(uh.Haves,
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
plumbing.NewHash("1111111111111111111111111111111111111111"),
)
buf := bytes.NewBuffer(nil)
err := uh.Encode(buf, true)
c.Assert(err, IsNil)
c.Assert(buf.String(), Equals, ""+
"0032have 1111111111111111111111111111111111111111\n"+
"0032have 2222222222222222222222222222222222222222\n"+
"0032have 3333333333333333333333333333333333333333\n"+
"0000",
)
}
go-git-5.13.2/plumbing/protocol/packp/uppackresp.go 0000664 0000000 0000000 00000005326 14744245500 0022263 0 ustar 00root root 0000000 0000000 package packp
import (
"errors"
"io"
"bufio"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
"github.com/go-git/go-git/v5/utils/ioutil"
)
// ErrUploadPackResponseNotDecoded is returned if Read is called without
// decoding first
var ErrUploadPackResponseNotDecoded = errors.New("upload-pack-response should be decoded")
// UploadPackResponse contains all the information responded by the upload-pack
// service, the response implements io.ReadCloser that allows to read the
// packfile directly from it.
type UploadPackResponse struct {
ShallowUpdate
ServerResponse
r io.ReadCloser
isShallow bool
isMultiACK bool
}
// NewUploadPackResponse create a new UploadPackResponse instance, the request
// being responded by the response is required.
func NewUploadPackResponse(req *UploadPackRequest) *UploadPackResponse {
isShallow := !req.Depth.IsZero()
isMultiACK := req.Capabilities.Supports(capability.MultiACK) ||
req.Capabilities.Supports(capability.MultiACKDetailed)
return &UploadPackResponse{
isShallow: isShallow,
isMultiACK: isMultiACK,
}
}
// NewUploadPackResponseWithPackfile creates a new UploadPackResponse instance,
// and sets its packfile reader.
func NewUploadPackResponseWithPackfile(req *UploadPackRequest,
pf io.ReadCloser) *UploadPackResponse {
r := NewUploadPackResponse(req)
r.r = pf
return r
}
// Decode decodes all the responses sent by upload-pack service into the struct
// and prepares it to read the packfile using the Read method
func (r *UploadPackResponse) Decode(reader io.ReadCloser) error {
buf := bufio.NewReader(reader)
if r.isShallow {
if err := r.ShallowUpdate.Decode(buf); err != nil {
return err
}
}
if err := r.ServerResponse.Decode(buf, r.isMultiACK); err != nil {
return err
}
// now the reader is ready to read the packfile content
r.r = ioutil.NewReadCloser(buf, reader)
return nil
}
// Encode encodes an UploadPackResponse.
func (r *UploadPackResponse) Encode(w io.Writer) (err error) {
if r.isShallow {
if err := r.ShallowUpdate.Encode(w); err != nil {
return err
}
}
if err := r.ServerResponse.Encode(w, r.isMultiACK); err != nil {
return err
}
defer ioutil.CheckClose(r.r, &err)
_, err = io.Copy(w, r.r)
return err
}
// Read reads the packfile data, if the request was done with any Sideband
// capability the content read should be demultiplexed. If the methods wasn't
// called before the ErrUploadPackResponseNotDecoded will be return
func (r *UploadPackResponse) Read(p []byte) (int, error) {
if r.r == nil {
return 0, ErrUploadPackResponseNotDecoded
}
return r.r.Read(p)
}
// Close the underlying reader, if any
func (r *UploadPackResponse) Close() error {
if r.r == nil {
return nil
}
return r.r.Close()
}
go-git-5.13.2/plumbing/protocol/packp/uppackresp_test.go 0000664 0000000 0000000 00000007143 14744245500 0023321 0 ustar 00root root 0000000 0000000 package packp
import (
"bytes"
"io"
"testing"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
. "gopkg.in/check.v1"
)
type UploadPackResponseSuite struct{}
var _ = Suite(&UploadPackResponseSuite{})
func (s *UploadPackResponseSuite) TestDecodeNAK(c *C) {
raw := "0008NAK\nPACK"
req := NewUploadPackRequest()
res := NewUploadPackResponse(req)
defer res.Close()
err := res.Decode(io.NopCloser(bytes.NewBufferString(raw)))
c.Assert(err, IsNil)
pack, err := io.ReadAll(res)
c.Assert(err, IsNil)
c.Assert(pack, DeepEquals, []byte("PACK"))
}
func (s *UploadPackResponseSuite) TestDecodeDepth(c *C) {
raw := "00000008NAK\nPACK"
req := NewUploadPackRequest()
req.Depth = DepthCommits(1)
res := NewUploadPackResponse(req)
defer res.Close()
err := res.Decode(io.NopCloser(bytes.NewBufferString(raw)))
c.Assert(err, IsNil)
pack, err := io.ReadAll(res)
c.Assert(err, IsNil)
c.Assert(pack, DeepEquals, []byte("PACK"))
}
func (s *UploadPackResponseSuite) TestDecodeMalformed(c *C) {
raw := "00000008ACK\nPACK"
req := NewUploadPackRequest()
req.Depth = DepthCommits(1)
res := NewUploadPackResponse(req)
defer res.Close()
err := res.Decode(io.NopCloser(bytes.NewBufferString(raw)))
c.Assert(err, NotNil)
}
// multi_ack isn't fully implemented, this ensures that Decode ignores that fact,
// as in some circumstances that's OK to assume so.
//
// TODO: Review as part of multi_ack implementation.
func (s *UploadPackResponseSuite) TestDecodeMultiACK(c *C) {
req := NewUploadPackRequest()
req.Capabilities.Set(capability.MultiACK)
res := NewUploadPackResponse(req)
defer res.Close()
err := res.Decode(io.NopCloser(bytes.NewBuffer(nil)))
c.Assert(err, IsNil)
}
func (s *UploadPackResponseSuite) TestReadNoDecode(c *C) {
req := NewUploadPackRequest()
req.Capabilities.Set(capability.MultiACK)
res := NewUploadPackResponse(req)
defer res.Close()
n, err := res.Read(nil)
c.Assert(err, Equals, ErrUploadPackResponseNotDecoded)
c.Assert(n, Equals, 0)
}
func (s *UploadPackResponseSuite) TestEncodeNAK(c *C) {
pf := io.NopCloser(bytes.NewBuffer([]byte("[PACK]")))
req := NewUploadPackRequest()
res := NewUploadPackResponseWithPackfile(req, pf)
defer func() { c.Assert(res.Close(), IsNil) }()
b := bytes.NewBuffer(nil)
c.Assert(res.Encode(b), IsNil)
expected := "0008NAK\n[PACK]"
c.Assert(b.String(), Equals, expected)
}
func (s *UploadPackResponseSuite) TestEncodeDepth(c *C) {
pf := io.NopCloser(bytes.NewBuffer([]byte("PACK")))
req := NewUploadPackRequest()
req.Depth = DepthCommits(1)
res := NewUploadPackResponseWithPackfile(req, pf)
defer func() { c.Assert(res.Close(), IsNil) }()
b := bytes.NewBuffer(nil)
c.Assert(res.Encode(b), IsNil)
expected := "00000008NAK\nPACK"
c.Assert(b.String(), Equals, expected)
}
func (s *UploadPackResponseSuite) TestEncodeMultiACK(c *C) {
pf := io.NopCloser(bytes.NewBuffer([]byte("[PACK]")))
req := NewUploadPackRequest()
res := NewUploadPackResponseWithPackfile(req, pf)
defer func() { c.Assert(res.Close(), IsNil) }()
res.ACKs = []plumbing.Hash{
plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f81"),
plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f82"),
}
b := bytes.NewBuffer(nil)
c.Assert(res.Encode(b), NotNil)
}
func FuzzDecoder(f *testing.F) {
f.Add([]byte("0045ACK 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f81\n"))
f.Add([]byte("003aACK5dc01c595e6c6ec9ccda4f6f69c131c0dd945f82 \n0008NAK\n0"))
f.Fuzz(func(t *testing.T, input []byte) {
req := NewUploadPackRequest()
res := NewUploadPackResponse(req)
defer res.Close()
res.Decode(io.NopCloser(bytes.NewReader(input)))
})
}
go-git-5.13.2/plumbing/reference.go 0000664 0000000 0000000 00000020146 14744245500 0017102 0 ustar 00root root 0000000 0000000 package plumbing
import (
"errors"
"fmt"
"regexp"
"strings"
)
const (
refPrefix = "refs/"
refHeadPrefix = refPrefix + "heads/"
refTagPrefix = refPrefix + "tags/"
refRemotePrefix = refPrefix + "remotes/"
refNotePrefix = refPrefix + "notes/"
symrefPrefix = "ref: "
)
// RefRevParseRules are a set of rules to parse references into short names, or expand into a full reference.
// These are the same rules as used by git in shorten_unambiguous_ref and expand_ref.
// See: https://github.com/git/git/blob/e0aaa1b6532cfce93d87af9bc813fb2e7a7ce9d7/refs.c#L417
var RefRevParseRules = []string{
"%s",
"refs/%s",
"refs/tags/%s",
"refs/heads/%s",
"refs/remotes/%s",
"refs/remotes/%s/HEAD",
}
var (
ErrReferenceNotFound = errors.New("reference not found")
// ErrInvalidReferenceName is returned when a reference name is invalid.
ErrInvalidReferenceName = errors.New("invalid reference name")
)
// ReferenceType reference type's
type ReferenceType int8
const (
InvalidReference ReferenceType = 0
HashReference ReferenceType = 1
SymbolicReference ReferenceType = 2
)
func (r ReferenceType) String() string {
switch r {
case InvalidReference:
return "invalid-reference"
case HashReference:
return "hash-reference"
case SymbolicReference:
return "symbolic-reference"
}
return ""
}
// ReferenceName reference name's
type ReferenceName string
// NewBranchReferenceName returns a reference name describing a branch based on
// his short name.
func NewBranchReferenceName(name string) ReferenceName {
return ReferenceName(refHeadPrefix + name)
}
// NewNoteReferenceName returns a reference name describing a note based on his
// short name.
func NewNoteReferenceName(name string) ReferenceName {
return ReferenceName(refNotePrefix + name)
}
// NewRemoteReferenceName returns a reference name describing a remote branch
// based on his short name and the remote name.
func NewRemoteReferenceName(remote, name string) ReferenceName {
return ReferenceName(refRemotePrefix + fmt.Sprintf("%s/%s", remote, name))
}
// NewRemoteHEADReferenceName returns a reference name describing a the HEAD
// branch of a remote.
func NewRemoteHEADReferenceName(remote string) ReferenceName {
return ReferenceName(refRemotePrefix + fmt.Sprintf("%s/%s", remote, HEAD))
}
// NewTagReferenceName returns a reference name describing a tag based on short
// his name.
func NewTagReferenceName(name string) ReferenceName {
return ReferenceName(refTagPrefix + name)
}
// IsBranch check if a reference is a branch
func (r ReferenceName) IsBranch() bool {
return strings.HasPrefix(string(r), refHeadPrefix)
}
// IsNote check if a reference is a note
func (r ReferenceName) IsNote() bool {
return strings.HasPrefix(string(r), refNotePrefix)
}
// IsRemote check if a reference is a remote
func (r ReferenceName) IsRemote() bool {
return strings.HasPrefix(string(r), refRemotePrefix)
}
// IsTag check if a reference is a tag
func (r ReferenceName) IsTag() bool {
return strings.HasPrefix(string(r), refTagPrefix)
}
func (r ReferenceName) String() string {
return string(r)
}
// Short returns the short name of a ReferenceName
func (r ReferenceName) Short() string {
s := string(r)
res := s
for _, format := range RefRevParseRules[1:] {
_, err := fmt.Sscanf(s, format, &res)
if err == nil {
continue
}
}
return res
}
var (
ctrlSeqs = regexp.MustCompile(`[\000-\037\177]`)
)
// Validate validates a reference name.
// This follows the git-check-ref-format rules.
// See https://git-scm.com/docs/git-check-ref-format
//
// It is important to note that this function does not check if the reference
// exists in the repository.
// It only checks if the reference name is valid.
// This functions does not support the --refspec-pattern, --normalize, and
// --allow-onelevel options.
//
// Git imposes the following rules on how references are named:
//
// 1. They can include slash / for hierarchical (directory) grouping, but no
// slash-separated component can begin with a dot . or end with the
// sequence .lock.
// 2. They must contain at least one /. This enforces the presence of a
// category like heads/, tags/ etc. but the actual names are not
// restricted. If the --allow-onelevel option is used, this rule is
// waived.
// 3. They cannot have two consecutive dots .. anywhere.
// 4. They cannot have ASCII control characters (i.e. bytes whose values are
// lower than \040, or \177 DEL), space, tilde ~, caret ^, or colon :
// anywhere.
// 5. They cannot have question-mark ?, asterisk *, or open bracket [
// anywhere. See the --refspec-pattern option below for an exception to this
// rule.
// 6. They cannot begin or end with a slash / or contain multiple consecutive
// slashes (see the --normalize option below for an exception to this rule).
// 7. They cannot end with a dot ..
// 8. They cannot contain a sequence @{.
// 9. They cannot be the single character @.
// 10. They cannot contain a \.
func (r ReferenceName) Validate() error {
s := string(r)
if len(s) == 0 {
return ErrInvalidReferenceName
}
// HEAD is a special case
if r == HEAD {
return nil
}
// rule 7
if strings.HasSuffix(s, ".") {
return ErrInvalidReferenceName
}
// rule 2
parts := strings.Split(s, "/")
if len(parts) < 2 {
return ErrInvalidReferenceName
}
isBranch := r.IsBranch()
isTag := r.IsTag()
for i, part := range parts {
// rule 6
if len(part) == 0 {
return ErrInvalidReferenceName
}
if strings.HasPrefix(part, ".") || // rule 1
strings.Contains(part, "..") || // rule 3
ctrlSeqs.MatchString(part) || // rule 4
strings.ContainsAny(part, "~^:?*[ \t\n") || // rule 4 & 5
strings.Contains(part, "@{") || // rule 8
part == "@" || // rule 9
strings.Contains(part, "\\") || // rule 10
strings.HasSuffix(part, ".lock") { // rule 1
return ErrInvalidReferenceName
}
if (isBranch || isTag) && strings.HasPrefix(part, "-") && (i == 2) { // branches & tags can't start with -
return ErrInvalidReferenceName
}
}
return nil
}
const (
HEAD ReferenceName = "HEAD"
Master ReferenceName = "refs/heads/master"
Main ReferenceName = "refs/heads/main"
)
// Reference is a representation of git reference
type Reference struct {
t ReferenceType
n ReferenceName
h Hash
target ReferenceName
}
// NewReferenceFromStrings creates a reference from name and target as string,
// the resulting reference can be a SymbolicReference or a HashReference base
// on the target provided
func NewReferenceFromStrings(name, target string) *Reference {
n := ReferenceName(name)
if strings.HasPrefix(target, symrefPrefix) {
target := ReferenceName(target[len(symrefPrefix):])
return NewSymbolicReference(n, target)
}
return NewHashReference(n, NewHash(target))
}
// NewSymbolicReference creates a new SymbolicReference reference
func NewSymbolicReference(n, target ReferenceName) *Reference {
return &Reference{
t: SymbolicReference,
n: n,
target: target,
}
}
// NewHashReference creates a new HashReference reference
func NewHashReference(n ReferenceName, h Hash) *Reference {
return &Reference{
t: HashReference,
n: n,
h: h,
}
}
// Type returns the type of a reference
func (r *Reference) Type() ReferenceType {
return r.t
}
// Name returns the name of a reference
func (r *Reference) Name() ReferenceName {
return r.n
}
// Hash returns the hash of a hash reference
func (r *Reference) Hash() Hash {
return r.h
}
// Target returns the target of a symbolic reference
func (r *Reference) Target() ReferenceName {
return r.target
}
// Strings dump a reference as a [2]string
func (r *Reference) Strings() [2]string {
var o [2]string
o[0] = r.Name().String()
switch r.Type() {
case HashReference:
o[1] = r.Hash().String()
case SymbolicReference:
o[1] = symrefPrefix + r.Target().String()
}
return o
}
func (r *Reference) String() string {
ref := ""
switch r.Type() {
case HashReference:
ref = r.Hash().String()
case SymbolicReference:
ref = symrefPrefix + r.Target().String()
default:
return ""
}
name := r.Name().String()
var v strings.Builder
v.Grow(len(ref) + len(name) + 1)
v.WriteString(ref)
v.WriteString(" ")
v.WriteString(name)
return v.String()
}
go-git-5.13.2/plumbing/reference_test.go 0000664 0000000 0000000 00000011462 14744245500 0020142 0 ustar 00root root 0000000 0000000 package plumbing
import (
"testing"
. "gopkg.in/check.v1"
)
type ReferenceSuite struct{}
var _ = Suite(&ReferenceSuite{})
const (
ExampleReferenceName ReferenceName = "refs/heads/v4"
)
func (s *ReferenceSuite) TestReferenceTypeString(c *C) {
c.Assert(SymbolicReference.String(), Equals, "symbolic-reference")
}
func (s *ReferenceSuite) TestReferenceNameShort(c *C) {
c.Assert(ExampleReferenceName.Short(), Equals, "v4")
}
func (s *ReferenceSuite) TestReferenceNameWithSlash(c *C) {
r := ReferenceName("refs/remotes/origin/feature/AllowSlashes")
c.Assert(r.Short(), Equals, "origin/feature/AllowSlashes")
}
func (s *ReferenceSuite) TestReferenceNameNote(c *C) {
r := ReferenceName("refs/notes/foo")
c.Assert(r.Short(), Equals, "notes/foo")
}
func (s *ReferenceSuite) TestNewReferenceFromStrings(c *C) {
r := NewReferenceFromStrings("refs/heads/v4", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
c.Assert(r.Type(), Equals, HashReference)
c.Assert(r.Name(), Equals, ExampleReferenceName)
c.Assert(r.Hash(), Equals, NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
r = NewReferenceFromStrings("HEAD", "ref: refs/heads/v4")
c.Assert(r.Type(), Equals, SymbolicReference)
c.Assert(r.Name(), Equals, HEAD)
c.Assert(r.Target(), Equals, ExampleReferenceName)
}
func (s *ReferenceSuite) TestNewSymbolicReference(c *C) {
r := NewSymbolicReference(HEAD, ExampleReferenceName)
c.Assert(r.Type(), Equals, SymbolicReference)
c.Assert(r.Name(), Equals, HEAD)
c.Assert(r.Target(), Equals, ExampleReferenceName)
}
func (s *ReferenceSuite) TestNewHashReference(c *C) {
r := NewHashReference(ExampleReferenceName, NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
c.Assert(r.Type(), Equals, HashReference)
c.Assert(r.Name(), Equals, ExampleReferenceName)
c.Assert(r.Hash(), Equals, NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
}
func (s *ReferenceSuite) TestNewBranchReferenceName(c *C) {
r := NewBranchReferenceName("foo")
c.Assert(r.String(), Equals, "refs/heads/foo")
}
func (s *ReferenceSuite) TestNewNoteReferenceName(c *C) {
r := NewNoteReferenceName("foo")
c.Assert(r.String(), Equals, "refs/notes/foo")
}
func (s *ReferenceSuite) TestNewRemoteReferenceName(c *C) {
r := NewRemoteReferenceName("bar", "foo")
c.Assert(r.String(), Equals, "refs/remotes/bar/foo")
}
func (s *ReferenceSuite) TestNewRemoteHEADReferenceName(c *C) {
r := NewRemoteHEADReferenceName("foo")
c.Assert(r.String(), Equals, "refs/remotes/foo/HEAD")
}
func (s *ReferenceSuite) TestNewTagReferenceName(c *C) {
r := NewTagReferenceName("foo")
c.Assert(r.String(), Equals, "refs/tags/foo")
}
func (s *ReferenceSuite) TestIsBranch(c *C) {
r := ExampleReferenceName
c.Assert(r.IsBranch(), Equals, true)
}
func (s *ReferenceSuite) TestIsNote(c *C) {
r := ReferenceName("refs/notes/foo")
c.Assert(r.IsNote(), Equals, true)
}
func (s *ReferenceSuite) TestIsRemote(c *C) {
r := ReferenceName("refs/remotes/origin/master")
c.Assert(r.IsRemote(), Equals, true)
}
func (s *ReferenceSuite) TestIsTag(c *C) {
r := ReferenceName("refs/tags/v3.1.")
c.Assert(r.IsTag(), Equals, true)
}
func (s *ReferenceSuite) TestValidReferenceNames(c *C) {
valid := []ReferenceName{
"refs/heads/master",
"refs/notes/commits",
"refs/remotes/origin/master",
"HEAD",
"refs/tags/v3.1.1",
"refs/pulls/1/head",
"refs/pulls/1/merge",
"refs/pulls/1/abc.123",
"refs/pulls",
"refs/-", // should this be allowed?
"refs/ab/-testing",
"refs/123-testing",
}
for _, v := range valid {
c.Assert(v.Validate(), IsNil)
}
invalid := []ReferenceName{
"refs",
"refs/",
"refs//",
"refs/heads/\\",
"refs/heads/\\foo",
"refs/heads/\\foo/bar",
"abc",
"",
"refs/heads/ ",
"refs/heads/ /",
"refs/heads/ /foo",
"refs/heads/.",
"refs/heads/..",
"refs/heads/foo..",
"refs/heads/foo.lock",
"refs/heads/foo@{bar}",
"refs/heads/foo[",
"refs/heads/foo~",
"refs/heads/foo^",
"refs/heads/foo:",
"refs/heads/foo?",
"refs/heads/foo*",
"refs/heads/foo[bar",
"refs/heads/foo\t",
"refs/heads/@",
"refs/heads/@{bar}",
"refs/heads/\n",
"refs/heads/-foo",
"refs/heads/foo..bar",
"refs/heads/-",
"refs/tags/-",
"refs/tags/-foo",
}
for i, v := range invalid {
comment := Commentf("invalid reference name case %d: %s", i, v)
c.Assert(v.Validate(), NotNil, comment)
c.Assert(v.Validate(), ErrorMatches, "invalid reference name", comment)
}
}
func benchMarkReferenceString(r *Reference, b *testing.B) {
for n := 0; n < b.N; n++ {
_ = r.String()
}
}
func BenchmarkReferenceStringSymbolic(b *testing.B) {
benchMarkReferenceString(NewSymbolicReference("v3.1.1", "refs/tags/v3.1.1"), b)
}
func BenchmarkReferenceStringHash(b *testing.B) {
benchMarkReferenceString(NewHashReference("v3.1.1", NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")), b)
}
func BenchmarkReferenceStringInvalid(b *testing.B) {
benchMarkReferenceString(&Reference{}, b)
}
go-git-5.13.2/plumbing/revision.go 0000664 0000000 0000000 00000000431 14744245500 0016775 0 ustar 00root root 0000000 0000000 package plumbing
// Revision represents a git revision
// to get more details about git revisions
// please check git manual page :
// https://www.kernel.org/pub/software/scm/git/docs/gitrevisions.html
type Revision string
func (r Revision) String() string {
return string(r)
}
go-git-5.13.2/plumbing/revlist/ 0000775 0000000 0000000 00000000000 14744245500 0016302 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/revlist/revlist.go 0000664 0000000 0000000 00000011710 14744245500 0020321 0 ustar 00root root 0000000 0000000 // Package revlist provides support to access the ancestors of commits, in a
// similar way as the git-rev-list command.
package revlist
import (
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/storer"
)
// Objects applies a complementary set. It gets all the hashes from all
// the reachable objects from the given objects. Ignore param are object hashes
// that we want to ignore on the result. All that objects must be accessible
// from the object storer.
func Objects(
s storer.EncodedObjectStorer,
objs,
ignore []plumbing.Hash,
) ([]plumbing.Hash, error) {
return ObjectsWithStorageForIgnores(s, s, objs, ignore)
}
// ObjectsWithStorageForIgnores is the same as Objects, but a
// secondary storage layer can be provided, to be used to finding the
// full set of objects to be ignored while finding the reachable
// objects. This is useful when the main `s` storage layer is slow
// and/or remote, while the ignore list is available somewhere local.
func ObjectsWithStorageForIgnores(
s, ignoreStore storer.EncodedObjectStorer,
objs,
ignore []plumbing.Hash,
) ([]plumbing.Hash, error) {
ignore, err := objects(ignoreStore, ignore, nil, true)
if err != nil {
return nil, err
}
return objects(s, objs, ignore, false)
}
func objects(
s storer.EncodedObjectStorer,
objects,
ignore []plumbing.Hash,
allowMissingObjects bool,
) ([]plumbing.Hash, error) {
seen := hashListToSet(ignore)
result := make(map[plumbing.Hash]bool)
visited := make(map[plumbing.Hash]bool)
walkerFunc := func(h plumbing.Hash) {
if !seen[h] {
result[h] = true
seen[h] = true
}
}
for _, h := range objects {
if err := processObject(s, h, seen, visited, ignore, walkerFunc); err != nil {
if allowMissingObjects && err == plumbing.ErrObjectNotFound {
continue
}
return nil, err
}
}
return hashSetToList(result), nil
}
// processObject obtains the object using the hash an process it depending of its type
func processObject(
s storer.EncodedObjectStorer,
h plumbing.Hash,
seen map[plumbing.Hash]bool,
visited map[plumbing.Hash]bool,
ignore []plumbing.Hash,
walkerFunc func(h plumbing.Hash),
) error {
if seen[h] {
return nil
}
o, err := s.EncodedObject(plumbing.AnyObject, h)
if err != nil {
return err
}
do, err := object.DecodeObject(s, o)
if err != nil {
return err
}
switch do := do.(type) {
case *object.Commit:
return reachableObjects(do, seen, visited, ignore, walkerFunc)
case *object.Tree:
return iterateCommitTrees(seen, do, walkerFunc)
case *object.Tag:
walkerFunc(do.Hash)
return processObject(s, do.Target, seen, visited, ignore, walkerFunc)
case *object.Blob:
walkerFunc(do.Hash)
default:
return fmt.Errorf("object type not valid: %s. "+
"Object reference: %s", o.Type(), o.Hash())
}
return nil
}
// reachableObjects returns, using the callback function, all the reachable
// objects from the specified commit. To avoid to iterate over seen commits,
// if a commit hash is into the 'seen' set, we will not iterate all his trees
// and blobs objects.
func reachableObjects(
commit *object.Commit,
seen map[plumbing.Hash]bool,
visited map[plumbing.Hash]bool,
ignore []plumbing.Hash,
cb func(h plumbing.Hash),
) error {
i := object.NewCommitPreorderIter(commit, seen, ignore)
pending := make(map[plumbing.Hash]bool)
addPendingParents(pending, visited, commit)
for {
commit, err := i.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
if pending[commit.Hash] {
delete(pending, commit.Hash)
}
addPendingParents(pending, visited, commit)
if visited[commit.Hash] && len(pending) == 0 {
break
}
if seen[commit.Hash] {
continue
}
cb(commit.Hash)
tree, err := commit.Tree()
if err != nil {
return err
}
if err := iterateCommitTrees(seen, tree, cb); err != nil {
return err
}
}
return nil
}
func addPendingParents(pending, visited map[plumbing.Hash]bool, commit *object.Commit) {
for _, p := range commit.ParentHashes {
if !visited[p] {
pending[p] = true
}
}
}
// iterateCommitTrees iterate all reachable trees from the given commit
func iterateCommitTrees(
seen map[plumbing.Hash]bool,
tree *object.Tree,
cb func(h plumbing.Hash),
) error {
if seen[tree.Hash] {
return nil
}
cb(tree.Hash)
treeWalker := object.NewTreeWalker(tree, true, seen)
for {
_, e, err := treeWalker.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
if e.Mode == filemode.Submodule {
continue
}
if seen[e.Hash] {
continue
}
cb(e.Hash)
}
return nil
}
func hashSetToList(hashes map[plumbing.Hash]bool) []plumbing.Hash {
var result []plumbing.Hash
for key := range hashes {
result = append(result, key)
}
return result
}
func hashListToSet(hashes []plumbing.Hash) map[plumbing.Hash]bool {
result := make(map[plumbing.Hash]bool)
for _, h := range hashes {
result[h] = true
}
return result
}
go-git-5.13.2/plumbing/revlist/revlist_test.go 0000664 0000000 0000000 00000020776 14744245500 0021374 0 ustar 00root root 0000000 0000000 package revlist
import (
"testing"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/filesystem"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type RevListSuite struct {
fixtures.Suite
Storer storer.EncodedObjectStorer
}
var _ = Suite(&RevListSuite{})
const (
initialCommit = "b029517f6300c2da0f4b651b8642506cd6aaf45d"
secondCommit = "b8e471f58bcbca63b07bda20e428190409c2db47"
someCommit = "918c48b83bd081e863dbe1b80f8998f058cd8294"
someCommitBranch = "e8d3ffab552895c19b9fcf7aa264d277cde33881"
someCommitOtherBranch = "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"
)
// Created using: git log --graph --oneline --all
//
// Basic fixture repository commits tree:
//
// * 6ecf0ef vendor stuff
// | * e8d3ffa some code in a branch
// |/
// * 918c48b some code
// * af2d6a6 some json
// * 1669dce Merge branch 'master'
// |\
// | * a5b8b09 Merge pull request #1
// | |\
// | | * b8e471f Creating changelog
// | |/
// * | 35e8510 binary file
// |/
// * b029517 Initial commit
func (s *RevListSuite) SetUpTest(c *C) {
sto := filesystem.NewStorage(fixtures.Basic().One().DotGit(), cache.NewObjectLRUDefault())
s.Storer = sto
}
func (s *RevListSuite) TestRevListObjects_Submodules(c *C) {
submodules := map[string]bool{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5": true,
}
sto := filesystem.NewStorage(fixtures.ByTag("submodule").One().DotGit(), cache.NewObjectLRUDefault())
ref, err := storer.ResolveReference(sto, plumbing.HEAD)
c.Assert(err, IsNil)
revList, err := Objects(sto, []plumbing.Hash{ref.Hash()}, nil)
c.Assert(err, IsNil)
for _, h := range revList {
c.Assert(submodules[h.String()], Equals, false)
}
}
// ---
// | |\
// | | * b8e471f Creating changelog
// | |/
// * | 35e8510 binary file
// |/
// * b029517 Initial commit
func (s *RevListSuite) TestRevListObjects(c *C) {
revList := map[string]bool{
"b8e471f58bcbca63b07bda20e428190409c2db47": true, // second commit
"c2d30fa8ef288618f65f6eed6e168e0d514886f4": true, // init tree
"d3ff53e0564a9f87d8e84b6e28e5060e517008aa": true, // CHANGELOG
}
localHist, err := Objects(s.Storer,
[]plumbing.Hash{plumbing.NewHash(initialCommit)}, nil)
c.Assert(err, IsNil)
remoteHist, err := Objects(s.Storer,
[]plumbing.Hash{plumbing.NewHash(secondCommit)}, localHist)
c.Assert(err, IsNil)
for _, h := range remoteHist {
c.Assert(revList[h.String()], Equals, true)
}
c.Assert(len(remoteHist), Equals, len(revList))
}
func (s *RevListSuite) TestRevListObjectsTagObject(c *C) {
sto := filesystem.NewStorage(
fixtures.ByTag("tags").
ByURL("https://github.com/git-fixtures/tags.git").One().DotGit(), cache.NewObjectLRUDefault())
expected := map[string]bool{
"70846e9a10ef7b41064b40f07713d5b8b9a8fc73": true,
"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391": true,
"ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc": true,
"f7b877701fbf855b44c0a9e86f3fdce2c298b07f": true,
}
hist, err := Objects(sto, []plumbing.Hash{plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc")}, nil)
c.Assert(err, IsNil)
for _, h := range hist {
c.Assert(expected[h.String()], Equals, true)
}
c.Assert(len(hist), Equals, len(expected))
}
func (s *RevListSuite) TestRevListObjectsWithStorageForIgnores(c *C) {
sto := filesystem.NewStorage(
fixtures.ByTag("merge-conflict").One().DotGit(),
cache.NewObjectLRUDefault())
// The "merge-conflict" repo has one extra commit in it, with a
// two files modified in two different subdirs.
expected := map[string]bool{
"1980fcf55330d9d94c34abee5ab734afecf96aba": true, // commit
"73d9cf44e9045254346c73f6646b08f9302c8570": true, // root dir
"e8435d512a98586bd2e4fcfcdf04101b0bb1b500": true, // go/
"257cc5642cb1a054f08cc83f2d943e56fd3ebe99": true, // haskal.hs
"d499a1a0b79b7d87a35155afd0c1cce78b37a91c": true, // example.go
"d108adc364fb6f21395d011ae2c8a11d96905b0d": true, // haskal/
}
hist, err := ObjectsWithStorageForIgnores(sto, s.Storer, []plumbing.Hash{plumbing.NewHash("1980fcf55330d9d94c34abee5ab734afecf96aba")}, []plumbing.Hash{plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")})
c.Assert(err, IsNil)
for _, h := range hist {
c.Assert(expected[h.String()], Equals, true)
}
c.Assert(len(hist), Equals, len(expected))
}
// ---
// | |\
// | | * b8e471f Creating changelog
// | |/
// * | 35e8510 binary file
// |/
// * b029517 Initial commit
func (s *RevListSuite) TestRevListObjectsWithBlobsAndTrees(c *C) {
revList := map[string]bool{
"b8e471f58bcbca63b07bda20e428190409c2db47": true, // second commit
}
localHist, err := Objects(s.Storer,
[]plumbing.Hash{
plumbing.NewHash(initialCommit),
plumbing.NewHash("c2d30fa8ef288618f65f6eed6e168e0d514886f4"),
plumbing.NewHash("d3ff53e0564a9f87d8e84b6e28e5060e517008aa"),
}, nil)
c.Assert(err, IsNil)
remoteHist, err := Objects(s.Storer,
[]plumbing.Hash{plumbing.NewHash(secondCommit)}, localHist)
c.Assert(err, IsNil)
for _, h := range remoteHist {
c.Assert(revList[h.String()], Equals, true)
}
c.Assert(len(remoteHist), Equals, len(revList))
}
func (s *RevListSuite) TestRevListObjectsReverse(c *C) {
localHist, err := Objects(s.Storer,
[]plumbing.Hash{plumbing.NewHash(secondCommit)}, nil)
c.Assert(err, IsNil)
remoteHist, err := Objects(s.Storer,
[]plumbing.Hash{plumbing.NewHash(initialCommit)}, localHist)
c.Assert(err, IsNil)
c.Assert(len(remoteHist), Equals, 0)
}
func (s *RevListSuite) TestRevListObjectsSameCommit(c *C) {
localHist, err := Objects(s.Storer,
[]plumbing.Hash{plumbing.NewHash(secondCommit)}, nil)
c.Assert(err, IsNil)
remoteHist, err := Objects(s.Storer,
[]plumbing.Hash{plumbing.NewHash(secondCommit)}, localHist)
c.Assert(err, IsNil)
c.Assert(len(remoteHist), Equals, 0)
}
// * 6ecf0ef vendor stuff
// | * e8d3ffa some code in a branch
// |/
// * 918c48b some code
// -----
func (s *RevListSuite) TestRevListObjectsNewBranch(c *C) {
localHist, err := Objects(s.Storer,
[]plumbing.Hash{plumbing.NewHash(someCommit)}, nil)
c.Assert(err, IsNil)
remoteHist, err := Objects(
s.Storer, []plumbing.Hash{
plumbing.NewHash(someCommitBranch),
plumbing.NewHash(someCommitOtherBranch)}, localHist)
c.Assert(err, IsNil)
revList := map[string]bool{
"a8d315b2b1c615d43042c3a62402b8a54288cf5c": true, // init tree
"cf4aa3b38974fb7d81f367c0830f7d78d65ab86b": true, // vendor folder
"9dea2395f5403188298c1dabe8bdafe562c491e3": true, // foo.go
"e8d3ffab552895c19b9fcf7aa264d277cde33881": true, // branch commit
"dbd3641b371024f44d0e469a9c8f5457b0660de1": true, // init tree
"7e59600739c96546163833214c36459e324bad0a": true, // README
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5": true, // otherBranch commit
}
for _, h := range remoteHist {
c.Assert(revList[h.String()], Equals, true)
}
c.Assert(len(remoteHist), Equals, len(revList))
}
// This tests will ensure that a5b8b09 and b8e471f will be visited even if
// 35e8510 has already been visited and will not stop iterating until they
// have been as well.
//
// * af2d6a6 some json
// * 1669dce Merge branch 'master'
// |\
// | * a5b8b09 Merge pull request #1
// | |\
// | | * b8e471f Creating changelog
// | |/
// * | 35e8510 binary file
// |/
// * b029517 Initial commit
func (s *RevListSuite) TestReachableObjectsNoRevisit(c *C) {
obj, err := s.Storer.EncodedObject(plumbing.CommitObject, plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"))
c.Assert(err, IsNil)
do, err := object.DecodeObject(s.Storer, obj)
c.Assert(err, IsNil)
commit, ok := do.(*object.Commit)
c.Assert(ok, Equals, true)
var visited []plumbing.Hash
err = reachableObjects(
commit,
map[plumbing.Hash]bool{
plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"): true,
},
map[plumbing.Hash]bool{
plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"): true,
},
nil,
func(h plumbing.Hash) {
obj, err := s.Storer.EncodedObject(plumbing.AnyObject, h)
c.Assert(err, IsNil)
do, err := object.DecodeObject(s.Storer, obj)
c.Assert(err, IsNil)
if _, ok := do.(*object.Commit); ok {
visited = append(visited, h)
}
},
)
c.Assert(err, IsNil)
c.Assert(visited, DeepEquals, []plumbing.Hash{
plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"),
plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"),
plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"),
plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"),
})
}
go-git-5.13.2/plumbing/serverinfo/ 0000775 0000000 0000000 00000000000 14744245500 0016774 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/serverinfo/serverinfo.go 0000664 0000000 0000000 00000003721 14744245500 0021510 0 ustar 00root root 0000000 0000000 package serverinfo
import (
"fmt"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/internal/reference"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage"
)
// UpdateServerInfo updates the server info files in the repository.
//
// It generates a list of available refs for the repository.
// Used by git http transport (dumb), for more information refer to:
// https://git-scm.com/book/id/v2/Git-Internals-Transfer-Protocols#_the_dumb_protocol
func UpdateServerInfo(s storage.Storer, fs billy.Filesystem) error {
pos, ok := s.(storer.PackedObjectStorer)
if !ok {
return git.ErrPackedObjectsNotSupported
}
infoRefs, err := fs.Create("info/refs")
if err != nil {
return err
}
defer infoRefs.Close()
refsIter, err := s.IterReferences()
if err != nil {
return err
}
defer refsIter.Close()
var refs []*plumbing.Reference
if err := refsIter.ForEach(func(ref *plumbing.Reference) error {
refs = append(refs, ref)
return nil
}); err != nil {
return err
}
reference.Sort(refs)
for _, ref := range refs {
name := ref.Name()
hash := ref.Hash()
switch ref.Type() {
case plumbing.SymbolicReference:
if name == plumbing.HEAD {
continue
}
ref, err := s.Reference(ref.Target())
if err != nil {
return err
}
hash = ref.Hash()
fallthrough
case plumbing.HashReference:
fmt.Fprintf(infoRefs, "%s\t%s\n", hash, name)
if name.IsTag() {
tag, err := object.GetTag(s, hash)
if err == nil {
fmt.Fprintf(infoRefs, "%s\t%s^{}\n", tag.Target, name)
}
}
}
}
infoPacks, err := fs.Create("objects/info/packs")
if err != nil {
return err
}
defer infoPacks.Close()
packs, err := pos.ObjectPacks()
if err != nil {
return err
}
for _, p := range packs {
fmt.Fprintf(infoPacks, "P pack-%s.pack\n", p)
}
fmt.Fprintln(infoPacks)
return nil
}
go-git-5.13.2/plumbing/serverinfo/serverinfo_test.go 0000664 0000000 0000000 00000010370 14744245500 0022545 0 ustar 00root root 0000000 0000000 package serverinfo
import (
"io"
"strings"
"testing"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/memfs"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
type ServerInfoSuite struct{}
var _ = Suite(&ServerInfoSuite{})
func Test(t *testing.T) { TestingT(t) }
func (s *ServerInfoSuite) TestUpdateServerInfoInit(c *C) {
fs := memfs.New()
st := memory.NewStorage()
r, err := git.Init(st, fs)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
err = UpdateServerInfo(st, fs)
c.Assert(err, IsNil)
}
func assertInfoRefs(c *C, st storage.Storer, fs billy.Filesystem) {
refsFile, err := fs.Open("info/refs")
c.Assert(err, IsNil)
defer refsFile.Close()
bts, err := io.ReadAll(refsFile)
c.Assert(err, IsNil)
localRefs := make(map[plumbing.ReferenceName]plumbing.Hash)
for _, line := range strings.Split(string(bts), "\n") {
if line == "" {
continue
}
parts := strings.Split(line, "\t")
c.Assert(parts, HasLen, 2)
hash := plumbing.NewHash(parts[0])
name := plumbing.ReferenceName(parts[1])
localRefs[name] = hash
}
refs, err := st.IterReferences()
c.Assert(err, IsNil)
err = refs.ForEach(func(ref *plumbing.Reference) error {
name := ref.Name()
hash := ref.Hash()
switch ref.Type() {
case plumbing.SymbolicReference:
if name == plumbing.HEAD {
return nil
}
ref, err := st.Reference(ref.Target())
c.Assert(err, IsNil)
hash = ref.Hash()
fallthrough
case plumbing.HashReference:
h, ok := localRefs[name]
c.Assert(ok, Equals, true)
c.Assert(h, Equals, hash)
if name.IsTag() {
tag, err := object.GetTag(st, hash)
if err == nil {
t, ok := localRefs[name+"^{}"]
c.Assert(ok, Equals, true)
c.Assert(t, Equals, tag.Target)
}
}
}
return nil
})
c.Assert(err, IsNil)
}
func assertObjectPacks(c *C, st storage.Storer, fs billy.Filesystem) {
infoPacks, err := fs.Open("objects/info/packs")
c.Assert(err, IsNil)
defer infoPacks.Close()
bts, err := io.ReadAll(infoPacks)
c.Assert(err, IsNil)
pos, ok := st.(storer.PackedObjectStorer)
c.Assert(ok, Equals, true)
localPacks := make(map[string]struct{})
packs, err := pos.ObjectPacks()
c.Assert(err, IsNil)
for _, line := range strings.Split(string(bts), "\n") {
if line == "" {
continue
}
parts := strings.Split(line, " ")
c.Assert(parts, HasLen, 2)
pack := strings.TrimPrefix(parts[1], "pack-")
pack = strings.TrimSuffix(pack, ".pack")
localPacks[pack] = struct{}{}
}
for _, p := range packs {
_, ok := localPacks[p.String()]
c.Assert(ok, Equals, true)
}
}
func (s *ServerInfoSuite) TestUpdateServerInfoTags(c *C) {
fs := memfs.New()
st := memory.NewStorage()
r, err := git.Clone(st, fs, &git.CloneOptions{
URL: fixtures.ByURL("https://github.com/git-fixtures/tags.git").One().URL,
})
c.Assert(err, IsNil)
c.Assert(r, NotNil)
err = UpdateServerInfo(st, fs)
c.Assert(err, IsNil)
assertInfoRefs(c, st, fs)
assertObjectPacks(c, st, fs)
}
func (s *ServerInfoSuite) TestUpdateServerInfoBasic(c *C) {
fs := memfs.New()
st := memory.NewStorage()
r, err := git.Clone(st, fs, &git.CloneOptions{
URL: fixtures.Basic().One().URL,
})
c.Assert(err, IsNil)
c.Assert(r, NotNil)
err = UpdateServerInfo(st, fs)
c.Assert(err, IsNil)
assertInfoRefs(c, st, fs)
assertObjectPacks(c, st, fs)
}
func (s *ServerInfoSuite) TestUpdateServerInfoBasicChange(c *C) {
fs := memfs.New()
st := memory.NewStorage()
r, err := git.Clone(st, fs, &git.CloneOptions{
URL: fixtures.Basic().One().URL,
})
c.Assert(err, IsNil)
c.Assert(r, NotNil)
err = UpdateServerInfo(st, fs)
c.Assert(err, IsNil)
assertInfoRefs(c, st, fs)
assertObjectPacks(c, st, fs)
head, err := r.Head()
c.Assert(err, IsNil)
ref := plumbing.NewHashReference("refs/heads/my-branch", head.Hash())
err = r.Storer.SetReference(ref)
c.Assert(err, IsNil)
_, err = r.CreateTag("test-tag", head.Hash(), &git.CreateTagOptions{
Message: "test-tag",
})
c.Assert(err, IsNil)
err = UpdateServerInfo(st, fs)
c.Assert(err, IsNil)
assertInfoRefs(c, st, fs)
assertObjectPacks(c, st, fs)
}
go-git-5.13.2/plumbing/storer/ 0000775 0000000 0000000 00000000000 14744245500 0016130 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/storer/doc.go 0000664 0000000 0000000 00000000133 14744245500 0017221 0 ustar 00root root 0000000 0000000 // Package storer defines the interfaces to store objects, references, etc.
package storer
go-git-5.13.2/plumbing/storer/index.go 0000664 0000000 0000000 00000000326 14744245500 0017567 0 ustar 00root root 0000000 0000000 package storer
import "github.com/go-git/go-git/v5/plumbing/format/index"
// IndexStorer generic storage of index.Index
type IndexStorer interface {
SetIndex(*index.Index) error
Index() (*index.Index, error)
}
go-git-5.13.2/plumbing/storer/object.go 0000664 0000000 0000000 00000023250 14744245500 0017727 0 ustar 00root root 0000000 0000000 package storer
import (
"errors"
"io"
"time"
"github.com/go-git/go-git/v5/plumbing"
)
var (
//ErrStop is used to stop a ForEach function in an Iter
ErrStop = errors.New("stop iter")
)
// EncodedObjectStorer generic storage of objects
type EncodedObjectStorer interface {
// NewEncodedObject returns a new plumbing.EncodedObject, the real type
// of the object can be a custom implementation or the default one,
// plumbing.MemoryObject.
NewEncodedObject() plumbing.EncodedObject
// SetEncodedObject saves an object into the storage, the object should
// be create with the NewEncodedObject, method, and file if the type is
// not supported.
SetEncodedObject(plumbing.EncodedObject) (plumbing.Hash, error)
// EncodedObject gets an object by hash with the given
// plumbing.ObjectType. Implementors should return
// (nil, plumbing.ErrObjectNotFound) if an object doesn't exist with
// both the given hash and object type.
//
// Valid plumbing.ObjectType values are CommitObject, BlobObject, TagObject,
// TreeObject and AnyObject. If plumbing.AnyObject is given, the object must
// be looked up regardless of its type.
EncodedObject(plumbing.ObjectType, plumbing.Hash) (plumbing.EncodedObject, error)
// IterObjects returns a custom EncodedObjectStorer over all the object
// on the storage.
//
// Valid plumbing.ObjectType values are CommitObject, BlobObject, TagObject,
IterEncodedObjects(plumbing.ObjectType) (EncodedObjectIter, error)
// HasEncodedObject returns ErrObjNotFound if the object doesn't
// exist. If the object does exist, it returns nil.
HasEncodedObject(plumbing.Hash) error
// EncodedObjectSize returns the plaintext size of the encoded object.
EncodedObjectSize(plumbing.Hash) (int64, error)
AddAlternate(remote string) error
}
// DeltaObjectStorer is an EncodedObjectStorer that can return delta
// objects.
type DeltaObjectStorer interface {
// DeltaObject is the same as EncodedObject but without resolving deltas.
// Deltas will be returned as plumbing.DeltaObject instances.
DeltaObject(plumbing.ObjectType, plumbing.Hash) (plumbing.EncodedObject, error)
}
// Transactioner is a optional method for ObjectStorer, it enables transactional read and write
// operations.
type Transactioner interface {
// Begin starts a transaction.
Begin() Transaction
}
// LooseObjectStorer is an optional interface for managing "loose"
// objects, i.e. those not in packfiles.
type LooseObjectStorer interface {
// ForEachObjectHash iterates over all the (loose) object hashes
// in the repository without necessarily having to read those objects.
// Objects only inside pack files may be omitted.
// If ErrStop is sent the iteration is stop but no error is returned.
ForEachObjectHash(func(plumbing.Hash) error) error
// LooseObjectTime looks up the (m)time associated with the
// loose object (that is not in a pack file). Some
// implementations (e.g. without loose objects)
// always return an error.
LooseObjectTime(plumbing.Hash) (time.Time, error)
// DeleteLooseObject deletes a loose object if it exists.
DeleteLooseObject(plumbing.Hash) error
}
// PackedObjectStorer is an optional interface for managing objects in
// packfiles.
type PackedObjectStorer interface {
// ObjectPacks returns hashes of object packs if the underlying
// implementation has pack files.
ObjectPacks() ([]plumbing.Hash, error)
// DeleteOldObjectPackAndIndex deletes an object pack and the corresponding index file if they exist.
// Deletion is only performed if the pack is older than the supplied time (or the time is zero).
DeleteOldObjectPackAndIndex(plumbing.Hash, time.Time) error
}
// PackfileWriter is an optional method for ObjectStorer, it enables directly writing
// a packfile to storage.
type PackfileWriter interface {
// PackfileWriter returns a writer for writing a packfile to the storage
//
// If the Storer not implements PackfileWriter the objects should be written
// using the Set method.
PackfileWriter() (io.WriteCloser, error)
}
// EncodedObjectIter is a generic closable interface for iterating over objects.
type EncodedObjectIter interface {
Next() (plumbing.EncodedObject, error)
ForEach(func(plumbing.EncodedObject) error) error
Close()
}
// Transaction is an in-progress storage transaction. A transaction must end
// with a call to Commit or Rollback.
type Transaction interface {
SetEncodedObject(plumbing.EncodedObject) (plumbing.Hash, error)
EncodedObject(plumbing.ObjectType, plumbing.Hash) (plumbing.EncodedObject, error)
Commit() error
Rollback() error
}
// EncodedObjectLookupIter implements EncodedObjectIter. It iterates over a
// series of object hashes and yields their associated objects by retrieving
// each one from object storage. The retrievals are lazy and only occur when the
// iterator moves forward with a call to Next().
//
// The EncodedObjectLookupIter must be closed with a call to Close() when it is
// no longer needed.
type EncodedObjectLookupIter struct {
storage EncodedObjectStorer
series []plumbing.Hash
t plumbing.ObjectType
pos int
}
// NewEncodedObjectLookupIter returns an object iterator given an object storage
// and a slice of object hashes.
func NewEncodedObjectLookupIter(
storage EncodedObjectStorer, t plumbing.ObjectType, series []plumbing.Hash) *EncodedObjectLookupIter {
return &EncodedObjectLookupIter{
storage: storage,
series: series,
t: t,
}
}
// Next returns the next object from the iterator. If the iterator has reached
// the end it will return io.EOF as an error. If the object can't be found in
// the object storage, it will return plumbing.ErrObjectNotFound as an error.
// If the object is retrieved successfully error will be nil.
func (iter *EncodedObjectLookupIter) Next() (plumbing.EncodedObject, error) {
if iter.pos >= len(iter.series) {
return nil, io.EOF
}
hash := iter.series[iter.pos]
obj, err := iter.storage.EncodedObject(iter.t, hash)
if err == nil {
iter.pos++
}
return obj, err
}
// ForEach call the cb function for each object contained on this iter until
// an error happens or the end of the iter is reached. If ErrStop is sent
// the iteration is stop but no error is returned. The iterator is closed.
func (iter *EncodedObjectLookupIter) ForEach(cb func(plumbing.EncodedObject) error) error {
return ForEachIterator(iter, cb)
}
// Close releases any resources used by the iterator.
func (iter *EncodedObjectLookupIter) Close() {
iter.pos = len(iter.series)
}
// EncodedObjectSliceIter implements EncodedObjectIter. It iterates over a
// series of objects stored in a slice and yields each one in turn when Next()
// is called.
//
// The EncodedObjectSliceIter must be closed with a call to Close() when it is
// no longer needed.
type EncodedObjectSliceIter struct {
series []plumbing.EncodedObject
}
// NewEncodedObjectSliceIter returns an object iterator for the given slice of
// objects.
func NewEncodedObjectSliceIter(series []plumbing.EncodedObject) *EncodedObjectSliceIter {
return &EncodedObjectSliceIter{
series: series,
}
}
// Next returns the next object from the iterator. If the iterator has reached
// the end it will return io.EOF as an error. If the object is retrieved
// successfully error will be nil.
func (iter *EncodedObjectSliceIter) Next() (plumbing.EncodedObject, error) {
if len(iter.series) == 0 {
return nil, io.EOF
}
obj := iter.series[0]
iter.series = iter.series[1:]
return obj, nil
}
// ForEach call the cb function for each object contained on this iter until
// an error happens or the end of the iter is reached. If ErrStop is sent
// the iteration is stop but no error is returned. The iterator is closed.
func (iter *EncodedObjectSliceIter) ForEach(cb func(plumbing.EncodedObject) error) error {
return ForEachIterator(iter, cb)
}
// Close releases any resources used by the iterator.
func (iter *EncodedObjectSliceIter) Close() {
iter.series = []plumbing.EncodedObject{}
}
// MultiEncodedObjectIter implements EncodedObjectIter. It iterates over several
// EncodedObjectIter,
//
// The MultiObjectIter must be closed with a call to Close() when it is no
// longer needed.
type MultiEncodedObjectIter struct {
iters []EncodedObjectIter
}
// NewMultiEncodedObjectIter returns an object iterator for the given slice of
// EncodedObjectIters.
func NewMultiEncodedObjectIter(iters []EncodedObjectIter) EncodedObjectIter {
return &MultiEncodedObjectIter{iters: iters}
}
// Next returns the next object from the iterator, if one iterator reach io.EOF
// is removed and the next one is used.
func (iter *MultiEncodedObjectIter) Next() (plumbing.EncodedObject, error) {
if len(iter.iters) == 0 {
return nil, io.EOF
}
obj, err := iter.iters[0].Next()
if err == io.EOF {
iter.iters[0].Close()
iter.iters = iter.iters[1:]
return iter.Next()
}
return obj, err
}
// ForEach call the cb function for each object contained on this iter until
// an error happens or the end of the iter is reached. If ErrStop is sent
// the iteration is stop but no error is returned. The iterator is closed.
func (iter *MultiEncodedObjectIter) ForEach(cb func(plumbing.EncodedObject) error) error {
return ForEachIterator(iter, cb)
}
// Close releases any resources used by the iterator.
func (iter *MultiEncodedObjectIter) Close() {
for _, i := range iter.iters {
i.Close()
}
}
type bareIterator interface {
Next() (plumbing.EncodedObject, error)
Close()
}
// ForEachIterator is a helper function to build iterators without need to
// rewrite the same ForEach function each time.
func ForEachIterator(iter bareIterator, cb func(plumbing.EncodedObject) error) error {
defer iter.Close()
for {
obj, err := iter.Next()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
if err := cb(obj); err != nil {
if err == ErrStop {
return nil
}
return err
}
}
}
go-git-5.13.2/plumbing/storer/object_test.go 0000664 0000000 0000000 00000007247 14744245500 0020776 0 ustar 00root root 0000000 0000000 package storer
import (
"fmt"
"testing"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type ObjectSuite struct {
Objects []plumbing.EncodedObject
Hash []plumbing.Hash
}
var _ = Suite(&ObjectSuite{})
func (s *ObjectSuite) SetUpSuite(c *C) {
s.Objects = []plumbing.EncodedObject{
s.buildObject([]byte("foo")),
s.buildObject([]byte("bar")),
}
for _, o := range s.Objects {
s.Hash = append(s.Hash, o.Hash())
}
}
func (s *ObjectSuite) TestMultiObjectIterNext(c *C) {
expected := []plumbing.EncodedObject{
&plumbing.MemoryObject{},
&plumbing.MemoryObject{},
&plumbing.MemoryObject{},
&plumbing.MemoryObject{},
&plumbing.MemoryObject{},
&plumbing.MemoryObject{},
}
iter := NewMultiEncodedObjectIter([]EncodedObjectIter{
NewEncodedObjectSliceIter(expected[0:2]),
NewEncodedObjectSliceIter(expected[2:4]),
NewEncodedObjectSliceIter(expected[4:5]),
})
var i int
iter.ForEach(func(o plumbing.EncodedObject) error {
c.Assert(o, Equals, expected[i])
i++
return nil
})
iter.Close()
}
func (s *ObjectSuite) buildObject(content []byte) plumbing.EncodedObject {
o := &plumbing.MemoryObject{}
o.Write(content)
return o
}
func (s *ObjectSuite) TestObjectLookupIter(c *C) {
var count int
storage := &MockObjectStorage{s.Objects}
i := NewEncodedObjectLookupIter(storage, plumbing.CommitObject, s.Hash)
err := i.ForEach(func(o plumbing.EncodedObject) error {
c.Assert(o, NotNil)
c.Assert(o.Hash().String(), Equals, s.Hash[count].String())
count++
return nil
})
c.Assert(err, IsNil)
i.Close()
}
func (s *ObjectSuite) TestObjectSliceIter(c *C) {
var count int
i := NewEncodedObjectSliceIter(s.Objects)
err := i.ForEach(func(o plumbing.EncodedObject) error {
c.Assert(o, NotNil)
c.Assert(o.Hash().String(), Equals, s.Hash[count].String())
count++
return nil
})
c.Assert(count, Equals, 2)
c.Assert(err, IsNil)
c.Assert(i.series, HasLen, 0)
}
func (s *ObjectSuite) TestObjectSliceIterStop(c *C) {
i := NewEncodedObjectSliceIter(s.Objects)
var count = 0
err := i.ForEach(func(o plumbing.EncodedObject) error {
c.Assert(o, NotNil)
c.Assert(o.Hash().String(), Equals, s.Hash[count].String())
count++
return ErrStop
})
c.Assert(count, Equals, 1)
c.Assert(err, IsNil)
}
func (s *ObjectSuite) TestObjectSliceIterError(c *C) {
i := NewEncodedObjectSliceIter([]plumbing.EncodedObject{
s.buildObject([]byte("foo")),
})
err := i.ForEach(func(plumbing.EncodedObject) error {
return fmt.Errorf("a random error")
})
c.Assert(err, NotNil)
}
type MockObjectStorage struct {
db []plumbing.EncodedObject
}
func (o *MockObjectStorage) NewEncodedObject() plumbing.EncodedObject {
return nil
}
func (o *MockObjectStorage) SetEncodedObject(obj plumbing.EncodedObject) (plumbing.Hash, error) {
return plumbing.ZeroHash, nil
}
func (o *MockObjectStorage) HasEncodedObject(h plumbing.Hash) error {
for _, o := range o.db {
if o.Hash() == h {
return nil
}
}
return plumbing.ErrObjectNotFound
}
func (o *MockObjectStorage) EncodedObjectSize(h plumbing.Hash) (
size int64, err error) {
for _, o := range o.db {
if o.Hash() == h {
return o.Size(), nil
}
}
return 0, plumbing.ErrObjectNotFound
}
func (o *MockObjectStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (plumbing.EncodedObject, error) {
for _, o := range o.db {
if o.Hash() == h {
return o, nil
}
}
return nil, plumbing.ErrObjectNotFound
}
func (o *MockObjectStorage) IterEncodedObjects(t plumbing.ObjectType) (EncodedObjectIter, error) {
return nil, nil
}
func (o *MockObjectStorage) Begin() Transaction {
return nil
}
func (o *MockObjectStorage) AddAlternate(remote string) error {
return nil
}
go-git-5.13.2/plumbing/storer/reference.go 0000664 0000000 0000000 00000014345 14744245500 0020424 0 ustar 00root root 0000000 0000000 package storer
import (
"errors"
"io"
"github.com/go-git/go-git/v5/plumbing"
)
const MaxResolveRecursion = 1024
// ErrMaxResolveRecursion is returned by ResolveReference is MaxResolveRecursion
// is exceeded
var ErrMaxResolveRecursion = errors.New("max. recursion level reached")
// ReferenceStorer is a generic storage of references.
type ReferenceStorer interface {
SetReference(*plumbing.Reference) error
// CheckAndSetReference sets the reference `new`, but if `old` is
// not `nil`, it first checks that the current stored value for
// `old.Name()` matches the given reference value in `old`. If
// not, it returns an error and doesn't update `new`.
CheckAndSetReference(new, old *plumbing.Reference) error
Reference(plumbing.ReferenceName) (*plumbing.Reference, error)
IterReferences() (ReferenceIter, error)
RemoveReference(plumbing.ReferenceName) error
CountLooseRefs() (int, error)
PackRefs() error
}
// ReferenceIter is a generic closable interface for iterating over references.
type ReferenceIter interface {
Next() (*plumbing.Reference, error)
ForEach(func(*plumbing.Reference) error) error
Close()
}
type referenceFilteredIter struct {
ff func(r *plumbing.Reference) bool
iter ReferenceIter
}
// NewReferenceFilteredIter returns a reference iterator for the given reference
// Iterator. This iterator will iterate only references that accomplish the
// provided function.
func NewReferenceFilteredIter(
ff func(r *plumbing.Reference) bool, iter ReferenceIter) ReferenceIter {
return &referenceFilteredIter{ff, iter}
}
// Next returns the next reference from the iterator. If the iterator has reached
// the end it will return io.EOF as an error.
func (iter *referenceFilteredIter) Next() (*plumbing.Reference, error) {
for {
r, err := iter.iter.Next()
if err != nil {
return nil, err
}
if iter.ff(r) {
return r, nil
}
continue
}
}
// ForEach call the cb function for each reference contained on this iter until
// an error happens or the end of the iter is reached. If ErrStop is sent
// the iteration is stopped but no error is returned. The iterator is closed.
func (iter *referenceFilteredIter) ForEach(cb func(*plumbing.Reference) error) error {
defer iter.Close()
for {
r, err := iter.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
if err := cb(r); err != nil {
if err == ErrStop {
break
}
return err
}
}
return nil
}
// Close releases any resources used by the iterator.
func (iter *referenceFilteredIter) Close() {
iter.iter.Close()
}
// ReferenceSliceIter implements ReferenceIter. It iterates over a series of
// references stored in a slice and yields each one in turn when Next() is
// called.
//
// The ReferenceSliceIter must be closed with a call to Close() when it is no
// longer needed.
type ReferenceSliceIter struct {
series []*plumbing.Reference
pos int
}
// NewReferenceSliceIter returns a reference iterator for the given slice of
// objects.
func NewReferenceSliceIter(series []*plumbing.Reference) ReferenceIter {
return &ReferenceSliceIter{
series: series,
}
}
// Next returns the next reference from the iterator. If the iterator has
// reached the end it will return io.EOF as an error.
func (iter *ReferenceSliceIter) Next() (*plumbing.Reference, error) {
if iter.pos >= len(iter.series) {
return nil, io.EOF
}
obj := iter.series[iter.pos]
iter.pos++
return obj, nil
}
// ForEach call the cb function for each reference contained on this iter until
// an error happens or the end of the iter is reached. If ErrStop is sent
// the iteration is stop but no error is returned. The iterator is closed.
func (iter *ReferenceSliceIter) ForEach(cb func(*plumbing.Reference) error) error {
return forEachReferenceIter(iter, cb)
}
type bareReferenceIterator interface {
Next() (*plumbing.Reference, error)
Close()
}
func forEachReferenceIter(iter bareReferenceIterator, cb func(*plumbing.Reference) error) error {
defer iter.Close()
for {
obj, err := iter.Next()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
if err := cb(obj); err != nil {
if err == ErrStop {
return nil
}
return err
}
}
}
// Close releases any resources used by the iterator.
func (iter *ReferenceSliceIter) Close() {
iter.pos = len(iter.series)
}
// MultiReferenceIter implements ReferenceIter. It iterates over several
// ReferenceIter,
//
// The MultiReferenceIter must be closed with a call to Close() when it is no
// longer needed.
type MultiReferenceIter struct {
iters []ReferenceIter
}
// NewMultiReferenceIter returns an reference iterator for the given slice of
// EncodedObjectIters.
func NewMultiReferenceIter(iters []ReferenceIter) ReferenceIter {
return &MultiReferenceIter{iters: iters}
}
// Next returns the next reference from the iterator, if one iterator reach
// io.EOF is removed and the next one is used.
func (iter *MultiReferenceIter) Next() (*plumbing.Reference, error) {
if len(iter.iters) == 0 {
return nil, io.EOF
}
obj, err := iter.iters[0].Next()
if err == io.EOF {
iter.iters[0].Close()
iter.iters = iter.iters[1:]
return iter.Next()
}
return obj, err
}
// ForEach call the cb function for each reference contained on this iter until
// an error happens or the end of the iter is reached. If ErrStop is sent
// the iteration is stop but no error is returned. The iterator is closed.
func (iter *MultiReferenceIter) ForEach(cb func(*plumbing.Reference) error) error {
return forEachReferenceIter(iter, cb)
}
// Close releases any resources used by the iterator.
func (iter *MultiReferenceIter) Close() {
for _, i := range iter.iters {
i.Close()
}
}
// ResolveReference resolves a SymbolicReference to a HashReference.
func ResolveReference(s ReferenceStorer, n plumbing.ReferenceName) (*plumbing.Reference, error) {
r, err := s.Reference(n)
if err != nil || r == nil {
return r, err
}
return resolveReference(s, r, 0)
}
func resolveReference(s ReferenceStorer, r *plumbing.Reference, recursion int) (*plumbing.Reference, error) {
if r.Type() != plumbing.SymbolicReference {
return r, nil
}
if recursion > MaxResolveRecursion {
return nil, ErrMaxResolveRecursion
}
t, err := s.Reference(r.Target())
if err != nil {
return nil, err
}
recursion++
return resolveReference(s, t, recursion)
}
go-git-5.13.2/plumbing/storer/reference_test.go 0000664 0000000 0000000 00000011161 14744245500 0021454 0 ustar 00root root 0000000 0000000 package storer
import (
"errors"
"io"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
type ReferenceSuite struct{}
var _ = Suite(&ReferenceSuite{})
func (s *ReferenceSuite) TestReferenceSliceIterNext(c *C) {
slice := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("foo", "foo"),
plumbing.NewReferenceFromStrings("bar", "bar"),
}
i := NewReferenceSliceIter(slice)
foo, err := i.Next()
c.Assert(err, IsNil)
c.Assert(foo == slice[0], Equals, true)
bar, err := i.Next()
c.Assert(err, IsNil)
c.Assert(bar == slice[1], Equals, true)
empty, err := i.Next()
c.Assert(err, Equals, io.EOF)
c.Assert(empty, IsNil)
}
func (s *ReferenceSuite) TestReferenceSliceIterForEach(c *C) {
slice := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("foo", "foo"),
plumbing.NewReferenceFromStrings("bar", "bar"),
}
i := NewReferenceSliceIter(slice)
var count int
i.ForEach(func(r *plumbing.Reference) error {
c.Assert(r == slice[count], Equals, true)
count++
return nil
})
c.Assert(count, Equals, 2)
}
func (s *ReferenceSuite) TestReferenceSliceIterForEachError(c *C) {
slice := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("foo", "foo"),
plumbing.NewReferenceFromStrings("bar", "bar"),
}
i := NewReferenceSliceIter(slice)
var count int
exampleErr := errors.New("SOME ERROR")
err := i.ForEach(func(r *plumbing.Reference) error {
c.Assert(r == slice[count], Equals, true)
count++
if count == 2 {
return exampleErr
}
return nil
})
c.Assert(err, Equals, exampleErr)
c.Assert(count, Equals, 2)
}
func (s *ReferenceSuite) TestReferenceSliceIterForEachStop(c *C) {
slice := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("foo", "foo"),
plumbing.NewReferenceFromStrings("bar", "bar"),
}
i := NewReferenceSliceIter(slice)
var count int
i.ForEach(func(r *plumbing.Reference) error {
c.Assert(r == slice[count], Equals, true)
count++
return ErrStop
})
c.Assert(count, Equals, 1)
}
func (s *ReferenceSuite) TestReferenceFilteredIterNext(c *C) {
slice := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("foo", "foo"),
plumbing.NewReferenceFromStrings("bar", "bar"),
}
i := NewReferenceFilteredIter(func(r *plumbing.Reference) bool {
return r.Name() == "bar"
}, NewReferenceSliceIter(slice))
foo, err := i.Next()
c.Assert(err, IsNil)
c.Assert(foo == slice[0], Equals, false)
c.Assert(foo == slice[1], Equals, true)
empty, err := i.Next()
c.Assert(err, Equals, io.EOF)
c.Assert(empty, IsNil)
}
func (s *ReferenceSuite) TestReferenceFilteredIterForEach(c *C) {
slice := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("foo", "foo"),
plumbing.NewReferenceFromStrings("bar", "bar"),
}
i := NewReferenceFilteredIter(func(r *plumbing.Reference) bool {
return r.Name() == "bar"
}, NewReferenceSliceIter(slice))
var count int
i.ForEach(func(r *plumbing.Reference) error {
c.Assert(r == slice[1], Equals, true)
count++
return nil
})
c.Assert(count, Equals, 1)
}
func (s *ReferenceSuite) TestReferenceFilteredIterError(c *C) {
slice := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("foo", "foo"),
plumbing.NewReferenceFromStrings("bar", "bar"),
}
i := NewReferenceFilteredIter(func(r *plumbing.Reference) bool {
return r.Name() == "bar"
}, NewReferenceSliceIter(slice))
var count int
exampleErr := errors.New("SOME ERROR")
err := i.ForEach(func(r *plumbing.Reference) error {
c.Assert(r == slice[1], Equals, true)
count++
if count == 1 {
return exampleErr
}
return nil
})
c.Assert(err, Equals, exampleErr)
c.Assert(count, Equals, 1)
}
func (s *ReferenceSuite) TestReferenceFilteredIterForEachStop(c *C) {
slice := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("foo", "foo"),
plumbing.NewReferenceFromStrings("bar", "bar"),
}
i := NewReferenceFilteredIter(func(r *plumbing.Reference) bool {
return r.Name() == "bar"
}, NewReferenceSliceIter(slice))
var count int
i.ForEach(func(r *plumbing.Reference) error {
c.Assert(r == slice[1], Equals, true)
count++
return ErrStop
})
c.Assert(count, Equals, 1)
}
func (s *ReferenceSuite) TestMultiReferenceIterForEach(c *C) {
i := NewMultiReferenceIter(
[]ReferenceIter{
NewReferenceSliceIter([]*plumbing.Reference{
plumbing.NewReferenceFromStrings("foo", "foo"),
}),
NewReferenceSliceIter([]*plumbing.Reference{
plumbing.NewReferenceFromStrings("bar", "bar"),
}),
},
)
var result []string
err := i.ForEach(func(r *plumbing.Reference) error {
result = append(result, r.Name().String())
return nil
})
c.Assert(err, IsNil)
c.Assert(result, HasLen, 2)
c.Assert(result, DeepEquals, []string{"foo", "bar"})
}
go-git-5.13.2/plumbing/storer/shallow.go 0000664 0000000 0000000 00000000476 14744245500 0020137 0 ustar 00root root 0000000 0000000 package storer
import "github.com/go-git/go-git/v5/plumbing"
// ShallowStorer is a storage of references to shallow commits by hash,
// meaning that these commits have missing parents because of a shallow fetch.
type ShallowStorer interface {
SetShallow([]plumbing.Hash) error
Shallow() ([]plumbing.Hash, error)
}
go-git-5.13.2/plumbing/storer/storer.go 0000664 0000000 0000000 00000000631 14744245500 0017775 0 ustar 00root root 0000000 0000000 package storer
// Storer is a basic storer for encoded objects and references.
type Storer interface {
EncodedObjectStorer
ReferenceStorer
}
// Initializer should be implemented by storers that require to perform any
// operation when creating a new repository (i.e. git init).
type Initializer interface {
// Init performs initialization of the storer and returns the error, if
// any.
Init() error
}
go-git-5.13.2/plumbing/transport/ 0000775 0000000 0000000 00000000000 14744245500 0016646 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/client/ 0000775 0000000 0000000 00000000000 14744245500 0020124 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/client/client.go 0000664 0000000 0000000 00000002702 14744245500 0021732 0 ustar 00root root 0000000 0000000 // Package client contains helper function to deal with the different client
// protocols.
package client
import (
"fmt"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/file"
"github.com/go-git/go-git/v5/plumbing/transport/git"
"github.com/go-git/go-git/v5/plumbing/transport/http"
"github.com/go-git/go-git/v5/plumbing/transport/ssh"
)
// Protocols are the protocols supported by default.
var Protocols = map[string]transport.Transport{
"http": http.DefaultClient,
"https": http.DefaultClient,
"ssh": ssh.DefaultClient,
"git": git.DefaultClient,
"file": file.DefaultClient,
}
// InstallProtocol adds or modifies an existing protocol.
func InstallProtocol(scheme string, c transport.Transport) {
if c == nil {
delete(Protocols, scheme)
return
}
Protocols[scheme] = c
}
// NewClient returns the appropriate client among of the set of known protocols:
// http://, https://, ssh:// and file://.
// See `InstallProtocol` to add or modify protocols.
func NewClient(endpoint *transport.Endpoint) (transport.Transport, error) {
return getTransport(endpoint)
}
func getTransport(endpoint *transport.Endpoint) (transport.Transport, error) {
f, ok := Protocols[endpoint.Protocol]
if !ok {
return nil, fmt.Errorf("unsupported scheme %q", endpoint.Protocol)
}
if f == nil {
return nil, fmt.Errorf("malformed client for scheme %q, client is defined as nil", endpoint.Protocol)
}
return f, nil
}
go-git-5.13.2/plumbing/transport/client/client_test.go 0000664 0000000 0000000 00000002777 14744245500 0023005 0 ustar 00root root 0000000 0000000 package client
import (
"net/http"
"testing"
"github.com/go-git/go-git/v5/plumbing/transport"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type ClientSuite struct{}
var _ = Suite(&ClientSuite{})
func (s *ClientSuite) TestNewClientSSH(c *C) {
e, err := transport.NewEndpoint("ssh://github.com/src-d/go-git")
c.Assert(err, IsNil)
output, err := NewClient(e)
c.Assert(err, IsNil)
c.Assert(output, NotNil)
}
func (s *ClientSuite) TestNewClientUnknown(c *C) {
e, err := transport.NewEndpoint("unknown://github.com/src-d/go-git")
c.Assert(err, IsNil)
_, err = NewClient(e)
c.Assert(err, NotNil)
}
func (s *ClientSuite) TestNewClientNil(c *C) {
Protocols["newscheme"] = nil
e, err := transport.NewEndpoint("newscheme://github.com/src-d/go-git")
c.Assert(err, IsNil)
_, err = NewClient(e)
c.Assert(err, NotNil)
}
func (s *ClientSuite) TestInstallProtocol(c *C) {
InstallProtocol("newscheme", &dummyClient{})
c.Assert(Protocols["newscheme"], NotNil)
}
func (s *ClientSuite) TestInstallProtocolNilValue(c *C) {
InstallProtocol("newscheme", &dummyClient{})
InstallProtocol("newscheme", nil)
_, ok := Protocols["newscheme"]
c.Assert(ok, Equals, false)
}
type dummyClient struct {
*http.Client
}
func (*dummyClient) NewUploadPackSession(*transport.Endpoint, transport.AuthMethod) (
transport.UploadPackSession, error) {
return nil, nil
}
func (*dummyClient) NewReceivePackSession(*transport.Endpoint, transport.AuthMethod) (
transport.ReceivePackSession, error) {
return nil, nil
}
go-git-5.13.2/plumbing/transport/client/example_test.go 0000664 0000000 0000000 00000000756 14744245500 0023155 0 ustar 00root root 0000000 0000000 package client_test
import (
"crypto/tls"
"net/http"
"github.com/go-git/go-git/v5/plumbing/transport/client"
githttp "github.com/go-git/go-git/v5/plumbing/transport/http"
)
func ExampleInstallProtocol() {
// Create custom net/http client that.
httpClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
// Install it as default client for https URLs.
client.InstallProtocol("https", githttp.NewClient(httpClient))
}
go-git-5.13.2/plumbing/transport/common.go 0000664 0000000 0000000 00000020262 14744245500 0020467 0 ustar 00root root 0000000 0000000 // Package transport includes the implementation for different transport
// protocols.
//
// `Client` can be used to fetch and send packfiles to a git server.
// The `client` package provides higher level functions to instantiate the
// appropriate `Client` based on the repository URL.
//
// go-git supports HTTP and SSH (see `Protocols`), but you can also install
// your own protocols (see the `client` package).
//
// Each protocol has its own implementation of `Client`, but you should
// generally not use them directly, use `client.NewClient` instead.
package transport
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"net/url"
"path/filepath"
"strconv"
"strings"
giturl "github.com/go-git/go-git/v5/internal/url"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
)
var (
ErrRepositoryNotFound = errors.New("repository not found")
ErrEmptyRemoteRepository = errors.New("remote repository is empty")
ErrAuthenticationRequired = errors.New("authentication required")
ErrAuthorizationFailed = errors.New("authorization failed")
ErrEmptyUploadPackRequest = errors.New("empty git-upload-pack given")
ErrInvalidAuthMethod = errors.New("invalid auth method")
ErrAlreadyConnected = errors.New("session already established")
)
const (
UploadPackServiceName = "git-upload-pack"
ReceivePackServiceName = "git-receive-pack"
)
// Transport can initiate git-upload-pack and git-receive-pack processes.
// It is implemented both by the client and the server, making this a RPC.
type Transport interface {
// NewUploadPackSession starts a git-upload-pack session for an endpoint.
NewUploadPackSession(*Endpoint, AuthMethod) (UploadPackSession, error)
// NewReceivePackSession starts a git-receive-pack session for an endpoint.
NewReceivePackSession(*Endpoint, AuthMethod) (ReceivePackSession, error)
}
type Session interface {
// AdvertisedReferences retrieves the advertised references for a
// repository.
// If the repository does not exist, returns ErrRepositoryNotFound.
// If the repository exists, but is empty, returns ErrEmptyRemoteRepository.
AdvertisedReferences() (*packp.AdvRefs, error)
// AdvertisedReferencesContext retrieves the advertised references for a
// repository.
// If the repository does not exist, returns ErrRepositoryNotFound.
// If the repository exists, but is empty, returns ErrEmptyRemoteRepository.
AdvertisedReferencesContext(context.Context) (*packp.AdvRefs, error)
io.Closer
}
type AuthMethod interface {
fmt.Stringer
Name() string
}
// UploadPackSession represents a git-upload-pack session.
// A git-upload-pack session has two steps: reference discovery
// (AdvertisedReferences) and uploading pack (UploadPack).
type UploadPackSession interface {
Session
// UploadPack takes a git-upload-pack request and returns a response,
// including a packfile. Don't be confused by terminology, the client
// side of a git-upload-pack is called git-fetch-pack, although here
// the same interface is used to make it RPC-like.
UploadPack(context.Context, *packp.UploadPackRequest) (*packp.UploadPackResponse, error)
}
// ReceivePackSession represents a git-receive-pack session.
// A git-receive-pack session has two steps: reference discovery
// (AdvertisedReferences) and receiving pack (ReceivePack).
// In that order.
type ReceivePackSession interface {
Session
// ReceivePack sends an update references request and a packfile
// reader and returns a ReportStatus and error. Don't be confused by
// terminology, the client side of a git-receive-pack is called
// git-send-pack, although here the same interface is used to make it
// RPC-like.
ReceivePack(context.Context, *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error)
}
// Endpoint represents a Git URL in any supported protocol.
type Endpoint struct {
// Protocol is the protocol of the endpoint (e.g. git, https, file).
Protocol string
// User is the user.
User string
// Password is the password.
Password string
// Host is the host.
Host string
// Port is the port to connect, if 0 the default port for the given protocol
// will be used.
Port int
// Path is the repository path.
Path string
// InsecureSkipTLS skips ssl verify if protocol is https
InsecureSkipTLS bool
// CaBundle specify additional ca bundle with system cert pool
CaBundle []byte
// Proxy provides info required for connecting to a proxy.
Proxy ProxyOptions
}
type ProxyOptions struct {
URL string
Username string
Password string
}
func (o *ProxyOptions) Validate() error {
if o.URL != "" {
_, err := url.Parse(o.URL)
return err
}
return nil
}
func (o *ProxyOptions) FullURL() (*url.URL, error) {
proxyURL, err := url.Parse(o.URL)
if err != nil {
return nil, err
}
if o.Username != "" {
if o.Password != "" {
proxyURL.User = url.UserPassword(o.Username, o.Password)
} else {
proxyURL.User = url.User(o.Username)
}
}
return proxyURL, nil
}
var defaultPorts = map[string]int{
"http": 80,
"https": 443,
"git": 9418,
"ssh": 22,
}
// String returns a string representation of the Git URL.
func (u *Endpoint) String() string {
var buf bytes.Buffer
if u.Protocol != "" {
buf.WriteString(u.Protocol)
buf.WriteByte(':')
}
if u.Protocol != "" || u.Host != "" || u.User != "" || u.Password != "" {
buf.WriteString("//")
if u.User != "" || u.Password != "" {
buf.WriteString(url.PathEscape(u.User))
if u.Password != "" {
buf.WriteByte(':')
buf.WriteString(url.PathEscape(u.Password))
}
buf.WriteByte('@')
}
if u.Host != "" {
buf.WriteString(u.Host)
if u.Port != 0 {
port, ok := defaultPorts[strings.ToLower(u.Protocol)]
if !ok || ok && port != u.Port {
fmt.Fprintf(&buf, ":%d", u.Port)
}
}
}
}
if u.Path != "" && u.Path[0] != '/' && u.Host != "" {
buf.WriteByte('/')
}
buf.WriteString(u.Path)
return buf.String()
}
func NewEndpoint(endpoint string) (*Endpoint, error) {
if e, ok := parseSCPLike(endpoint); ok {
return e, nil
}
if e, ok := parseFile(endpoint); ok {
return e, nil
}
return parseURL(endpoint)
}
func parseURL(endpoint string) (*Endpoint, error) {
u, err := url.Parse(endpoint)
if err != nil {
return nil, err
}
if !u.IsAbs() {
return nil, plumbing.NewPermanentError(fmt.Errorf(
"invalid endpoint: %s", endpoint,
))
}
var user, pass string
if u.User != nil {
user = u.User.Username()
pass, _ = u.User.Password()
}
host := u.Hostname()
if strings.Contains(host, ":") {
// IPv6 address
host = "[" + host + "]"
}
return &Endpoint{
Protocol: u.Scheme,
User: user,
Password: pass,
Host: host,
Port: getPort(u),
Path: getPath(u),
}, nil
}
func getPort(u *url.URL) int {
p := u.Port()
if p == "" {
return 0
}
i, err := strconv.Atoi(p)
if err != nil {
return 0
}
return i
}
func getPath(u *url.URL) string {
var res string = u.Path
if u.RawQuery != "" {
res += "?" + u.RawQuery
}
if u.Fragment != "" {
res += "#" + u.Fragment
}
return res
}
func parseSCPLike(endpoint string) (*Endpoint, bool) {
if giturl.MatchesScheme(endpoint) || !giturl.MatchesScpLike(endpoint) {
return nil, false
}
user, host, portStr, path := giturl.FindScpLikeComponents(endpoint)
port, err := strconv.Atoi(portStr)
if err != nil {
port = 22
}
return &Endpoint{
Protocol: "ssh",
User: user,
Host: host,
Port: port,
Path: path,
}, true
}
func parseFile(endpoint string) (*Endpoint, bool) {
if giturl.MatchesScheme(endpoint) {
return nil, false
}
path, err := filepath.Abs(endpoint)
if err != nil {
return nil, false
}
return &Endpoint{
Protocol: "file",
Path: path,
}, true
}
// UnsupportedCapabilities are the capabilities not supported by any client
// implementation
var UnsupportedCapabilities = []capability.Capability{
capability.MultiACK,
capability.MultiACKDetailed,
capability.ThinPack,
}
// FilterUnsupportedCapabilities it filter out all the UnsupportedCapabilities
// from a capability.List, the intended usage is on the client implementation
// to filter the capabilities from an AdvRefs message.
func FilterUnsupportedCapabilities(list *capability.List) {
for _, c := range UnsupportedCapabilities {
list.Delete(c)
}
}
go-git-5.13.2/plumbing/transport/common_test.go 0000664 0000000 0000000 00000017105 14744245500 0021530 0 ustar 00root root 0000000 0000000 package transport
import (
"fmt"
"net/url"
"os"
"path/filepath"
"runtime"
"testing"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type SuiteCommon struct{}
var _ = Suite(&SuiteCommon{})
func (s *SuiteCommon) TestNewEndpointHTTP(c *C) {
e, err := NewEndpoint("http://git:pass@github.com/user/repository.git?foo#bar")
c.Assert(err, IsNil)
c.Assert(e.Protocol, Equals, "http")
c.Assert(e.User, Equals, "git")
c.Assert(e.Password, Equals, "pass")
c.Assert(e.Host, Equals, "github.com")
c.Assert(e.Port, Equals, 0)
c.Assert(e.Path, Equals, "/user/repository.git?foo#bar")
c.Assert(e.String(), Equals, "http://git:pass@github.com/user/repository.git?foo#bar")
}
func (s *SuiteCommon) TestNewEndpointPorts(c *C) {
e, err := NewEndpoint("http://git:pass@github.com:8080/user/repository.git?foo#bar")
c.Assert(err, IsNil)
c.Assert(e.String(), Equals, "http://git:pass@github.com:8080/user/repository.git?foo#bar")
e, err = NewEndpoint("https://git:pass@github.com:443/user/repository.git?foo#bar")
c.Assert(err, IsNil)
c.Assert(e.String(), Equals, "https://git:pass@github.com/user/repository.git?foo#bar")
e, err = NewEndpoint("ssh://git:pass@github.com:22/user/repository.git?foo#bar")
c.Assert(err, IsNil)
c.Assert(e.String(), Equals, "ssh://git:pass@github.com/user/repository.git?foo#bar")
e, err = NewEndpoint("git://github.com:9418/user/repository.git?foo#bar")
c.Assert(err, IsNil)
c.Assert(e.String(), Equals, "git://github.com/user/repository.git?foo#bar")
}
func (s *SuiteCommon) TestNewEndpointSSH(c *C) {
e, err := NewEndpoint("ssh://git@github.com/user/repository.git")
c.Assert(err, IsNil)
c.Assert(e.Protocol, Equals, "ssh")
c.Assert(e.User, Equals, "git")
c.Assert(e.Password, Equals, "")
c.Assert(e.Host, Equals, "github.com")
c.Assert(e.Port, Equals, 0)
c.Assert(e.Path, Equals, "/user/repository.git")
c.Assert(e.String(), Equals, "ssh://git@github.com/user/repository.git")
}
func (s *SuiteCommon) TestNewEndpointSSHNoUser(c *C) {
e, err := NewEndpoint("ssh://github.com/user/repository.git")
c.Assert(err, IsNil)
c.Assert(e.Protocol, Equals, "ssh")
c.Assert(e.User, Equals, "")
c.Assert(e.Password, Equals, "")
c.Assert(e.Host, Equals, "github.com")
c.Assert(e.Port, Equals, 0)
c.Assert(e.Path, Equals, "/user/repository.git")
c.Assert(e.String(), Equals, "ssh://github.com/user/repository.git")
}
func (s *SuiteCommon) TestNewEndpointSSHWithPort(c *C) {
e, err := NewEndpoint("ssh://git@github.com:777/user/repository.git")
c.Assert(err, IsNil)
c.Assert(e.Protocol, Equals, "ssh")
c.Assert(e.User, Equals, "git")
c.Assert(e.Password, Equals, "")
c.Assert(e.Host, Equals, "github.com")
c.Assert(e.Port, Equals, 777)
c.Assert(e.Path, Equals, "/user/repository.git")
c.Assert(e.String(), Equals, "ssh://git@github.com:777/user/repository.git")
}
func (s *SuiteCommon) TestNewEndpointSCPLike(c *C) {
e, err := NewEndpoint("git@github.com:user/repository.git")
c.Assert(err, IsNil)
c.Assert(e.Protocol, Equals, "ssh")
c.Assert(e.User, Equals, "git")
c.Assert(e.Password, Equals, "")
c.Assert(e.Host, Equals, "github.com")
c.Assert(e.Port, Equals, 22)
c.Assert(e.Path, Equals, "user/repository.git")
c.Assert(e.String(), Equals, "ssh://git@github.com/user/repository.git")
}
func (s *SuiteCommon) TestNewEndpointSCPLikeWithNumericPath(c *C) {
e, err := NewEndpoint("git@github.com:9999/user/repository.git")
c.Assert(err, IsNil)
c.Assert(e.Protocol, Equals, "ssh")
c.Assert(e.User, Equals, "git")
c.Assert(e.Password, Equals, "")
c.Assert(e.Host, Equals, "github.com")
c.Assert(e.Port, Equals, 22)
c.Assert(e.Path, Equals, "9999/user/repository.git")
c.Assert(e.String(), Equals, "ssh://git@github.com/9999/user/repository.git")
}
func (s *SuiteCommon) TestNewEndpointSCPLikeWithPort(c *C) {
e, err := NewEndpoint("git@github.com:8080:9999/user/repository.git")
c.Assert(err, IsNil)
c.Assert(e.Protocol, Equals, "ssh")
c.Assert(e.User, Equals, "git")
c.Assert(e.Password, Equals, "")
c.Assert(e.Host, Equals, "github.com")
c.Assert(e.Port, Equals, 8080)
c.Assert(e.Path, Equals, "9999/user/repository.git")
c.Assert(e.String(), Equals, "ssh://git@github.com:8080/9999/user/repository.git")
}
func (s *SuiteCommon) TestNewEndpointFileAbs(c *C) {
var err error
abs := "/foo.git"
if runtime.GOOS == "windows" {
abs, err = filepath.Abs(abs)
c.Assert(err, IsNil)
}
e, err := NewEndpoint("/foo.git")
c.Assert(err, IsNil)
c.Assert(e.Protocol, Equals, "file")
c.Assert(e.User, Equals, "")
c.Assert(e.Password, Equals, "")
c.Assert(e.Host, Equals, "")
c.Assert(e.Port, Equals, 0)
c.Assert(e.Path, Equals, abs)
c.Assert(e.String(), Equals, "file://"+abs)
}
func (s *SuiteCommon) TestNewEndpointFileRel(c *C) {
abs, err := filepath.Abs("foo.git")
c.Assert(err, IsNil)
e, err := NewEndpoint("foo.git")
c.Assert(err, IsNil)
c.Assert(e.Protocol, Equals, "file")
c.Assert(e.User, Equals, "")
c.Assert(e.Password, Equals, "")
c.Assert(e.Host, Equals, "")
c.Assert(e.Port, Equals, 0)
c.Assert(e.Path, Equals, abs)
c.Assert(e.String(), Equals, "file://"+abs)
}
func (s *SuiteCommon) TestNewEndpointFileWindows(c *C) {
abs := "C:\\foo.git"
if runtime.GOOS != "windows" {
cwd, err := os.Getwd()
c.Assert(err, IsNil)
abs = filepath.Join(cwd, "C:\\foo.git")
}
e, err := NewEndpoint("C:\\foo.git")
c.Assert(err, IsNil)
c.Assert(e.Protocol, Equals, "file")
c.Assert(e.User, Equals, "")
c.Assert(e.Password, Equals, "")
c.Assert(e.Host, Equals, "")
c.Assert(e.Port, Equals, 0)
c.Assert(e.Path, Equals, abs)
c.Assert(e.String(), Equals, "file://"+abs)
}
func (s *SuiteCommon) TestNewEndpointFileURL(c *C) {
e, err := NewEndpoint("file:///foo.git")
c.Assert(err, IsNil)
c.Assert(e.Protocol, Equals, "file")
c.Assert(e.User, Equals, "")
c.Assert(e.Password, Equals, "")
c.Assert(e.Host, Equals, "")
c.Assert(e.Port, Equals, 0)
c.Assert(e.Path, Equals, "/foo.git")
c.Assert(e.String(), Equals, "file:///foo.git")
}
func (s *SuiteCommon) TestValidEndpoint(c *C) {
user := "person@mail.com"
pass := " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
e, err := NewEndpoint(fmt.Sprintf(
"http://%s:%s@github.com/user/repository.git",
url.PathEscape(user),
url.PathEscape(pass),
))
c.Assert(err, IsNil)
c.Assert(e, NotNil)
c.Assert(e.User, Equals, user)
c.Assert(e.Password, Equals, pass)
c.Assert(e.Host, Equals, "github.com")
c.Assert(e.Path, Equals, "/user/repository.git")
c.Assert(e.String(), Equals, "http://person@mail.com:%20%21%22%23$%25&%27%28%29%2A+%2C-.%2F:%3B%3C=%3E%3F@%5B%5C%5D%5E_%60%7B%7C%7D~@github.com/user/repository.git")
}
func (s *SuiteCommon) TestNewEndpointInvalidURL(c *C) {
e, err := NewEndpoint("http://\\")
c.Assert(err, NotNil)
c.Assert(e, IsNil)
}
func (s *SuiteCommon) TestFilterUnsupportedCapabilities(c *C) {
l := capability.NewList()
l.Set(capability.MultiACK)
FilterUnsupportedCapabilities(l)
c.Assert(l.Supports(capability.MultiACK), Equals, false)
}
func (s *SuiteCommon) TestNewEndpointIPv6(c *C) {
// see issue https://github.com/go-git/go-git/issues/740
//
// IPv6 host names are not being properly handled, which results in unhelpful
// error messages depending on the format used.
//
e, err := NewEndpoint("http://[::1]:8080/foo.git")
c.Assert(err, IsNil)
c.Assert(e.Host, Equals, "[::1]")
c.Assert(e.String(), Equals, "http://[::1]:8080/foo.git")
}
func FuzzNewEndpoint(f *testing.F) {
f.Add("http://127.0.0.1:8080/foo.git")
f.Add("http://[::1]:8080/foo.git")
f.Add("file:///foo.git")
f.Add("ssh://git@github.com/user/repository.git")
f.Add("git@github.com:user/repository.git")
f.Fuzz(func(t *testing.T, input string) {
NewEndpoint(input)
})
}
go-git-5.13.2/plumbing/transport/file/ 0000775 0000000 0000000 00000000000 14744245500 0017565 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/file/client.go 0000664 0000000 0000000 00000007117 14744245500 0021400 0 ustar 00root root 0000000 0000000 // Package file implements the file transport protocol.
package file
import (
"bufio"
"errors"
"io"
"os"
"path/filepath"
"runtime"
"strings"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/internal/common"
"golang.org/x/sys/execabs"
)
// DefaultClient is the default local client.
var DefaultClient = NewClient(
transport.UploadPackServiceName,
transport.ReceivePackServiceName,
)
type runner struct {
UploadPackBin string
ReceivePackBin string
}
// NewClient returns a new local client using the given git-upload-pack and
// git-receive-pack binaries.
func NewClient(uploadPackBin, receivePackBin string) transport.Transport {
return common.NewClient(&runner{
UploadPackBin: uploadPackBin,
ReceivePackBin: receivePackBin,
})
}
func prefixExecPath(cmd string) (string, error) {
// Use `git --exec-path` to find the exec path.
execCmd := execabs.Command("git", "--exec-path")
stdout, err := execCmd.StdoutPipe()
if err != nil {
return "", err
}
stdoutBuf := bufio.NewReader(stdout)
err = execCmd.Start()
if err != nil {
return "", err
}
execPathBytes, isPrefix, err := stdoutBuf.ReadLine()
if err != nil {
return "", err
}
if isPrefix {
return "", errors.New("couldn't read exec-path line all at once")
}
err = execCmd.Wait()
if err != nil {
return "", err
}
execPath := string(execPathBytes)
execPath = strings.TrimSpace(execPath)
cmd = filepath.Join(execPath, cmd)
// Make sure it actually exists.
_, err = execabs.LookPath(cmd)
if err != nil {
return "", err
}
return cmd, nil
}
func (r *runner) Command(cmd string, ep *transport.Endpoint, auth transport.AuthMethod,
) (common.Command, error) {
switch cmd {
case transport.UploadPackServiceName:
cmd = r.UploadPackBin
case transport.ReceivePackServiceName:
cmd = r.ReceivePackBin
}
_, err := execabs.LookPath(cmd)
if err != nil {
if e, ok := err.(*execabs.Error); ok && e.Err == execabs.ErrNotFound {
cmd, err = prefixExecPath(cmd)
if err != nil {
return nil, err
}
} else {
return nil, err
}
}
return &command{cmd: execabs.Command(cmd, adjustPathForWindows(ep.Path))}, nil
}
func isDriveLetter(c byte) bool {
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
}
// On Windows, the path that results from a file: URL has a leading slash. This
// has to be removed if there's a drive letter
func adjustPathForWindows(p string) string {
if runtime.GOOS != "windows" {
return p
}
if len(p) >= 3 && p[0] == '/' && isDriveLetter(p[1]) && p[2] == ':' {
return p[1:]
}
return p
}
type command struct {
cmd *execabs.Cmd
stderrCloser io.Closer
closed bool
}
func (c *command) Start() error {
return c.cmd.Start()
}
func (c *command) StderrPipe() (io.Reader, error) {
// Pipe returned by Command.StderrPipe has a race with Read + Command.Wait.
// We use an io.Pipe and close it after the command finishes.
r, w := io.Pipe()
c.cmd.Stderr = w
c.stderrCloser = r
return r, nil
}
func (c *command) StdinPipe() (io.WriteCloser, error) {
return c.cmd.StdinPipe()
}
func (c *command) StdoutPipe() (io.Reader, error) {
return c.cmd.StdoutPipe()
}
func (c *command) Kill() error {
c.cmd.Process.Kill()
return c.Close()
}
// Close waits for the command to exit.
func (c *command) Close() error {
if c.closed {
return nil
}
defer func() {
c.closed = true
_ = c.stderrCloser.Close()
}()
err := c.cmd.Wait()
if _, ok := err.(*os.PathError); ok {
return nil
}
// When a repository does not exist, the command exits with code 128.
if _, ok := err.(*execabs.ExitError); ok {
return nil
}
return err
}
go-git-5.13.2/plumbing/transport/file/client_test.go 0000664 0000000 0000000 00000002601 14744245500 0022430 0 ustar 00root root 0000000 0000000 package file
import (
"io"
"os"
"path/filepath"
"strings"
"testing"
"github.com/go-git/go-git/v5/plumbing/transport"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type ClientSuite struct {
CommonSuite
}
var _ = Suite(&ClientSuite{})
func (s *ClientSuite) TestCommand(c *C) {
runner := &runner{
UploadPackBin: transport.UploadPackServiceName,
ReceivePackBin: transport.ReceivePackServiceName,
}
ep, err := transport.NewEndpoint(filepath.Join("fake", "repo"))
c.Assert(err, IsNil)
var emptyAuth transport.AuthMethod
_, err = runner.Command("git-receive-pack", ep, emptyAuth)
c.Assert(err, IsNil)
// Make sure we get an error for one that doesn't exist.
_, err = runner.Command("git-fake-command", ep, emptyAuth)
c.Assert(err, NotNil)
}
const bareConfig = `[core]
repositoryformatversion = 0
filemode = true
bare = true`
func prepareRepo(c *C, path string) *transport.Endpoint {
ep, err := transport.NewEndpoint(path)
c.Assert(err, IsNil)
// git-receive-pack refuses to update refs/heads/master on non-bare repo
// so we ensure bare repo config.
config := filepath.Join(path, "config")
if _, err := os.Stat(config); err == nil {
f, err := os.OpenFile(config, os.O_TRUNC|os.O_WRONLY, 0)
c.Assert(err, IsNil)
content := strings.NewReader(bareConfig)
_, err = io.Copy(f, content)
c.Assert(err, IsNil)
c.Assert(f.Close(), IsNil)
}
return ep
}
go-git-5.13.2/plumbing/transport/file/common_test.go 0000664 0000000 0000000 00000001740 14744245500 0022445 0 ustar 00root root 0000000 0000000 package file
import (
"os"
"os/exec"
"path/filepath"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type CommonSuite struct {
fixtures.Suite
ReceivePackBin string
UploadPackBin string
tmpDir string // to be removed at teardown
}
var _ = Suite(&CommonSuite{})
func (s *CommonSuite) SetUpSuite(c *C) {
if err := exec.Command("git", "--version").Run(); err != nil {
c.Skip("git command not found")
}
var err error
s.tmpDir, err = os.MkdirTemp(c.MkDir(), "")
c.Assert(err, IsNil)
s.ReceivePackBin = filepath.Join(s.tmpDir, "git-receive-pack")
s.UploadPackBin = filepath.Join(s.tmpDir, "git-upload-pack")
bin := filepath.Join(s.tmpDir, "go-git")
cmd := exec.Command("go", "build", "-o", bin)
cmd.Dir = "../../../cli/go-git"
c.Assert(cmd.Run(), IsNil)
c.Assert(os.Symlink(bin, s.ReceivePackBin), IsNil)
c.Assert(os.Symlink(bin, s.UploadPackBin), IsNil)
}
func (s *CommonSuite) TearDownSuite(c *C) {
defer s.Suite.TearDownSuite(c)
}
go-git-5.13.2/plumbing/transport/file/receive_pack_test.go 0000664 0000000 0000000 00000003531 14744245500 0023575 0 ustar 00root root 0000000 0000000 package file
import (
"os"
"github.com/go-git/go-git/v5/plumbing/transport/test"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type ReceivePackSuite struct {
CommonSuite
test.ReceivePackSuite
}
var _ = Suite(&ReceivePackSuite{})
func (s *ReceivePackSuite) SetUpSuite(c *C) {
s.CommonSuite.SetUpSuite(c)
s.ReceivePackSuite.Client = DefaultClient
}
func (s *ReceivePackSuite) SetUpTest(c *C) {
fixture := fixtures.Basic().One()
path := fixture.DotGit().Root()
s.Endpoint = prepareRepo(c, path)
fixture = fixtures.ByTag("empty").One()
path = fixture.DotGit().Root()
s.EmptyEndpoint = prepareRepo(c, path)
s.NonExistentEndpoint = prepareRepo(c, "/non-existent")
}
func (s *ReceivePackSuite) TearDownTest(c *C) {
s.Suite.TearDownSuite(c)
}
// TODO: fix test
func (s *ReceivePackSuite) TestCommandNoOutput(c *C) {
c.Skip("failing test")
if _, err := os.Stat("/bin/true"); os.IsNotExist(err) {
c.Skip("/bin/true not found")
}
client := NewClient("true", "true")
session, err := client.NewReceivePackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
ar, err := session.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(ar, IsNil)
}
func (s *ReceivePackSuite) TestMalformedInputNoErrors(c *C) {
if _, err := os.Stat("/usr/bin/yes"); os.IsNotExist(err) {
c.Skip("/usr/bin/yes not found")
}
client := NewClient("yes", "yes")
session, err := client.NewReceivePackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
ar, err := session.AdvertisedReferences()
c.Assert(err, NotNil)
c.Assert(ar, IsNil)
}
func (s *ReceivePackSuite) TestNonExistentCommand(c *C) {
cmd := "/non-existent-git"
client := NewClient(cmd, cmd)
session, err := client.NewReceivePackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, ErrorMatches, ".*(no such file or directory.*|.*file does not exist)*.")
c.Assert(session, IsNil)
}
go-git-5.13.2/plumbing/transport/file/server.go 0000664 0000000 0000000 00000002624 14744245500 0021426 0 ustar 00root root 0000000 0000000 package file
import (
"fmt"
"os"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/internal/common"
"github.com/go-git/go-git/v5/plumbing/transport/server"
"github.com/go-git/go-git/v5/utils/ioutil"
)
// ServeUploadPack serves a git-upload-pack request using standard output, input
// and error. This is meant to be used when implementing a git-upload-pack
// command.
func ServeUploadPack(path string) error {
ep, err := transport.NewEndpoint(path)
if err != nil {
return err
}
// TODO: define and implement a server-side AuthMethod
s, err := server.DefaultServer.NewUploadPackSession(ep, nil)
if err != nil {
return fmt.Errorf("error creating session: %s", err)
}
return common.ServeUploadPack(srvCmd, s)
}
// ServeReceivePack serves a git-receive-pack request using standard output,
// input and error. This is meant to be used when implementing a
// git-receive-pack command.
func ServeReceivePack(path string) error {
ep, err := transport.NewEndpoint(path)
if err != nil {
return err
}
// TODO: define and implement a server-side AuthMethod
s, err := server.DefaultServer.NewReceivePackSession(ep, nil)
if err != nil {
return fmt.Errorf("error creating session: %s", err)
}
return common.ServeReceivePack(srvCmd, s)
}
var srvCmd = common.ServerCommand{
Stdin: os.Stdin,
Stdout: ioutil.WriteNopCloser(os.Stdout),
Stderr: os.Stderr,
}
go-git-5.13.2/plumbing/transport/file/server_test.go 0000664 0000000 0000000 00000003432 14744245500 0022463 0 ustar 00root root 0000000 0000000 package file
import (
"os"
"os/exec"
"github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type ServerSuite struct {
CommonSuite
RemoteName string
SrcPath string
DstPath string
}
var _ = Suite(&ServerSuite{})
func (s *ServerSuite) SetUpSuite(c *C) {
s.CommonSuite.SetUpSuite(c)
s.RemoteName = "test"
fixture := fixtures.Basic().One()
s.SrcPath = fixture.DotGit().Root()
fixture = fixtures.ByTag("empty").One()
s.DstPath = fixture.DotGit().Root()
cmd := exec.Command("git", "remote", "add", s.RemoteName, s.DstPath)
cmd.Dir = s.SrcPath
c.Assert(cmd.Run(), IsNil)
}
func (s *ServerSuite) TestPush(c *C) {
if !s.checkExecPerm(c) {
c.Skip("go-git binary has not execution permissions")
}
// git <2.0 cannot push to an empty repository without a refspec.
cmd := exec.Command("git", "push",
"--receive-pack", s.ReceivePackBin,
s.RemoteName, "refs/heads/*:refs/heads/*",
)
cmd.Dir = s.SrcPath
cmd.Env = os.Environ()
cmd.Env = append(cmd.Env, "GIT_TRACE=true", "GIT_TRACE_PACKET=true")
out, err := cmd.CombinedOutput()
c.Assert(err, IsNil, Commentf("combined stdout and stderr:\n%s\n", out))
}
func (s *ServerSuite) TestClone(c *C) {
if !s.checkExecPerm(c) {
c.Skip("go-git binary has not execution permissions")
}
pathToClone := c.MkDir()
cmd := exec.Command("git", "clone",
"--upload-pack", s.UploadPackBin,
s.SrcPath, pathToClone,
)
cmd.Env = os.Environ()
cmd.Env = append(cmd.Env, "GIT_TRACE=true", "GIT_TRACE_PACKET=true")
out, err := cmd.CombinedOutput()
c.Assert(err, IsNil, Commentf("combined stdout and stderr:\n%s\n", out))
}
func (s *ServerSuite) checkExecPerm(c *C) bool {
const userExecPermMask = 0100
info, err := os.Stat(s.ReceivePackBin)
c.Assert(err, IsNil)
return (info.Mode().Perm() & userExecPermMask) == userExecPermMask
}
go-git-5.13.2/plumbing/transport/file/upload_pack_test.go 0000664 0000000 0000000 00000004233 14744245500 0023437 0 ustar 00root root 0000000 0000000 package file
import (
"os"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/test"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type UploadPackSuite struct {
CommonSuite
test.UploadPackSuite
}
var _ = Suite(&UploadPackSuite{})
func (s *UploadPackSuite) SetUpSuite(c *C) {
s.CommonSuite.SetUpSuite(c)
s.UploadPackSuite.Client = DefaultClient
fixture := fixtures.Basic().One()
path := fixture.DotGit().Root()
ep, err := transport.NewEndpoint(path)
c.Assert(err, IsNil)
s.Endpoint = ep
fixture = fixtures.ByTag("empty").One()
path = fixture.DotGit().Root()
ep, err = transport.NewEndpoint(path)
c.Assert(err, IsNil)
s.EmptyEndpoint = ep
ep, err = transport.NewEndpoint("non-existent")
c.Assert(err, IsNil)
s.NonExistentEndpoint = ep
}
// TODO: fix test
func (s *UploadPackSuite) TestCommandNoOutput(c *C) {
c.Skip("failing test")
if _, err := os.Stat("/bin/true"); os.IsNotExist(err) {
c.Skip("/bin/true not found")
}
client := NewClient("true", "true")
session, err := client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
ar, err := session.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(ar, IsNil)
}
func (s *UploadPackSuite) TestMalformedInputNoErrors(c *C) {
if _, err := os.Stat("/usr/bin/yes"); os.IsNotExist(err) {
c.Skip("/usr/bin/yes not found")
}
client := NewClient("yes", "yes")
session, err := client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
ar, err := session.AdvertisedReferences()
c.Assert(err, NotNil)
c.Assert(ar, IsNil)
}
func (s *UploadPackSuite) TestNonExistentCommand(c *C) {
cmd := "/non-existent-git"
client := NewClient(cmd, cmd)
session, err := client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
// Error message is OS-dependant, so do a broad check
c.Assert(err, ErrorMatches, ".*file.*")
c.Assert(session, IsNil)
}
func (s *UploadPackSuite) TestUploadPackWithContextOnRead(c *C) {
// TODO: Fix race condition when Session.Close and the read failed due to a
// canceled context when the packfile is being read.
c.Skip("UploadPack has a race condition when we Close the session")
}
go-git-5.13.2/plumbing/transport/git/ 0000775 0000000 0000000 00000000000 14744245500 0017431 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/git/common.go 0000664 0000000 0000000 00000005021 14744245500 0021246 0 ustar 00root root 0000000 0000000 // Package git implements the git transport protocol.
package git
import (
"io"
"net"
"strconv"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/internal/common"
"github.com/go-git/go-git/v5/utils/ioutil"
)
// DefaultClient is the default git client.
var DefaultClient = common.NewClient(&runner{})
const DefaultPort = 9418
type runner struct{}
// Command returns a new Command for the given cmd in the given Endpoint
func (r *runner) Command(cmd string, ep *transport.Endpoint, auth transport.AuthMethod) (common.Command, error) {
// auth not allowed since git protocol doesn't support authentication
if auth != nil {
return nil, transport.ErrInvalidAuthMethod
}
c := &command{command: cmd, endpoint: ep}
if err := c.connect(); err != nil {
return nil, err
}
return c, nil
}
type command struct {
conn net.Conn
connected bool
command string
endpoint *transport.Endpoint
}
// Start executes the command sending the required message to the TCP connection
func (c *command) Start() error {
req := packp.GitProtoRequest{
RequestCommand: c.command,
Pathname: c.endpoint.Path,
}
host := c.endpoint.Host
if c.endpoint.Port != DefaultPort {
host = net.JoinHostPort(c.endpoint.Host, strconv.Itoa(c.endpoint.Port))
}
req.Host = host
return req.Encode(c.conn)
}
func (c *command) connect() error {
if c.connected {
return transport.ErrAlreadyConnected
}
var err error
c.conn, err = net.Dial("tcp", c.getHostWithPort())
if err != nil {
return err
}
c.connected = true
return nil
}
func (c *command) getHostWithPort() string {
host := c.endpoint.Host
port := c.endpoint.Port
if port <= 0 {
port = DefaultPort
}
return net.JoinHostPort(host, strconv.Itoa(port))
}
// StderrPipe git protocol doesn't have any dedicated error channel
func (c *command) StderrPipe() (io.Reader, error) {
return nil, nil
}
// StdinPipe returns the underlying connection as WriteCloser, wrapped to prevent
// call to the Close function from the connection, a command execution in git
// protocol can't be closed or killed
func (c *command) StdinPipe() (io.WriteCloser, error) {
return ioutil.WriteNopCloser(c.conn), nil
}
// StdoutPipe returns the underlying connection as Reader
func (c *command) StdoutPipe() (io.Reader, error) {
return c.conn, nil
}
// Close closes the TCP connection and connection.
func (c *command) Close() error {
if !c.connected {
return nil
}
c.connected = false
return c.conn.Close()
}
go-git-5.13.2/plumbing/transport/git/common_test.go 0000664 0000000 0000000 00000004643 14744245500 0022316 0 ustar 00root root 0000000 0000000 package git
import (
"bytes"
"fmt"
"net"
"os"
"os/exec"
"path/filepath"
"runtime"
"testing"
"time"
"github.com/go-git/go-git/v5/plumbing/transport"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type BaseSuite struct {
fixtures.Suite
base string
port int
daemon *exec.Cmd
}
func (s *BaseSuite) SetUpTest(c *C) {
if runtime.GOOS == "windows" {
c.Skip(`git for windows has issues with write operations through git:// protocol.
See https://github.com/git-for-windows/git/issues/907`)
}
cmd := exec.Command("git", "daemon", "--help")
output, err := cmd.CombinedOutput()
if err != nil && bytes.Contains(output, []byte("'daemon' is not a git command")) {
c.Fatal("git daemon cannot be found")
}
s.port, err = freePort()
c.Assert(err, IsNil)
s.base, err = os.MkdirTemp(c.MkDir(), fmt.Sprintf("go-git-protocol-%d", s.port))
c.Assert(err, IsNil)
}
func (s *BaseSuite) StartDaemon(c *C) {
s.daemon = exec.Command(
"git",
"daemon",
fmt.Sprintf("--base-path=%s", s.base),
"--export-all",
"--enable=receive-pack",
"--reuseaddr",
fmt.Sprintf("--port=%d", s.port),
// Unless max-connections is limited to 1, a git-receive-pack
// might not be seen by a subsequent operation.
"--max-connections=1",
)
// Environment must be inherited in order to acknowledge GIT_EXEC_PATH if set.
s.daemon.Env = os.Environ()
err := s.daemon.Start()
c.Assert(err, IsNil)
// Connections might be refused if we start sending request too early.
time.Sleep(time.Millisecond * 500)
}
func (s *BaseSuite) newEndpoint(c *C, name string) *transport.Endpoint {
ep, err := transport.NewEndpoint(fmt.Sprintf("git://localhost:%d/%s", s.port, name))
c.Assert(err, IsNil)
return ep
}
func (s *BaseSuite) prepareRepository(c *C, f *fixtures.Fixture, name string) *transport.Endpoint {
fs := f.DotGit()
err := fixtures.EnsureIsBare(fs)
c.Assert(err, IsNil)
path := filepath.Join(s.base, name)
err = os.Rename(fs.Root(), path)
c.Assert(err, IsNil)
return s.newEndpoint(c, name)
}
func (s *BaseSuite) TearDownTest(c *C) {
if s.daemon != nil {
_ = s.daemon.Process.Signal(os.Kill)
_ = s.daemon.Wait()
}
}
func freePort() (int, error) {
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
if err != nil {
return 0, err
}
l, err := net.ListenTCP("tcp", addr)
if err != nil {
return 0, err
}
return l.Addr().(*net.TCPAddr).Port, l.Close()
}
go-git-5.13.2/plumbing/transport/git/receive_pack_test.go 0000664 0000000 0000000 00000001465 14744245500 0023445 0 ustar 00root root 0000000 0000000 package git
import (
"github.com/go-git/go-git/v5/plumbing/transport/test"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type ReceivePackSuite struct {
test.ReceivePackSuite
BaseSuite
}
var _ = Suite(&ReceivePackSuite{})
func (s *ReceivePackSuite) SetUpTest(c *C) {
s.BaseSuite.SetUpTest(c)
s.ReceivePackSuite.Client = DefaultClient
s.ReceivePackSuite.Endpoint = s.prepareRepository(c, fixtures.Basic().One(), "basic.git")
s.ReceivePackSuite.EmptyEndpoint = s.prepareRepository(c, fixtures.ByTag("empty").One(), "empty.git")
s.ReceivePackSuite.NonExistentEndpoint = s.newEndpoint(c, "non-existent.git")
s.StartDaemon(c)
}
func (s *ReceivePackSuite) TestAdvertisedReferencesEmpty(c *C) {
//This test from BaseSuite is flaky, so it's disabled until we figure out a solution.
}
go-git-5.13.2/plumbing/transport/git/upload_pack_test.go 0000664 0000000 0000000 00000001223 14744245500 0023277 0 ustar 00root root 0000000 0000000 package git
import (
"github.com/go-git/go-git/v5/plumbing/transport/test"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type UploadPackSuite struct {
test.UploadPackSuite
BaseSuite
}
var _ = Suite(&UploadPackSuite{})
func (s *UploadPackSuite) SetUpSuite(c *C) {
s.BaseSuite.SetUpTest(c)
s.UploadPackSuite.Client = DefaultClient
s.UploadPackSuite.Endpoint = s.prepareRepository(c, fixtures.Basic().One(), "basic.git")
s.UploadPackSuite.EmptyEndpoint = s.prepareRepository(c, fixtures.ByTag("empty").One(), "empty.git")
s.UploadPackSuite.NonExistentEndpoint = s.newEndpoint(c, "non-existent.git")
s.StartDaemon(c)
}
go-git-5.13.2/plumbing/transport/http/ 0000775 0000000 0000000 00000000000 14744245500 0017625 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/http/common.go 0000664 0000000 0000000 00000026644 14744245500 0021460 0 ustar 00root root 0000000 0000000 // Package http implements the HTTP transport protocol.
package http
import (
"bytes"
"context"
"crypto/tls"
"crypto/x509"
"fmt"
"net"
"net/http"
"net/url"
"reflect"
"strconv"
"strings"
"sync"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/golang/groupcache/lru"
)
// it requires a bytes.Buffer, because we need to know the length
func applyHeadersToRequest(req *http.Request, content *bytes.Buffer, host string, requestType string) {
req.Header.Add("User-Agent", capability.DefaultAgent())
req.Header.Add("Host", host) // host:port
if content == nil {
req.Header.Add("Accept", "*/*")
return
}
req.Header.Add("Accept", fmt.Sprintf("application/x-%s-result", requestType))
req.Header.Add("Content-Type", fmt.Sprintf("application/x-%s-request", requestType))
req.Header.Add("Content-Length", strconv.Itoa(content.Len()))
}
const infoRefsPath = "/info/refs"
func advertisedReferences(ctx context.Context, s *session, serviceName string) (ref *packp.AdvRefs, err error) {
url := fmt.Sprintf(
"%s%s?service=%s",
s.endpoint.String(), infoRefsPath, serviceName,
)
req, err := http.NewRequest(http.MethodGet, url, nil)
if err != nil {
return nil, err
}
s.ApplyAuthToRequest(req)
applyHeadersToRequest(req, nil, s.endpoint.Host, serviceName)
res, err := s.client.Do(req.WithContext(ctx))
if err != nil {
return nil, err
}
s.ModifyEndpointIfRedirect(res)
defer ioutil.CheckClose(res.Body, &err)
if err = NewErr(res); err != nil {
return nil, err
}
ar := packp.NewAdvRefs()
if err = ar.Decode(res.Body); err != nil {
if err == packp.ErrEmptyAdvRefs {
err = transport.ErrEmptyRemoteRepository
}
return nil, err
}
// Git 2.41+ returns a zero-id plus capabilities when an empty
// repository is being cloned. This skips the existing logic within
// advrefs_decode.decodeFirstHash, which expects a flush-pkt instead.
//
// This logic aligns with plumbing/transport/internal/common/common.go.
if ar.IsEmpty() &&
// Empty repositories are valid for git-receive-pack.
transport.ReceivePackServiceName != serviceName {
return nil, transport.ErrEmptyRemoteRepository
}
transport.FilterUnsupportedCapabilities(ar.Capabilities)
s.advRefs = ar
return ar, nil
}
type client struct {
client *http.Client
transports *lru.Cache
mutex sync.RWMutex
}
// ClientOptions holds user configurable options for the client.
type ClientOptions struct {
// CacheMaxEntries is the max no. of entries that the transport objects
// cache will hold at any given point of time. It must be a positive integer.
// Calling `client.addTransport()` after the cache has reached the specified
// size, will result in the least recently used transport getting deleted
// before the provided transport is added to the cache.
CacheMaxEntries int
}
var (
// defaultTransportCacheSize is the default capacity of the transport objects cache.
// Its value is 0 because transport caching is turned off by default and is an
// opt-in feature.
defaultTransportCacheSize = 0
// DefaultClient is the default HTTP client, which uses a net/http client configured
// with http.DefaultTransport.
DefaultClient = NewClient(nil)
)
// NewClient creates a new client with a custom net/http client.
// See `InstallProtocol` to install and override default http client.
// If the net/http client is nil or empty, it will use a net/http client configured
// with http.DefaultTransport.
//
// Note that for HTTP client cannot distinguish between private repositories and
// unexistent repositories on GitHub. So it returns `ErrAuthorizationRequired`
// for both.
func NewClient(c *http.Client) transport.Transport {
if c == nil {
c = &http.Client{
Transport: http.DefaultTransport,
}
}
return NewClientWithOptions(c, &ClientOptions{
CacheMaxEntries: defaultTransportCacheSize,
})
}
// NewClientWithOptions returns a new client configured with the provided net/http client
// and other custom options specific to the client.
// If the net/http client is nil or empty, it will use a net/http client configured
// with http.DefaultTransport.
func NewClientWithOptions(c *http.Client, opts *ClientOptions) transport.Transport {
if c == nil {
c = &http.Client{
Transport: http.DefaultTransport,
}
}
cl := &client{
client: c,
}
if opts != nil {
if opts.CacheMaxEntries > 0 {
cl.transports = lru.New(opts.CacheMaxEntries)
}
}
return cl
}
func (c *client) NewUploadPackSession(ep *transport.Endpoint, auth transport.AuthMethod) (
transport.UploadPackSession, error) {
return newUploadPackSession(c, ep, auth)
}
func (c *client) NewReceivePackSession(ep *transport.Endpoint, auth transport.AuthMethod) (
transport.ReceivePackSession, error) {
return newReceivePackSession(c, ep, auth)
}
type session struct {
auth AuthMethod
client *http.Client
endpoint *transport.Endpoint
advRefs *packp.AdvRefs
}
func transportWithInsecureTLS(transport *http.Transport) {
if transport.TLSClientConfig == nil {
transport.TLSClientConfig = &tls.Config{}
}
transport.TLSClientConfig.InsecureSkipVerify = true
}
func transportWithCABundle(transport *http.Transport, caBundle []byte) error {
rootCAs, err := x509.SystemCertPool()
if err != nil {
return err
}
if rootCAs == nil {
rootCAs = x509.NewCertPool()
}
rootCAs.AppendCertsFromPEM(caBundle)
if transport.TLSClientConfig == nil {
transport.TLSClientConfig = &tls.Config{}
}
transport.TLSClientConfig.RootCAs = rootCAs
return nil
}
func transportWithProxy(transport *http.Transport, proxyURL *url.URL) {
transport.Proxy = http.ProxyURL(proxyURL)
}
func configureTransport(transport *http.Transport, ep *transport.Endpoint) error {
if len(ep.CaBundle) > 0 {
if err := transportWithCABundle(transport, ep.CaBundle); err != nil {
return err
}
}
if ep.InsecureSkipTLS {
transportWithInsecureTLS(transport)
}
if ep.Proxy.URL != "" {
proxyURL, err := ep.Proxy.FullURL()
if err != nil {
return err
}
transportWithProxy(transport, proxyURL)
}
return nil
}
func newSession(c *client, ep *transport.Endpoint, auth transport.AuthMethod) (*session, error) {
var httpClient *http.Client
// We need to configure the http transport if there are transport specific
// options present in the endpoint.
if len(ep.CaBundle) > 0 || ep.InsecureSkipTLS || ep.Proxy.URL != "" {
var transport *http.Transport
// if the client wasn't configured to have a cache for transports then just configure
// the transport and use it directly, otherwise try to use the cache.
if c.transports == nil {
tr, ok := c.client.Transport.(*http.Transport)
if !ok {
return nil, fmt.Errorf("expected underlying client transport to be of type: %s; got: %s",
reflect.TypeOf(transport), reflect.TypeOf(c.client.Transport))
}
transport = tr.Clone()
configureTransport(transport, ep)
} else {
transportOpts := transportOptions{
caBundle: string(ep.CaBundle),
insecureSkipTLS: ep.InsecureSkipTLS,
}
if ep.Proxy.URL != "" {
proxyURL, err := ep.Proxy.FullURL()
if err != nil {
return nil, err
}
transportOpts.proxyURL = *proxyURL
}
var found bool
transport, found = c.fetchTransport(transportOpts)
if !found {
transport = c.client.Transport.(*http.Transport).Clone()
configureTransport(transport, ep)
c.addTransport(transportOpts, transport)
}
}
httpClient = &http.Client{
Transport: transport,
CheckRedirect: c.client.CheckRedirect,
Jar: c.client.Jar,
Timeout: c.client.Timeout,
}
} else {
httpClient = c.client
}
s := &session{
auth: basicAuthFromEndpoint(ep),
client: httpClient,
endpoint: ep,
}
if auth != nil {
a, ok := auth.(AuthMethod)
if !ok {
return nil, transport.ErrInvalidAuthMethod
}
s.auth = a
}
return s, nil
}
func (s *session) ApplyAuthToRequest(req *http.Request) {
if s.auth == nil {
return
}
s.auth.SetAuth(req)
}
func (s *session) ModifyEndpointIfRedirect(res *http.Response) {
if res.Request == nil {
return
}
r := res.Request
if !strings.HasSuffix(r.URL.Path, infoRefsPath) {
return
}
h, p, err := net.SplitHostPort(r.URL.Host)
if err != nil {
h = r.URL.Host
}
if p != "" {
port, err := strconv.Atoi(p)
if err == nil {
s.endpoint.Port = port
}
}
s.endpoint.Host = h
s.endpoint.Protocol = r.URL.Scheme
s.endpoint.Path = r.URL.Path[:len(r.URL.Path)-len(infoRefsPath)]
}
func (*session) Close() error {
return nil
}
// AuthMethod is concrete implementation of common.AuthMethod for HTTP services
type AuthMethod interface {
transport.AuthMethod
SetAuth(r *http.Request)
}
func basicAuthFromEndpoint(ep *transport.Endpoint) *BasicAuth {
u := ep.User
if u == "" {
return nil
}
return &BasicAuth{u, ep.Password}
}
// BasicAuth represent a HTTP basic auth
type BasicAuth struct {
Username, Password string
}
func (a *BasicAuth) SetAuth(r *http.Request) {
if a == nil {
return
}
r.SetBasicAuth(a.Username, a.Password)
}
// Name is name of the auth
func (a *BasicAuth) Name() string {
return "http-basic-auth"
}
func (a *BasicAuth) String() string {
masked := "*******"
if a.Password == "" {
masked = ""
}
return fmt.Sprintf("%s - %s:%s", a.Name(), a.Username, masked)
}
// TokenAuth implements an http.AuthMethod that can be used with http transport
// to authenticate with HTTP token authentication (also known as bearer
// authentication).
//
// IMPORTANT: If you are looking to use OAuth tokens with popular servers (e.g.
// GitHub, Bitbucket, GitLab) you should use BasicAuth instead. These servers
// use basic HTTP authentication, with the OAuth token as user or password.
// Check the documentation of your git server for details.
type TokenAuth struct {
Token string
}
func (a *TokenAuth) SetAuth(r *http.Request) {
if a == nil {
return
}
r.Header.Add("Authorization", fmt.Sprintf("Bearer %s", a.Token))
}
// Name is name of the auth
func (a *TokenAuth) Name() string {
return "http-token-auth"
}
func (a *TokenAuth) String() string {
masked := "*******"
if a.Token == "" {
masked = ""
}
return fmt.Sprintf("%s - %s", a.Name(), masked)
}
// Err is a dedicated error to return errors based on status code
type Err struct {
Response *http.Response
Reason string
}
// NewErr returns a new Err based on a http response and closes response body
// if needed
func NewErr(r *http.Response) error {
if r.StatusCode >= http.StatusOK && r.StatusCode < http.StatusMultipleChoices {
return nil
}
var reason string
// If a response message is present, add it to error
var messageBuffer bytes.Buffer
if r.Body != nil {
messageLength, _ := messageBuffer.ReadFrom(r.Body)
if messageLength > 0 {
reason = messageBuffer.String()
}
_ = r.Body.Close()
}
switch r.StatusCode {
case http.StatusUnauthorized:
return fmt.Errorf("%w: %s", transport.ErrAuthenticationRequired, reason)
case http.StatusForbidden:
return fmt.Errorf("%w: %s", transport.ErrAuthorizationFailed, reason)
case http.StatusNotFound:
return fmt.Errorf("%w: %s", transport.ErrRepositoryNotFound, reason)
}
return plumbing.NewUnexpectedError(&Err{r, reason})
}
// StatusCode returns the status code of the response
func (e *Err) StatusCode() int {
return e.Response.StatusCode
}
func (e *Err) Error() string {
return fmt.Sprintf("unexpected requesting %q status code: %d",
e.Response.Request.URL, e.Response.StatusCode,
)
}
go-git-5.13.2/plumbing/transport/http/common_test.go 0000664 0000000 0000000 00000017133 14744245500 0022510 0 ustar 00root root 0000000 0000000 package http
import (
"crypto/tls"
"fmt"
"io"
"log"
"net"
"net/http"
"net/http/cgi"
"net/url"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/transport"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type ClientSuite struct {
Endpoint *transport.Endpoint
EmptyAuth transport.AuthMethod
}
var _ = Suite(&ClientSuite{})
func (s *ClientSuite) SetUpSuite(c *C) {
var err error
s.Endpoint, err = transport.NewEndpoint(
"https://github.com/git-fixtures/basic",
)
c.Assert(err, IsNil)
}
func (s *UploadPackSuite) TestNewClient(c *C) {
roundTripper := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
cl := &http.Client{Transport: roundTripper}
r, ok := NewClient(cl).(*client)
c.Assert(ok, Equals, true)
c.Assert(r.client, Equals, cl)
}
func (s *ClientSuite) TestNewBasicAuth(c *C) {
a := &BasicAuth{"foo", "qux"}
c.Assert(a.Name(), Equals, "http-basic-auth")
c.Assert(a.String(), Equals, "http-basic-auth - foo:*******")
}
func (s *ClientSuite) TestNewTokenAuth(c *C) {
a := &TokenAuth{"OAUTH-TOKEN-TEXT"}
c.Assert(a.Name(), Equals, "http-token-auth")
c.Assert(a.String(), Equals, "http-token-auth - *******")
// Check header is set correctly
req, err := http.NewRequest("GET", "https://github.com/git-fixtures/basic", nil)
c.Assert(err, Equals, nil)
a.SetAuth(req)
c.Assert(req.Header.Get("Authorization"), Equals, "Bearer OAUTH-TOKEN-TEXT")
}
func (s *ClientSuite) TestNewErrOK(c *C) {
res := &http.Response{StatusCode: http.StatusOK}
err := NewErr(res)
c.Assert(err, IsNil)
}
func (s *ClientSuite) TestNewErrUnauthorized(c *C) {
s.testNewHTTPError(c, http.StatusUnauthorized, ".*authentication required.*")
}
func (s *ClientSuite) TestNewErrForbidden(c *C) {
s.testNewHTTPError(c, http.StatusForbidden, ".*authorization failed.*")
}
func (s *ClientSuite) TestNewErrNotFound(c *C) {
s.testNewHTTPError(c, http.StatusNotFound, ".*repository not found.*")
}
func (s *ClientSuite) TestNewHTTPError40x(c *C) {
s.testNewHTTPError(c, http.StatusPaymentRequired,
"unexpected client error.*")
}
func (s *ClientSuite) TestNewUnexpectedError(c *C) {
res := &http.Response{
StatusCode: 500,
Body: io.NopCloser(strings.NewReader("Unexpected error")),
}
err := NewErr(res)
c.Assert(err, NotNil)
c.Assert(err, FitsTypeOf, &plumbing.UnexpectedError{})
unexpectedError, _ := err.(*plumbing.UnexpectedError)
c.Assert(unexpectedError.Err, FitsTypeOf, &Err{})
httpError, _ := unexpectedError.Err.(*Err)
c.Assert(httpError.Reason, Equals, "Unexpected error")
}
func (s *ClientSuite) Test_newSession(c *C) {
cl := NewClientWithOptions(nil, &ClientOptions{
CacheMaxEntries: 2,
}).(*client)
insecureEP := s.Endpoint
insecureEP.InsecureSkipTLS = true
session, err := newSession(cl, insecureEP, nil)
c.Assert(err, IsNil)
sessionTransport := session.client.Transport.(*http.Transport)
c.Assert(sessionTransport.TLSClientConfig.InsecureSkipVerify, Equals, true)
t, ok := cl.fetchTransport(transportOptions{
insecureSkipTLS: true,
})
// transport should be cached.
c.Assert(ok, Equals, true)
// cached transport should be the one that's used.
c.Assert(sessionTransport, Equals, t)
caEndpoint := insecureEP
caEndpoint.CaBundle = []byte("this is the way")
session, err = newSession(cl, caEndpoint, nil)
c.Assert(err, IsNil)
sessionTransport = session.client.Transport.(*http.Transport)
c.Assert(sessionTransport.TLSClientConfig.InsecureSkipVerify, Equals, true)
c.Assert(sessionTransport.TLSClientConfig.RootCAs, NotNil)
t, ok = cl.fetchTransport(transportOptions{
insecureSkipTLS: true,
caBundle: "this is the way",
})
// transport should be cached.
c.Assert(ok, Equals, true)
// cached transport should be the one that's used.
c.Assert(sessionTransport, Equals, t)
session, err = newSession(cl, caEndpoint, nil)
c.Assert(err, IsNil)
sessionTransport = session.client.Transport.(*http.Transport)
// transport that's going to be used should be cached already.
c.Assert(sessionTransport, Equals, t)
// no new transport got cached.
c.Assert(cl.transports.Len(), Equals, 2)
// if the cache does not exist, the transport should still be correctly configured.
cl.transports = nil
session, err = newSession(cl, insecureEP, nil)
c.Assert(err, IsNil)
sessionTransport = session.client.Transport.(*http.Transport)
c.Assert(sessionTransport.TLSClientConfig.InsecureSkipVerify, Equals, true)
}
func (s *ClientSuite) testNewHTTPError(c *C, code int, msg string) {
req, _ := http.NewRequest("GET", "foo", nil)
res := &http.Response{
StatusCode: code,
Request: req,
}
err := NewErr(res)
c.Assert(err, NotNil)
c.Assert(err, ErrorMatches, msg)
}
func (s *ClientSuite) TestSetAuth(c *C) {
auth := &BasicAuth{}
r, err := DefaultClient.NewUploadPackSession(s.Endpoint, auth)
c.Assert(err, IsNil)
c.Assert(auth, Equals, r.(*upSession).auth)
}
type mockAuth struct{}
func (*mockAuth) Name() string { return "" }
func (*mockAuth) String() string { return "" }
func (s *ClientSuite) TestSetAuthWrongType(c *C) {
_, err := DefaultClient.NewUploadPackSession(s.Endpoint, &mockAuth{})
c.Assert(err, Equals, transport.ErrInvalidAuthMethod)
}
func (s *ClientSuite) TestModifyEndpointIfRedirect(c *C) {
sess := &session{endpoint: nil}
u, _ := url.Parse("https://example.com/info/refs")
res := &http.Response{Request: &http.Request{URL: u}}
c.Assert(func() {
sess.ModifyEndpointIfRedirect(res)
}, PanicMatches, ".*nil pointer dereference.*")
sess = &session{endpoint: nil}
// no-op - should return and not panic
sess.ModifyEndpointIfRedirect(&http.Response{})
data := []struct {
url string
endpoint *transport.Endpoint
expected *transport.Endpoint
}{
{"https://example.com/foo/bar", nil, nil},
{"https://example.com/foo.git/info/refs",
&transport.Endpoint{},
&transport.Endpoint{Protocol: "https", Host: "example.com", Path: "/foo.git"}},
{"https://example.com:8080/foo.git/info/refs",
&transport.Endpoint{},
&transport.Endpoint{Protocol: "https", Host: "example.com", Port: 8080, Path: "/foo.git"}},
}
for _, d := range data {
u, _ := url.Parse(d.url)
sess := &session{endpoint: d.endpoint}
sess.ModifyEndpointIfRedirect(&http.Response{
Request: &http.Request{URL: u},
})
c.Assert(d.endpoint, DeepEquals, d.expected)
}
}
type BaseSuite struct {
fixtures.Suite
base string
host string
port int
}
func (s *BaseSuite) SetUpTest(c *C) {
l, err := net.Listen("tcp", "localhost:0")
c.Assert(err, IsNil)
base, err := os.MkdirTemp(c.MkDir(), fmt.Sprintf("go-git-http-%d", s.port))
c.Assert(err, IsNil)
s.port = l.Addr().(*net.TCPAddr).Port
s.base = filepath.Join(base, s.host)
err = os.MkdirAll(s.base, 0755)
c.Assert(err, IsNil)
cmd := exec.Command("git", "--exec-path")
out, err := cmd.CombinedOutput()
c.Assert(err, IsNil)
server := &http.Server{
Handler: &cgi.Handler{
Path: filepath.Join(strings.Trim(string(out), "\n"), "git-http-backend"),
Env: []string{"GIT_HTTP_EXPORT_ALL=true", fmt.Sprintf("GIT_PROJECT_ROOT=%s", s.base)},
},
}
go func() {
log.Fatal(server.Serve(l))
}()
}
func (s *BaseSuite) prepareRepository(c *C, f *fixtures.Fixture, name string) *transport.Endpoint {
fs := f.DotGit()
err := fixtures.EnsureIsBare(fs)
c.Assert(err, IsNil)
path := filepath.Join(s.base, name)
err = os.Rename(fs.Root(), path)
c.Assert(err, IsNil)
return s.newEndpoint(c, name)
}
func (s *BaseSuite) newEndpoint(c *C, name string) *transport.Endpoint {
ep, err := transport.NewEndpoint(fmt.Sprintf("http://localhost:%d/%s", s.port, name))
c.Assert(err, IsNil)
return ep
}
go-git-5.13.2/plumbing/transport/http/internal/ 0000775 0000000 0000000 00000000000 14744245500 0021441 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/http/internal/test/ 0000775 0000000 0000000 00000000000 14744245500 0022420 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/http/internal/test/proxy_test.go 0000664 0000000 0000000 00000004077 14744245500 0025177 0 ustar 00root root 0000000 0000000 package test
import (
"context"
"crypto/tls"
"fmt"
"net"
nethttp "net/http"
"os"
"sync/atomic"
"testing"
"github.com/elazarl/goproxy"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/http"
. "gopkg.in/check.v1"
)
// Hook up gocheck into the "go test" runner.
func Test(t *testing.T) { TestingT(t) }
type ProxySuite struct{}
var _ = Suite(&ProxySuite{})
var proxiedRequests int32
// This test tests proxy support via an env var, i.e. `HTTPS_PROXY`.
// Its located in a separate package because golang caches the value
// of proxy env vars leading to misleading/unexpected test results.
func (s *ProxySuite) TestAdvertisedReferences(c *C) {
proxy := goproxy.NewProxyHttpServer()
proxy.Verbose = true
SetupHTTPSProxy(proxy, &proxiedRequests)
httpsListener, err := net.Listen("tcp", ":0")
c.Assert(err, IsNil)
defer httpsListener.Close()
httpProxyAddr := fmt.Sprintf("localhost:%d", httpsListener.Addr().(*net.TCPAddr).Port)
proxyServer := nethttp.Server{
Addr: httpProxyAddr,
Handler: proxy,
// Due to how golang manages http/2 when provided with custom TLS config,
// servers and clients running in the same process leads to issues.
// Ref: https://github.com/golang/go/issues/21336
TLSConfig: &tls.Config{
NextProtos: []string{"http/1.1"},
},
}
go proxyServer.ServeTLS(httpsListener, "../../testdata/certs/server.crt", "../../testdata/certs/server.key")
defer proxyServer.Close()
os.Setenv("HTTPS_PROXY", fmt.Sprintf("https://user:pass@%s", httpProxyAddr))
defer os.Unsetenv("HTTPS_PROXY")
endpoint, err := transport.NewEndpoint("https://github.com/git-fixtures/basic.git")
c.Assert(err, IsNil)
endpoint.InsecureSkipTLS = true
client := http.DefaultClient
session, err := client.NewUploadPackSession(endpoint, nil)
c.Assert(err, IsNil)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
info, err := session.AdvertisedReferencesContext(ctx)
c.Assert(err, IsNil)
c.Assert(info, NotNil)
proxyUsed := atomic.LoadInt32(&proxiedRequests) > 0
c.Assert(proxyUsed, Equals, true)
}
go-git-5.13.2/plumbing/transport/http/internal/test/test_utils.go 0000664 0000000 0000000 00000002375 14744245500 0025155 0 ustar 00root root 0000000 0000000 package test
import (
"encoding/base64"
"strings"
"sync/atomic"
"github.com/elazarl/goproxy"
)
func SetupHTTPSProxy(proxy *goproxy.ProxyHttpServer, proxiedRequests *int32) {
var proxyHandler goproxy.FuncHttpsHandler = func(host string, ctx *goproxy.ProxyCtx) (*goproxy.ConnectAction, string) {
if strings.Contains(host, "github.com") {
user, pass, _ := ParseBasicAuth(ctx.Req.Header.Get("Proxy-Authorization"))
if user != "user" || pass != "pass" {
return goproxy.RejectConnect, host
}
atomic.AddInt32(proxiedRequests, 1)
return goproxy.OkConnect, host
}
// Reject if it isn't our request.
return goproxy.RejectConnect, host
}
proxy.OnRequest().HandleConnect(proxyHandler)
}
// adapted from https://github.com/golang/go/blob/2ef70d9d0f98832c8103a7968b195e560a8bb262/src/net/http/request.go#L959
func ParseBasicAuth(auth string) (username, password string, ok bool) {
const prefix = "Basic "
if len(auth) < len(prefix) || !strings.EqualFold(auth[:len(prefix)], prefix) {
return "", "", false
}
c, err := base64.StdEncoding.DecodeString(auth[len(prefix):])
if err != nil {
return "", "", false
}
cs := string(c)
username, password, ok = strings.Cut(cs, ":")
if !ok {
return "", "", false
}
return username, password, true
}
go-git-5.13.2/plumbing/transport/http/proxy_test.go 0000664 0000000 0000000 00000007004 14744245500 0022375 0 ustar 00root root 0000000 0000000 package http
import (
"context"
"crypto/tls"
"fmt"
"net"
"net/http"
"strings"
"sync/atomic"
"github.com/elazarl/goproxy"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/http/internal/test"
. "gopkg.in/check.v1"
)
type ProxySuite struct {
u UploadPackSuite
fixtures.Suite
}
var _ = Suite(&ProxySuite{})
var proxiedRequests int32
func (s *ProxySuite) TestAdvertisedReferences(c *C) {
s.u.SetUpTest(c)
proxy := goproxy.NewProxyHttpServer()
proxy.Verbose = true
setupHTTPProxy(proxy, &proxiedRequests)
httpListener, err := net.Listen("tcp", ":0")
c.Assert(err, IsNil)
defer httpListener.Close()
httpProxyAddr := fmt.Sprintf("http://localhost:%d", httpListener.Addr().(*net.TCPAddr).Port)
proxyServer := http.Server{
Addr: httpProxyAddr,
Handler: proxy,
}
go proxyServer.Serve(httpListener)
defer proxyServer.Close()
endpoint := s.u.prepareRepository(c, fixtures.Basic().One(), "basic.git")
endpoint.Proxy = transport.ProxyOptions{
URL: httpProxyAddr,
Username: "user",
Password: "pass",
}
s.u.Client = NewClient(nil)
session, err := s.u.Client.NewUploadPackSession(endpoint, nil)
c.Assert(err, IsNil)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
info, err := session.AdvertisedReferencesContext(ctx)
c.Assert(err, IsNil)
c.Assert(info, NotNil)
proxyUsed := atomic.LoadInt32(&proxiedRequests) > 0
c.Assert(proxyUsed, Equals, true)
atomic.StoreInt32(&proxiedRequests, 0)
test.SetupHTTPSProxy(proxy, &proxiedRequests)
httpsListener, err := net.Listen("tcp", ":0")
c.Assert(err, IsNil)
defer httpsListener.Close()
httpsProxyAddr := fmt.Sprintf("https://localhost:%d", httpsListener.Addr().(*net.TCPAddr).Port)
tlsProxyServer := http.Server{
Addr: httpsProxyAddr,
Handler: proxy,
// Due to how golang manages http/2 when provided with custom TLS config,
// servers and clients running in the same process leads to issues.
// Ref: https://github.com/golang/go/issues/21336
TLSConfig: &tls.Config{
NextProtos: []string{"http/1.1"},
},
}
go tlsProxyServer.ServeTLS(httpsListener, "testdata/certs/server.crt", "testdata/certs/server.key")
defer tlsProxyServer.Close()
endpoint, err = transport.NewEndpoint("https://github.com/git-fixtures/basic.git")
c.Assert(err, IsNil)
endpoint.Proxy = transport.ProxyOptions{
URL: httpsProxyAddr,
Username: "user",
Password: "pass",
}
endpoint.InsecureSkipTLS = true
session, err = s.u.Client.NewUploadPackSession(endpoint, nil)
c.Assert(err, IsNil)
info, err = session.AdvertisedReferencesContext(ctx)
c.Assert(err, IsNil)
c.Assert(info, NotNil)
proxyUsed = atomic.LoadInt32(&proxiedRequests) > 0
c.Assert(proxyUsed, Equals, true)
}
func setupHTTPProxy(proxy *goproxy.ProxyHttpServer, proxiedRequests *int32) {
// The request is being forwarded to the local test git server in this handler.
var proxyHandler goproxy.FuncReqHandler = func(req *http.Request, ctx *goproxy.ProxyCtx) (*http.Request, *http.Response) {
if strings.Contains(req.Host, "localhost") {
user, pass, _ := test.ParseBasicAuth(req.Header.Get("Proxy-Authorization"))
if user != "user" || pass != "pass" {
return req, goproxy.NewResponse(req, goproxy.ContentTypeText, http.StatusUnauthorized, "")
}
atomic.AddInt32(proxiedRequests, 1)
return req, nil
}
// Reject if it isn't our request.
return req, goproxy.NewResponse(req, goproxy.ContentTypeText, http.StatusForbidden, "")
}
proxy.OnRequest().Do(proxyHandler)
}
go-git-5.13.2/plumbing/transport/http/receive_pack.go 0000664 0000000 0000000 00000005033 14744245500 0022575 0 ustar 00root root 0000000 0000000 package http
import (
"bytes"
"context"
"fmt"
"io"
"net/http"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/utils/ioutil"
)
type rpSession struct {
*session
}
func newReceivePackSession(c *client, ep *transport.Endpoint, auth transport.AuthMethod) (transport.ReceivePackSession, error) {
s, err := newSession(c, ep, auth)
return &rpSession{s}, err
}
func (s *rpSession) AdvertisedReferences() (*packp.AdvRefs, error) {
return advertisedReferences(context.TODO(), s.session, transport.ReceivePackServiceName)
}
func (s *rpSession) AdvertisedReferencesContext(ctx context.Context) (*packp.AdvRefs, error) {
return advertisedReferences(ctx, s.session, transport.ReceivePackServiceName)
}
func (s *rpSession) ReceivePack(ctx context.Context, req *packp.ReferenceUpdateRequest) (
*packp.ReportStatus, error) {
url := fmt.Sprintf(
"%s/%s",
s.endpoint.String(), transport.ReceivePackServiceName,
)
buf := bytes.NewBuffer(nil)
if err := req.Encode(buf); err != nil {
return nil, err
}
res, err := s.doRequest(ctx, http.MethodPost, url, buf)
if err != nil {
return nil, err
}
r, err := ioutil.NonEmptyReader(res.Body)
if err == ioutil.ErrEmptyReader {
return nil, nil
}
if err != nil {
return nil, err
}
var d *sideband.Demuxer
if req.Capabilities.Supports(capability.Sideband64k) {
d = sideband.NewDemuxer(sideband.Sideband64k, r)
} else if req.Capabilities.Supports(capability.Sideband) {
d = sideband.NewDemuxer(sideband.Sideband, r)
}
if d != nil {
d.Progress = req.Progress
r = d
}
rc := ioutil.NewReadCloser(r, res.Body)
report := packp.NewReportStatus()
if err := report.Decode(rc); err != nil {
return nil, err
}
return report, report.Error()
}
func (s *rpSession) doRequest(
ctx context.Context, method, url string, content *bytes.Buffer,
) (*http.Response, error) {
var body io.Reader
if content != nil {
body = content
}
req, err := http.NewRequest(method, url, body)
if err != nil {
return nil, plumbing.NewPermanentError(err)
}
applyHeadersToRequest(req, content, s.endpoint.Host, transport.ReceivePackServiceName)
s.ApplyAuthToRequest(req)
res, err := s.client.Do(req.WithContext(ctx))
if err != nil {
return nil, plumbing.NewUnexpectedError(err)
}
if err := NewErr(res); err != nil {
return nil, err
}
return res, nil
}
go-git-5.13.2/plumbing/transport/http/receive_pack_test.go 0000664 0000000 0000000 00000001210 14744245500 0023625 0 ustar 00root root 0000000 0000000 package http
import (
"github.com/go-git/go-git/v5/plumbing/transport/test"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type ReceivePackSuite struct {
test.ReceivePackSuite
BaseSuite
}
var _ = Suite(&ReceivePackSuite{})
func (s *ReceivePackSuite) SetUpTest(c *C) {
s.BaseSuite.SetUpTest(c)
s.ReceivePackSuite.Client = DefaultClient
s.ReceivePackSuite.Endpoint = s.prepareRepository(c, fixtures.Basic().One(), "basic.git")
s.ReceivePackSuite.EmptyEndpoint = s.prepareRepository(c, fixtures.ByTag("empty").One(), "empty.git")
s.ReceivePackSuite.NonExistentEndpoint = s.newEndpoint(c, "non-existent.git")
}
go-git-5.13.2/plumbing/transport/http/testdata/ 0000775 0000000 0000000 00000000000 14744245500 0021436 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/http/testdata/certs/ 0000775 0000000 0000000 00000000000 14744245500 0022556 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/http/testdata/certs/server.crt 0000664 0000000 0000000 00000002426 14744245500 0024602 0 ustar 00root root 0000000 0000000 -----BEGIN CERTIFICATE-----
MIIDkzCCAnugAwIBAgIUWcuzUyG3EfGsXVUH0BAmnCJyNHswDQYJKoZIhvcNAQEL
BQAwWTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDESMBAGA1UEAwwJbG9jYWxob3N0MB4X
DTIzMDMwNzA3MTgwNloXDTI0MDMwNjA3MTgwNlowWTELMAkGA1UEBhMCQVUxEzAR
BgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5
IEx0ZDESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
MIIBCgKCAQEAvyKX6vJXt1u+WBfBNJByFDAb7msdsk6SiPFlX5uyilaWmlRxvLo1
GZMjjuQbs4wU6BAoZcgiELnsC9GSyxgrhk7NIW3ud/QD7s8ZxETxFLb0ur6tJj7/
ETEcU/AKSl1FpeJbGHqGipYp5+0GU0zPDxRYqC2N3+fcGZPQbBwxb1f+MrBjWutb
3eNYTLdPH3W7RUqbunC1KZRJ8XOcU5XZ4qEaMkZYdz1QItxwPnpPuSZs53ga3TDF
zclpQcT8OH2JNwSI6bwlwFJ0Es06manw7XHmgd8anhix9FdsQYaTOW4kqh1iKQ/P
jPG50bdTUEqlOsaa+9av/qf+90npzt3xqQIDAQABo1MwUTAdBgNVHQ4EFgQUqTqb
q+jiJVgwftQS+YLcQWnvTuAwHwYDVR0jBBgwFoAUqTqbq+jiJVgwftQS+YLcQWnv
TuAwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAVUaFSikxyCy1
4P/ZZgeuR7vEJ5vWBxKPw/jFNZUFWy2Ag32w1BhrDwoYoc1Awg76QF2TqBQAhFNm
ek9aE+L83P/R2UhE9+LHnzwdMXt9HYOI1grONk2z3lMI1y4FCJBxHfGyC/XMoNgZ
qP7UdLgLGTIMN3O1Fww416Hn8BHzxN4o5ZEHJZ6QPMuN8OLk9oVu3yQIq/QcmSDH
GT2RiwT5IJWMUKK1UrV+y3/T9FwW2qqu+LX+coxjk7HgDWy3y66V9ahLBt8kONcr
qK0zutoQ5WPSmvnD2Nr0LVLGXEd7hbQNO7bgjO2YOBtnagUQJt72i/OmvZv8Mfnp
Bu6Qgl5hDw==
-----END CERTIFICATE-----
go-git-5.13.2/plumbing/transport/http/testdata/certs/server.key 0000664 0000000 0000000 00000003250 14744245500 0024576 0 ustar 00root root 0000000 0000000 -----BEGIN PRIVATE KEY-----
MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC/Ipfq8le3W75Y
F8E0kHIUMBvuax2yTpKI8WVfm7KKVpaaVHG8ujUZkyOO5BuzjBToEChlyCIQuewL
0ZLLGCuGTs0hbe539APuzxnERPEUtvS6vq0mPv8RMRxT8ApKXUWl4lsYeoaKlinn
7QZTTM8PFFioLY3f59wZk9BsHDFvV/4ysGNa61vd41hMt08fdbtFSpu6cLUplEnx
c5xTldnioRoyRlh3PVAi3HA+ek+5JmzneBrdMMXNyWlBxPw4fYk3BIjpvCXAUnQS
zTqZqfDtceaB3xqeGLH0V2xBhpM5biSqHWIpD8+M8bnRt1NQSqU6xpr71q/+p/73
SenO3fGpAgMBAAECggEAQUjenQhzv5Rdmpdajcq8vHqGP9Rki0/dK1tQpex3elsD
C+nGA5GSq46feaIeeCBjz7QdKE7Im+/1WUAXJLm3vCNUW5PB/UTixwIEKg7mTY4E
X3jbiZHA661boKv/x9C+BmAff2fyZonN/ILwQymcG+l2MtOEfzMh8baUXSjwFbhg
B08u4iXjee0y9I0CGMYWfasHLOIuhACCFKtqnvdQp8B82g8eSPhme5IjfPP8KZVr
00n6z8m00HVk6/yYJ8pVZ82j3T+wH6IqvlvaC320sbto8YXV6i8GWHaJumzU4/9s
IRm4459E+NmNcLNY/TCu89zsfrgNirN+qFfvJIOTxQKBgQDtME8s4UP0MhGuJ2lD
1HD64fAxMC6Xp/QSzY91Yn79UNssUUV+IwjuUnLIz3U8DBs/QETLm7CkNtI7h5m5
dBdeBBzCRGxhe8WqRfvceu4s0zr08ZkDaKLjFsBSnBsXZhKAAuRqBjnGAoAiKgVa
WpEAug00ThhQjipSY9tO9NSBawKBgQDOSz+8m2HJFktEdSctKIB9DesqlAg7YCyy
dHzywP0/r7wEvsCN7xPgCT5g8JBkRaFvLLKgw7gMKAUx8V2iwizEoDCAs/pbTWji
uZwPC8lWtbkpBMQIaP4Wap+GyFQJKv1/qZduwpkwkj+ok+m3WwIW55VFGyLn3XGG
VcLZm83aOwKBgQDXXI/nXjqHVZb8HEjWD+Ttx4yB/Q+xIAzbrc3edap8c5guKzUA
DOulCTOz5bq65PsweTh970V6NVS6PKt12lUFRpKeSeZmtS2LJ7RCQ1RTWxAjK+MV
V0LfEt9ZouhuXH3bwcSICFMY2VhirOjjW2xhzo0Cuw4UxqDi4kxU6rSxNQKBgQCI
sn5KmV/jot0/QK40E0mJFEcHkM4foiwcGGqPZWiq4eUh89CefJTb+OQX0nCrsSQ3
ChRXyTlU/NPsczcL2cVWiZt6PUihZZsh2cJaigHhbkuCrcDEneX4rrCE3IwrAwy1
oohRAawG7nI2X8UYFbs9uDlGcKPhpvBKBtw13DM87wKBgE8fOiFoTph//6piU7dV
pN33UfhPcAFwsIzxAH6Ljo6BYx2hfPRCxI2g0wchk6ydbDecLgMwVgugdJZ6+tRf
P+YV3wEwPcWOvWby3+EmJh0cXUTl6ZMA+eR4pvCi6kf2xJf9dRmEeNNhOuzn9Y0J
cT9yhBFG4iejKP0iTwET1JKY
-----END PRIVATE KEY-----
go-git-5.13.2/plumbing/transport/http/transport.go 0000664 0000000 0000000 00000001425 14744245500 0022212 0 ustar 00root root 0000000 0000000 package http
import (
"net/http"
"net/url"
)
// transportOptions contains transport specific configuration.
type transportOptions struct {
insecureSkipTLS bool
// []byte is not comparable.
caBundle string
proxyURL url.URL
}
func (c *client) addTransport(opts transportOptions, transport *http.Transport) {
c.mutex.Lock()
c.transports.Add(opts, transport)
c.mutex.Unlock()
}
func (c *client) removeTransport(opts transportOptions) {
c.mutex.Lock()
c.transports.Remove(opts)
c.mutex.Unlock()
}
func (c *client) fetchTransport(opts transportOptions) (*http.Transport, bool) {
c.mutex.RLock()
t, ok := c.transports.Get(opts)
c.mutex.RUnlock()
if !ok {
return nil, false
}
transport, ok := t.(*http.Transport)
if !ok {
return nil, false
}
return transport, true
}
go-git-5.13.2/plumbing/transport/http/upload_pack.go 0000664 0000000 0000000 00000005610 14744245500 0022440 0 ustar 00root root 0000000 0000000 package http
import (
"bytes"
"context"
"fmt"
"io"
"net/http"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/internal/common"
"github.com/go-git/go-git/v5/utils/ioutil"
)
type upSession struct {
*session
}
func newUploadPackSession(c *client, ep *transport.Endpoint, auth transport.AuthMethod) (transport.UploadPackSession, error) {
s, err := newSession(c, ep, auth)
return &upSession{s}, err
}
func (s *upSession) AdvertisedReferences() (*packp.AdvRefs, error) {
return advertisedReferences(context.TODO(), s.session, transport.UploadPackServiceName)
}
func (s *upSession) AdvertisedReferencesContext(ctx context.Context) (*packp.AdvRefs, error) {
return advertisedReferences(ctx, s.session, transport.UploadPackServiceName)
}
func (s *upSession) UploadPack(
ctx context.Context, req *packp.UploadPackRequest,
) (*packp.UploadPackResponse, error) {
if req.IsEmpty() {
return nil, transport.ErrEmptyUploadPackRequest
}
if err := req.Validate(); err != nil {
return nil, err
}
url := fmt.Sprintf(
"%s/%s",
s.endpoint.String(), transport.UploadPackServiceName,
)
content, err := uploadPackRequestToReader(req)
if err != nil {
return nil, err
}
res, err := s.doRequest(ctx, http.MethodPost, url, content)
if err != nil {
return nil, err
}
r, err := ioutil.NonEmptyReader(res.Body)
if err != nil {
if err == ioutil.ErrEmptyReader || err == io.ErrUnexpectedEOF {
return nil, transport.ErrEmptyUploadPackRequest
}
return nil, err
}
rc := ioutil.NewReadCloser(r, res.Body)
return common.DecodeUploadPackResponse(rc, req)
}
// Close does nothing.
func (s *upSession) Close() error {
return nil
}
func (s *upSession) doRequest(
ctx context.Context, method, url string, content *bytes.Buffer,
) (*http.Response, error) {
var body io.Reader
if content != nil {
body = content
}
req, err := http.NewRequest(method, url, body)
if err != nil {
return nil, plumbing.NewPermanentError(err)
}
applyHeadersToRequest(req, content, s.endpoint.Host, transport.UploadPackServiceName)
s.ApplyAuthToRequest(req)
res, err := s.client.Do(req.WithContext(ctx))
if err != nil {
return nil, plumbing.NewUnexpectedError(err)
}
if err := NewErr(res); err != nil {
return nil, err
}
return res, nil
}
func uploadPackRequestToReader(req *packp.UploadPackRequest) (*bytes.Buffer, error) {
buf := bytes.NewBuffer(nil)
e := pktline.NewEncoder(buf)
if err := req.UploadRequest.Encode(buf); err != nil {
return nil, fmt.Errorf("sending upload-req message: %s", err)
}
if err := req.UploadHaves.Encode(buf, false); err != nil {
return nil, fmt.Errorf("sending haves message: %s", err)
}
if err := e.EncodeString("done\n"); err != nil {
return nil, err
}
return buf, nil
}
go-git-5.13.2/plumbing/transport/http/upload_pack_test.go 0000664 0000000 0000000 00000010754 14744245500 0023504 0 ustar 00root root 0000000 0000000 package http
import (
"context"
"fmt"
"io"
"net/url"
"os"
"path/filepath"
. "github.com/go-git/go-git/v5/internal/test"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/test"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type UploadPackSuite struct {
test.UploadPackSuite
BaseSuite
}
var _ = Suite(&UploadPackSuite{})
func (s *UploadPackSuite) SetUpSuite(c *C) {
s.BaseSuite.SetUpTest(c)
s.UploadPackSuite.Client = DefaultClient
s.UploadPackSuite.Endpoint = s.prepareRepository(c, fixtures.Basic().One(), "basic.git")
s.UploadPackSuite.EmptyEndpoint = s.prepareRepository(c, fixtures.ByTag("empty").One(), "empty.git")
s.UploadPackSuite.NonExistentEndpoint = s.newEndpoint(c, "non-existent.git")
}
// Overwritten, different behaviour for HTTP.
func (s *UploadPackSuite) TestAdvertisedReferencesNotExists(c *C) {
r, err := s.Client.NewUploadPackSession(s.NonExistentEndpoint, s.EmptyAuth)
c.Assert(err, IsNil)
info, err := r.AdvertisedReferences()
c.Assert(err, ErrorIs, transport.ErrRepositoryNotFound)
c.Assert(info, IsNil)
}
func (s *UploadPackSuite) TestuploadPackRequestToReader(c *C) {
r := packp.NewUploadPackRequest()
r.Wants = append(r.Wants, plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c"))
r.Wants = append(r.Wants, plumbing.NewHash("2b41ef280fdb67a9b250678686a0c3e03b0a9989"))
r.Haves = append(r.Haves, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
sr, err := uploadPackRequestToReader(r)
c.Assert(err, IsNil)
b, _ := io.ReadAll(sr)
c.Assert(string(b), Equals,
"0032want 2b41ef280fdb67a9b250678686a0c3e03b0a9989\n"+
"0032want d82f291cde9987322c8a0c81a325e1ba6159684c\n0000"+
"0032have 6ecf0ef2c2dffb796033e5a02219af86ec6584e5\n"+
"0009done\n",
)
}
func (s *UploadPackSuite) prepareRepository(c *C, f *fixtures.Fixture, name string) *transport.Endpoint {
fs := f.DotGit()
err := fixtures.EnsureIsBare(fs)
c.Assert(err, IsNil)
path := filepath.Join(s.base, name)
err = os.Rename(fs.Root(), path)
c.Assert(err, IsNil)
return s.newEndpoint(c, name)
}
func (s *UploadPackSuite) newEndpoint(c *C, name string) *transport.Endpoint {
ep, err := transport.NewEndpoint(fmt.Sprintf("http://localhost:%d/%s", s.port, name))
c.Assert(err, IsNil)
return ep
}
func (s *UploadPackSuite) TestAdvertisedReferencesRedirectPath(c *C) {
endpoint, _ := transport.NewEndpoint("https://gitlab.com/gitlab-org/gitter/webapp")
session, err := s.Client.NewUploadPackSession(endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
info, err := session.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(info, NotNil)
url := session.(*upSession).endpoint.String()
c.Assert(url, Equals, "https://gitlab.com/gitlab-org/gitter/webapp.git")
}
func (s *UploadPackSuite) TestAdvertisedReferencesRedirectSchema(c *C) {
endpoint, _ := transport.NewEndpoint("http://github.com/git-fixtures/basic")
session, err := s.Client.NewUploadPackSession(endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
info, err := session.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(info, NotNil)
url := session.(*upSession).endpoint.String()
c.Assert(url, Equals, "https://github.com/git-fixtures/basic")
}
func (s *UploadPackSuite) TestAdvertisedReferencesContext(c *C) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
endpoint, _ := transport.NewEndpoint("http://github.com/git-fixtures/basic")
session, err := s.Client.NewUploadPackSession(endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
info, err := session.AdvertisedReferencesContext(ctx)
c.Assert(err, IsNil)
c.Assert(info, NotNil)
url := session.(*upSession).endpoint.String()
c.Assert(url, Equals, "https://github.com/git-fixtures/basic")
}
func (s *UploadPackSuite) TestAdvertisedReferencesContextCanceled(c *C) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
endpoint, _ := transport.NewEndpoint("http://github.com/git-fixtures/basic")
session, err := s.Client.NewUploadPackSession(endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
info, err := session.AdvertisedReferencesContext(ctx)
c.Assert(err, DeepEquals, &url.Error{Op: "Get", URL: "http://github.com/git-fixtures/basic/info/refs?service=git-upload-pack", Err: context.Canceled})
c.Assert(info, IsNil)
}
func (s *UploadPackSuite) TestUploadPackWithContextOnRead(c *C) {
c.Skip("flaky tests, looks like sometimes the request body is cached, so doesn't fail on context cancel")
}
go-git-5.13.2/plumbing/transport/internal/ 0000775 0000000 0000000 00000000000 14744245500 0020462 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/internal/common/ 0000775 0000000 0000000 00000000000 14744245500 0021752 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/internal/common/common.go 0000664 0000000 0000000 00000031130 14744245500 0023567 0 ustar 00root root 0000000 0000000 // Package common implements the git pack protocol with a pluggable transport.
// This is a low-level package to implement new transports. Use a concrete
// implementation instead (e.g. http, file, ssh).
//
// A simple example of usage can be found in the file package.
package common
import (
"bufio"
"context"
"errors"
"fmt"
"io"
"regexp"
"strings"
"time"
"github.com/go-git/go-git/v5/plumbing/format/pktline"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/utils/ioutil"
)
const (
readErrorSecondsTimeout = 10
)
var (
ErrTimeoutExceeded = errors.New("timeout exceeded")
// stdErrSkipPattern is used for skipping lines from a command's stderr output.
// Any line matching this pattern will be skipped from further
// processing and not be returned to calling code.
stdErrSkipPattern = regexp.MustCompile("^remote:( =*){0,1}$")
)
// Commander creates Command instances. This is the main entry point for
// transport implementations.
type Commander interface {
// Command creates a new Command for the given git command and
// endpoint. cmd can be git-upload-pack or git-receive-pack. An
// error should be returned if the endpoint is not supported or the
// command cannot be created (e.g. binary does not exist, connection
// cannot be established).
Command(cmd string, ep *transport.Endpoint, auth transport.AuthMethod) (Command, error)
}
// Command is used for a single command execution.
// This interface is modeled after exec.Cmd and ssh.Session in the standard
// library.
type Command interface {
// StderrPipe returns a pipe that will be connected to the command's
// standard error when the command starts. It should not be called after
// Start.
StderrPipe() (io.Reader, error)
// StdinPipe returns a pipe that will be connected to the command's
// standard input when the command starts. It should not be called after
// Start. The pipe should be closed when no more input is expected.
StdinPipe() (io.WriteCloser, error)
// StdoutPipe returns a pipe that will be connected to the command's
// standard output when the command starts. It should not be called after
// Start.
StdoutPipe() (io.Reader, error)
// Start starts the specified command. It does not wait for it to
// complete.
Start() error
// Close closes the command and releases any resources used by it. It
// will block until the command exits.
Close() error
}
// CommandKiller expands the Command interface, enabling it for being killed.
type CommandKiller interface {
// Kill and close the session whatever the state it is. It will block until
// the command is terminated.
Kill() error
}
type client struct {
cmdr Commander
}
// NewClient creates a new client using the given Commander.
func NewClient(runner Commander) transport.Transport {
return &client{runner}
}
// NewUploadPackSession creates a new UploadPackSession.
func (c *client) NewUploadPackSession(ep *transport.Endpoint, auth transport.AuthMethod) (
transport.UploadPackSession, error) {
return c.newSession(transport.UploadPackServiceName, ep, auth)
}
// NewReceivePackSession creates a new ReceivePackSession.
func (c *client) NewReceivePackSession(ep *transport.Endpoint, auth transport.AuthMethod) (
transport.ReceivePackSession, error) {
return c.newSession(transport.ReceivePackServiceName, ep, auth)
}
type session struct {
Stdin io.WriteCloser
Stdout io.Reader
Command Command
isReceivePack bool
advRefs *packp.AdvRefs
packRun bool
finished bool
firstErrLine chan string
}
func (c *client) newSession(s string, ep *transport.Endpoint, auth transport.AuthMethod) (*session, error) {
cmd, err := c.cmdr.Command(s, ep, auth)
if err != nil {
return nil, err
}
stdin, err := cmd.StdinPipe()
if err != nil {
return nil, err
}
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, err
}
stderr, err := cmd.StderrPipe()
if err != nil {
return nil, err
}
if err := cmd.Start(); err != nil {
return nil, err
}
return &session{
Stdin: stdin,
Stdout: stdout,
Command: cmd,
firstErrLine: c.listenFirstError(stderr),
isReceivePack: s == transport.ReceivePackServiceName,
}, nil
}
func (c *client) listenFirstError(r io.Reader) chan string {
if r == nil {
return nil
}
errLine := make(chan string, 1)
go func() {
s := bufio.NewScanner(r)
for {
if s.Scan() {
line := s.Text()
if !stdErrSkipPattern.MatchString(line) {
errLine <- line
break
}
} else {
close(errLine)
break
}
}
_, _ = io.Copy(io.Discard, r)
}()
return errLine
}
func (s *session) AdvertisedReferences() (*packp.AdvRefs, error) {
return s.AdvertisedReferencesContext(context.TODO())
}
// AdvertisedReferences retrieves the advertised references from the server.
func (s *session) AdvertisedReferencesContext(ctx context.Context) (*packp.AdvRefs, error) {
if s.advRefs != nil {
return s.advRefs, nil
}
ar := packp.NewAdvRefs()
if err := ar.Decode(s.StdoutContext(ctx)); err != nil {
if err := s.handleAdvRefDecodeError(err); err != nil {
return nil, err
}
}
// Some servers like jGit, announce capabilities instead of returning an
// packp message with a flush. This verifies that we received a empty
// adv-refs, even it contains capabilities.
if !s.isReceivePack && ar.IsEmpty() {
return nil, transport.ErrEmptyRemoteRepository
}
transport.FilterUnsupportedCapabilities(ar.Capabilities)
s.advRefs = ar
return ar, nil
}
func (s *session) handleAdvRefDecodeError(err error) error {
var errLine *pktline.ErrorLine
if errors.As(err, &errLine) {
if isRepoNotFoundError(errLine.Text) {
return transport.ErrRepositoryNotFound
}
return errLine
}
// If repository is not found, we get empty stdout and server writes an
// error to stderr.
if errors.Is(err, packp.ErrEmptyInput) {
// TODO:(v6): handle this error in a better way.
// Instead of checking the stderr output for a specific error message,
// define an ExitError and embed the stderr output and exit (if one
// exists) in the error struct. Just like exec.ExitError.
s.finished = true
if err := s.checkNotFoundError(); err != nil {
return err
}
return io.ErrUnexpectedEOF
}
// For empty (but existing) repositories, we get empty advertised-references
// message. But valid. That is, it includes at least a flush.
if err == packp.ErrEmptyAdvRefs {
// Empty repositories are valid for git-receive-pack.
if s.isReceivePack {
return nil
}
if err := s.finish(); err != nil {
return err
}
return transport.ErrEmptyRemoteRepository
}
// Some server sends the errors as normal content (git protocol), so when
// we try to decode it fails, we need to check the content of it, to detect
// not found errors
if uerr, ok := err.(*packp.ErrUnexpectedData); ok {
if isRepoNotFoundError(string(uerr.Data)) {
return transport.ErrRepositoryNotFound
}
}
return err
}
// UploadPack performs a request to the server to fetch a packfile. A reader is
// returned with the packfile content. The reader must be closed after reading.
func (s *session) UploadPack(ctx context.Context, req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) {
if req.IsEmpty() {
// XXX: IsEmpty means haves are a subset of wants, in that case we have
// everything we asked for. Close the connection and return nil.
if err := s.finish(); err != nil {
return nil, err
}
// TODO:(v6) return nil here
return nil, transport.ErrEmptyUploadPackRequest
}
if err := req.Validate(); err != nil {
return nil, err
}
if _, err := s.AdvertisedReferencesContext(ctx); err != nil {
return nil, err
}
s.packRun = true
in := s.StdinContext(ctx)
out := s.StdoutContext(ctx)
if err := uploadPack(in, out, req); err != nil {
return nil, err
}
r, err := ioutil.NonEmptyReader(out)
if err == ioutil.ErrEmptyReader {
if c, ok := s.Stdout.(io.Closer); ok {
_ = c.Close()
}
return nil, transport.ErrEmptyUploadPackRequest
}
if err != nil {
return nil, err
}
rc := ioutil.NewReadCloser(r, s)
return DecodeUploadPackResponse(rc, req)
}
func (s *session) StdinContext(ctx context.Context) io.WriteCloser {
return ioutil.NewWriteCloserOnError(
ioutil.NewContextWriteCloser(ctx, s.Stdin),
s.onError,
)
}
func (s *session) StdoutContext(ctx context.Context) io.Reader {
return ioutil.NewReaderOnError(
ioutil.NewContextReader(ctx, s.Stdout),
s.onError,
)
}
func (s *session) onError(err error) {
if k, ok := s.Command.(CommandKiller); ok {
_ = k.Kill()
}
_ = s.Close()
}
func (s *session) ReceivePack(ctx context.Context, req *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) {
if _, err := s.AdvertisedReferences(); err != nil {
return nil, err
}
s.packRun = true
w := s.StdinContext(ctx)
if err := req.Encode(w); err != nil {
return nil, err
}
if err := w.Close(); err != nil {
return nil, err
}
if !req.Capabilities.Supports(capability.ReportStatus) {
// If we don't have report-status, we can only
// check return value error.
return nil, s.Command.Close()
}
r := s.StdoutContext(ctx)
var d *sideband.Demuxer
if req.Capabilities.Supports(capability.Sideband64k) {
d = sideband.NewDemuxer(sideband.Sideband64k, r)
} else if req.Capabilities.Supports(capability.Sideband) {
d = sideband.NewDemuxer(sideband.Sideband, r)
}
if d != nil {
d.Progress = req.Progress
r = d
}
report := packp.NewReportStatus()
if err := report.Decode(r); err != nil {
return nil, err
}
if err := report.Error(); err != nil {
defer s.Close()
return report, err
}
return report, s.Command.Close()
}
func (s *session) finish() error {
if s.finished {
return nil
}
s.finished = true
// If we did not run a upload/receive-pack, we close the connection
// gracefully by sending a flush packet to the server. If the server
// operates correctly, it will exit with status 0.
if !s.packRun {
_, err := s.Stdin.Write(pktline.FlushPkt)
return err
}
return nil
}
func (s *session) Close() (err error) {
err = s.finish()
defer ioutil.CheckClose(s.Command, &err)
return
}
func (s *session) checkNotFoundError() error {
t := time.NewTicker(time.Second * readErrorSecondsTimeout)
defer t.Stop()
select {
case <-t.C:
return ErrTimeoutExceeded
case line, ok := <-s.firstErrLine:
if !ok || len(line) == 0 {
return nil
}
if isRepoNotFoundError(line) {
return transport.ErrRepositoryNotFound
}
// TODO:(v6): return server error just as it is without a prefix
return fmt.Errorf("unknown error: %s", line)
}
}
const (
githubRepoNotFoundErr = "Repository not found."
bitbucketRepoNotFoundErr = "repository does not exist."
localRepoNotFoundErr = "does not appear to be a git repository"
gitProtocolNotFoundErr = "Repository not found."
gitProtocolNoSuchErr = "no such repository"
gitProtocolAccessDeniedErr = "access denied"
gogsAccessDeniedErr = "Repository does not exist or you do not have access"
gitlabRepoNotFoundErr = "The project you were looking for could not be found"
)
func isRepoNotFoundError(s string) bool {
for _, err := range []string{
githubRepoNotFoundErr,
bitbucketRepoNotFoundErr,
localRepoNotFoundErr,
gitProtocolNotFoundErr,
gitProtocolNoSuchErr,
gitProtocolAccessDeniedErr,
gogsAccessDeniedErr,
gitlabRepoNotFoundErr,
} {
if strings.Contains(s, err) {
return true
}
}
return false
}
// uploadPack implements the git-upload-pack protocol.
func uploadPack(w io.WriteCloser, _ io.Reader, req *packp.UploadPackRequest) error {
// TODO support multi_ack mode
// TODO support multi_ack_detailed mode
// TODO support acks for common objects
// TODO build a proper state machine for all these processing options
if err := req.UploadRequest.Encode(w); err != nil {
return fmt.Errorf("sending upload-req message: %s", err)
}
if err := req.UploadHaves.Encode(w, true); err != nil {
return fmt.Errorf("sending haves message: %s", err)
}
if err := sendDone(w); err != nil {
return fmt.Errorf("sending done message: %s", err)
}
if err := w.Close(); err != nil {
return fmt.Errorf("closing input: %s", err)
}
return nil
}
func sendDone(w io.Writer) error {
e := pktline.NewEncoder(w)
return e.Encodef("done\n")
}
// DecodeUploadPackResponse decodes r into a new packp.UploadPackResponse
func DecodeUploadPackResponse(r io.ReadCloser, req *packp.UploadPackRequest) (
*packp.UploadPackResponse, error,
) {
res := packp.NewUploadPackResponse(req)
if err := res.Decode(r); err != nil {
return nil, fmt.Errorf("error decoding upload-pack response: %s", err)
}
return res, nil
}
go-git-5.13.2/plumbing/transport/internal/common/common_test.go 0000664 0000000 0000000 00000004063 14744245500 0024633 0 ustar 00root root 0000000 0000000 package common
import (
"fmt"
"testing"
"github.com/go-git/go-git/v5/plumbing/transport"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type CommonSuite struct{}
var _ = Suite(&CommonSuite{})
func (s *CommonSuite) TestIsRepoNotFoundErrorForUnknownSource(c *C) {
msg := "unknown system is complaining of something very sad :("
isRepoNotFound := isRepoNotFoundError(msg)
c.Assert(isRepoNotFound, Equals, false)
}
func (s *CommonSuite) TestIsRepoNotFoundError(c *C) {
msg := "no such repository : some error stuf"
isRepoNotFound := isRepoNotFoundError(msg)
c.Assert(isRepoNotFound, Equals, true)
}
func (s *CommonSuite) TestCheckNotFoundError(c *C) {
firstErrLine := make(chan string, 1)
session := session{
firstErrLine: firstErrLine,
}
firstErrLine <- ""
err := session.checkNotFoundError()
c.Assert(err, IsNil)
}
func TestAdvertisedReferencesWithRemoteError(t *testing.T) {
tests := []struct {
name string
stderr string
wantErr error
}{
{
name: "unknown error",
stderr: "something",
wantErr: fmt.Errorf("unknown error: something"),
},
{
name: "GitLab: repository not found",
stderr: `remote:
remote: ========================================================================
remote:
remote: ERROR: The project you were looking for could not be found or you don't have permission to view it.
remote:
remote: ========================================================================
remote:`,
wantErr: transport.ErrRepositoryNotFound,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
client := NewClient(MockCommander{stderr: tt.stderr})
sess, err := client.NewUploadPackSession(nil, nil)
if err != nil {
t.Fatalf("unexpected error: %s", err)
}
_, err = sess.AdvertisedReferences()
if tt.wantErr != nil {
if tt.wantErr != err {
if tt.wantErr.Error() != err.Error() {
t.Fatalf("expected a different error: got '%s', expected '%s'", err, tt.wantErr)
}
}
} else if err != nil {
t.Fatalf("unexpected error: %s", err)
}
})
}
}
go-git-5.13.2/plumbing/transport/internal/common/mocks.go 0000664 0000000 0000000 00000001546 14744245500 0023423 0 ustar 00root root 0000000 0000000 package common
import (
"bytes"
"io"
gogitioutil "github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-git/v5/plumbing/transport"
)
type MockCommand struct {
stdin bytes.Buffer
stdout bytes.Buffer
stderr bytes.Buffer
}
func (c MockCommand) StderrPipe() (io.Reader, error) {
return &c.stderr, nil
}
func (c MockCommand) StdinPipe() (io.WriteCloser, error) {
return gogitioutil.WriteNopCloser(&c.stdin), nil
}
func (c MockCommand) StdoutPipe() (io.Reader, error) {
return &c.stdout, nil
}
func (c MockCommand) Start() error {
return nil
}
func (c MockCommand) Close() error {
panic("not implemented")
}
type MockCommander struct {
stderr string
}
func (c MockCommander) Command(cmd string, ep *transport.Endpoint, auth transport.AuthMethod) (Command, error) {
return &MockCommand{
stderr: *bytes.NewBufferString(c.stderr),
}, nil
}
go-git-5.13.2/plumbing/transport/internal/common/server.go 0000664 0000000 0000000 00000003115 14744245500 0023607 0 ustar 00root root 0000000 0000000 package common
import (
"context"
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/utils/ioutil"
)
// ServerCommand is used for a single server command execution.
type ServerCommand struct {
Stderr io.Writer
Stdout io.WriteCloser
Stdin io.Reader
}
func ServeUploadPack(cmd ServerCommand, s transport.UploadPackSession) (err error) {
ioutil.CheckClose(cmd.Stdout, &err)
ar, err := s.AdvertisedReferences()
if err != nil {
return err
}
if err := ar.Encode(cmd.Stdout); err != nil {
return err
}
req := packp.NewUploadPackRequest()
if err := req.Decode(cmd.Stdin); err != nil {
return err
}
var resp *packp.UploadPackResponse
resp, err = s.UploadPack(context.TODO(), req)
if err != nil {
return err
}
return resp.Encode(cmd.Stdout)
}
func ServeReceivePack(cmd ServerCommand, s transport.ReceivePackSession) error {
ar, err := s.AdvertisedReferences()
if err != nil {
return fmt.Errorf("internal error in advertised references: %s", err)
}
if err := ar.Encode(cmd.Stdout); err != nil {
return fmt.Errorf("error in advertised references encoding: %s", err)
}
req := packp.NewReferenceUpdateRequest()
if err := req.Decode(cmd.Stdin); err != nil {
return fmt.Errorf("error decoding: %s", err)
}
rs, err := s.ReceivePack(context.TODO(), req)
if rs != nil {
if err := rs.Encode(cmd.Stdout); err != nil {
return fmt.Errorf("error in encoding report status %s", err)
}
}
if err != nil {
return fmt.Errorf("error in receive pack: %s", err)
}
return nil
}
go-git-5.13.2/plumbing/transport/server/ 0000775 0000000 0000000 00000000000 14744245500 0020154 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/server/loader.go 0000664 0000000 0000000 00000004060 14744245500 0021751 0 ustar 00root root 0000000 0000000 package server
import (
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/osfs"
)
// DefaultLoader is a filesystem loader ignoring host and resolving paths to /.
var DefaultLoader = NewFilesystemLoader(osfs.New(""))
// Loader loads repository's storer.Storer based on an optional host and a path.
type Loader interface {
// Load loads a storer.Storer given a transport.Endpoint.
// Returns transport.ErrRepositoryNotFound if the repository does not
// exist.
Load(ep *transport.Endpoint) (storer.Storer, error)
}
type fsLoader struct {
base billy.Filesystem
}
// NewFilesystemLoader creates a Loader that ignores host and resolves paths
// with a given base filesystem.
func NewFilesystemLoader(base billy.Filesystem) Loader {
return &fsLoader{base}
}
// Load looks up the endpoint's path in the base file system and returns a
// storer for it. Returns transport.ErrRepositoryNotFound if a repository does
// not exist in the given path.
func (l *fsLoader) Load(ep *transport.Endpoint) (storer.Storer, error) {
fs, err := l.base.Chroot(ep.Path)
if err != nil {
return nil, err
}
var bare bool
if _, err := fs.Stat("config"); err == nil {
bare = true
}
if !bare {
// do not use git.GitDirName due to import cycle
if _, err := fs.Stat(".git"); err != nil {
return nil, transport.ErrRepositoryNotFound
}
}
return filesystem.NewStorage(fs, cache.NewObjectLRUDefault()), nil
}
// MapLoader is a Loader that uses a lookup map of storer.Storer by
// transport.Endpoint.
type MapLoader map[string]storer.Storer
// Load returns a storer.Storer for given a transport.Endpoint by looking it up
// in the map. Returns transport.ErrRepositoryNotFound if the endpoint does not
// exist.
func (l MapLoader) Load(ep *transport.Endpoint) (storer.Storer, error) {
s, ok := l[ep.String()]
if !ok {
return nil, transport.ErrRepositoryNotFound
}
return s, nil
}
go-git-5.13.2/plumbing/transport/server/loader_test.go 0000664 0000000 0000000 00000004102 14744245500 0023005 0 ustar 00root root 0000000 0000000 package server
import (
"os/exec"
"path/filepath"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
type loaderSuiteRepo struct {
bare bool
path string
}
type LoaderSuite struct {
Repos map[string]loaderSuiteRepo
}
var _ = Suite(&LoaderSuite{
Repos: map[string]loaderSuiteRepo{
"repo": {path: "repo.git"},
"bare": {path: "bare.git", bare: true},
},
})
func (s *LoaderSuite) SetUpSuite(c *C) {
if err := exec.Command("git", "--version").Run(); err != nil {
c.Skip("git command not found")
}
dir := c.MkDir()
for key, repo := range s.Repos {
repo.path = filepath.Join(dir, repo.path)
if repo.bare {
c.Assert(exec.Command("git", "init", "--bare", repo.path).Run(), IsNil)
} else {
c.Assert(exec.Command("git", "init", repo.path).Run(), IsNil)
}
s.Repos[key] = repo
}
}
func (s *LoaderSuite) endpoint(c *C, url string) *transport.Endpoint {
ep, err := transport.NewEndpoint(url)
c.Assert(err, IsNil)
return ep
}
func (s *LoaderSuite) TestLoadNonExistent(c *C) {
sto, err := DefaultLoader.Load(s.endpoint(c, "does-not-exist"))
c.Assert(err, Equals, transport.ErrRepositoryNotFound)
c.Assert(sto, IsNil)
}
func (s *LoaderSuite) TestLoadNonExistentIgnoreHost(c *C) {
sto, err := DefaultLoader.Load(s.endpoint(c, "https://github.com/does-not-exist"))
c.Assert(err, Equals, transport.ErrRepositoryNotFound)
c.Assert(sto, IsNil)
}
func (s *LoaderSuite) TestLoad(c *C) {
sto, err := DefaultLoader.Load(s.endpoint(c, s.Repos["repo"].path))
c.Assert(err, IsNil)
c.Assert(sto, NotNil)
}
func (s *LoaderSuite) TestLoadBare(c *C) {
sto, err := DefaultLoader.Load(s.endpoint(c, s.Repos["bare"].path))
c.Assert(err, IsNil)
c.Assert(sto, NotNil)
}
func (s *LoaderSuite) TestMapLoader(c *C) {
ep, err := transport.NewEndpoint("file://test")
sto := memory.NewStorage()
c.Assert(err, IsNil)
loader := MapLoader{ep.String(): sto}
ep, err = transport.NewEndpoint("file://test")
c.Assert(err, IsNil)
loaderSto, err := loader.Load(ep)
c.Assert(err, IsNil)
c.Assert(sto, Equals, loaderSto)
}
go-git-5.13.2/plumbing/transport/server/receive_pack_test.go 0000664 0000000 0000000 00000003225 14744245500 0024164 0 ustar 00root root 0000000 0000000 package server_test
import (
"context"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/transport"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type ReceivePackSuite struct {
BaseSuite
}
var _ = Suite(&ReceivePackSuite{})
func (s *ReceivePackSuite) SetUpSuite(c *C) {
s.BaseSuite.SetUpSuite(c)
s.ReceivePackSuite.Client = s.client
}
func (s *ReceivePackSuite) SetUpTest(c *C) {
s.prepareRepositories(c)
}
func (s *ReceivePackSuite) TearDownTest(c *C) {
s.Suite.TearDownSuite(c)
}
// Overwritten, server returns error earlier.
func (s *ReceivePackSuite) TestAdvertisedReferencesNotExists(c *C) {
r, err := s.Client.NewReceivePackSession(s.NonExistentEndpoint, s.EmptyAuth)
c.Assert(err, Equals, transport.ErrRepositoryNotFound)
c.Assert(r, IsNil)
}
func (s *ReceivePackSuite) TestReceivePackWithNilPackfile(c *C) {
endpoint := s.Endpoint
auth := s.EmptyAuth
fixture := fixtures.Basic().ByTag("packfile").One()
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{Name: "refs/heads/newbranch", Old: plumbing.NewHash(fixture.Head), New: plumbing.ZeroHash},
}
// default is already nil, but be explicit since this is what the test is for
req.Packfile = nil
comment := Commentf(
"failed with ep=%s fixture=%s",
endpoint.String(), fixture.URL,
)
r, err := s.Client.NewReceivePackSession(endpoint, auth)
c.Assert(err, IsNil, comment)
defer func() { c.Assert(r.Close(), IsNil, comment) }()
report, err := r.ReceivePack(context.Background(), req)
c.Assert(report, IsNil, comment)
c.Assert(err, NotNil, comment)
}
go-git-5.13.2/plumbing/transport/server/server.go 0000664 0000000 0000000 00000022217 14744245500 0022015 0 ustar 00root root 0000000 0000000 // Package server implements the git server protocol. For most use cases, the
// transport-specific implementations should be used.
package server
import (
"context"
"errors"
"fmt"
"io"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
"github.com/go-git/go-git/v5/plumbing/revlist"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/utils/ioutil"
)
var DefaultServer = NewServer(DefaultLoader)
type server struct {
loader Loader
handler *handler
}
// NewServer returns a transport.Transport implementing a git server,
// independent of transport. Each transport must wrap this.
func NewServer(loader Loader) transport.Transport {
return &server{
loader,
&handler{asClient: false},
}
}
// NewClient returns a transport.Transport implementing a client with an
// embedded server.
func NewClient(loader Loader) transport.Transport {
return &server{
loader,
&handler{asClient: true},
}
}
func (s *server) NewUploadPackSession(ep *transport.Endpoint, auth transport.AuthMethod) (transport.UploadPackSession, error) {
sto, err := s.loader.Load(ep)
if err != nil {
return nil, err
}
return s.handler.NewUploadPackSession(sto)
}
func (s *server) NewReceivePackSession(ep *transport.Endpoint, auth transport.AuthMethod) (transport.ReceivePackSession, error) {
sto, err := s.loader.Load(ep)
if err != nil {
return nil, err
}
return s.handler.NewReceivePackSession(sto)
}
type handler struct {
asClient bool
}
func (h *handler) NewUploadPackSession(s storer.Storer) (transport.UploadPackSession, error) {
return &upSession{
session: session{storer: s, asClient: h.asClient},
}, nil
}
func (h *handler) NewReceivePackSession(s storer.Storer) (transport.ReceivePackSession, error) {
return &rpSession{
session: session{storer: s, asClient: h.asClient},
cmdStatus: map[plumbing.ReferenceName]error{},
}, nil
}
type session struct {
storer storer.Storer
caps *capability.List
asClient bool
}
func (s *session) Close() error {
return nil
}
func (s *session) SetAuth(transport.AuthMethod) error {
//TODO: deprecate
return nil
}
func (s *session) checkSupportedCapabilities(cl *capability.List) error {
for _, c := range cl.All() {
if !s.caps.Supports(c) {
return fmt.Errorf("unsupported capability: %s", c)
}
}
return nil
}
type upSession struct {
session
}
func (s *upSession) AdvertisedReferences() (*packp.AdvRefs, error) {
return s.AdvertisedReferencesContext(context.TODO())
}
func (s *upSession) AdvertisedReferencesContext(ctx context.Context) (*packp.AdvRefs, error) {
ar := packp.NewAdvRefs()
if err := s.setSupportedCapabilities(ar.Capabilities); err != nil {
return nil, err
}
s.caps = ar.Capabilities
if err := setReferences(s.storer, ar); err != nil {
return nil, err
}
if err := setHEAD(s.storer, ar); err != nil {
return nil, err
}
if s.asClient && len(ar.References) == 0 {
return nil, transport.ErrEmptyRemoteRepository
}
return ar, nil
}
func (s *upSession) UploadPack(ctx context.Context, req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) {
if req.IsEmpty() {
return nil, transport.ErrEmptyUploadPackRequest
}
if err := req.Validate(); err != nil {
return nil, err
}
if s.caps == nil {
s.caps = capability.NewList()
if err := s.setSupportedCapabilities(s.caps); err != nil {
return nil, err
}
}
if err := s.checkSupportedCapabilities(req.Capabilities); err != nil {
return nil, err
}
s.caps = req.Capabilities
if len(req.Shallows) > 0 {
return nil, fmt.Errorf("shallow not supported")
}
objs, err := s.objectsToUpload(req)
if err != nil {
return nil, err
}
pr, pw := io.Pipe()
e := packfile.NewEncoder(pw, s.storer, false)
go func() {
// TODO: plumb through a pack window.
_, err := e.Encode(objs, 10)
pw.CloseWithError(err)
}()
return packp.NewUploadPackResponseWithPackfile(req,
ioutil.NewContextReadCloser(ctx, pr),
), nil
}
func (s *upSession) objectsToUpload(req *packp.UploadPackRequest) ([]plumbing.Hash, error) {
haves, err := revlist.Objects(s.storer, req.Haves, nil)
if err != nil {
return nil, err
}
return revlist.Objects(s.storer, req.Wants, haves)
}
func (*upSession) setSupportedCapabilities(c *capability.List) error {
if err := c.Set(capability.Agent, capability.DefaultAgent()); err != nil {
return err
}
if err := c.Set(capability.OFSDelta); err != nil {
return err
}
return nil
}
type rpSession struct {
session
cmdStatus map[plumbing.ReferenceName]error
firstErr error
unpackErr error
}
func (s *rpSession) AdvertisedReferences() (*packp.AdvRefs, error) {
return s.AdvertisedReferencesContext(context.TODO())
}
func (s *rpSession) AdvertisedReferencesContext(ctx context.Context) (*packp.AdvRefs, error) {
ar := packp.NewAdvRefs()
if err := s.setSupportedCapabilities(ar.Capabilities); err != nil {
return nil, err
}
s.caps = ar.Capabilities
if err := setReferences(s.storer, ar); err != nil {
return nil, err
}
if err := setHEAD(s.storer, ar); err != nil {
return nil, err
}
return ar, nil
}
var (
ErrUpdateReference = errors.New("failed to update ref")
)
func (s *rpSession) ReceivePack(ctx context.Context, req *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) {
if s.caps == nil {
s.caps = capability.NewList()
if err := s.setSupportedCapabilities(s.caps); err != nil {
return nil, err
}
}
if err := s.checkSupportedCapabilities(req.Capabilities); err != nil {
return nil, err
}
s.caps = req.Capabilities
//TODO: Implement 'atomic' update of references.
if req.Packfile != nil {
r := ioutil.NewContextReadCloser(ctx, req.Packfile)
if err := s.writePackfile(r); err != nil {
s.unpackErr = err
s.firstErr = err
return s.reportStatus(), err
}
}
s.updateReferences(req)
return s.reportStatus(), s.firstErr
}
func (s *rpSession) updateReferences(req *packp.ReferenceUpdateRequest) {
for _, cmd := range req.Commands {
exists, err := referenceExists(s.storer, cmd.Name)
if err != nil {
s.setStatus(cmd.Name, err)
continue
}
switch cmd.Action() {
case packp.Create:
if exists {
s.setStatus(cmd.Name, ErrUpdateReference)
continue
}
ref := plumbing.NewHashReference(cmd.Name, cmd.New)
err := s.storer.SetReference(ref)
s.setStatus(cmd.Name, err)
case packp.Delete:
if !exists {
s.setStatus(cmd.Name, ErrUpdateReference)
continue
}
err := s.storer.RemoveReference(cmd.Name)
s.setStatus(cmd.Name, err)
case packp.Update:
if !exists {
s.setStatus(cmd.Name, ErrUpdateReference)
continue
}
ref := plumbing.NewHashReference(cmd.Name, cmd.New)
err := s.storer.SetReference(ref)
s.setStatus(cmd.Name, err)
}
}
}
func (s *rpSession) writePackfile(r io.ReadCloser) error {
if r == nil {
return nil
}
if err := packfile.UpdateObjectStorage(s.storer, r); err != nil {
_ = r.Close()
return err
}
return r.Close()
}
func (s *rpSession) setStatus(ref plumbing.ReferenceName, err error) {
s.cmdStatus[ref] = err
if s.firstErr == nil && err != nil {
s.firstErr = err
}
}
func (s *rpSession) reportStatus() *packp.ReportStatus {
if !s.caps.Supports(capability.ReportStatus) {
return nil
}
rs := packp.NewReportStatus()
rs.UnpackStatus = "ok"
if s.unpackErr != nil {
rs.UnpackStatus = s.unpackErr.Error()
}
if s.cmdStatus == nil {
return rs
}
for ref, err := range s.cmdStatus {
msg := "ok"
if err != nil {
msg = err.Error()
}
status := &packp.CommandStatus{
ReferenceName: ref,
Status: msg,
}
rs.CommandStatuses = append(rs.CommandStatuses, status)
}
return rs
}
func (*rpSession) setSupportedCapabilities(c *capability.List) error {
if err := c.Set(capability.Agent, capability.DefaultAgent()); err != nil {
return err
}
if err := c.Set(capability.OFSDelta); err != nil {
return err
}
if err := c.Set(capability.DeleteRefs); err != nil {
return err
}
return c.Set(capability.ReportStatus)
}
func setHEAD(s storer.Storer, ar *packp.AdvRefs) error {
ref, err := s.Reference(plumbing.HEAD)
if err == plumbing.ErrReferenceNotFound {
return nil
}
if err != nil {
return err
}
if ref.Type() == plumbing.SymbolicReference {
if err := ar.AddReference(ref); err != nil {
return nil
}
ref, err = storer.ResolveReference(s, ref.Target())
if err == plumbing.ErrReferenceNotFound {
return nil
}
if err != nil {
return err
}
}
if ref.Type() != plumbing.HashReference {
return plumbing.ErrInvalidType
}
h := ref.Hash()
ar.Head = &h
return nil
}
func setReferences(s storer.Storer, ar *packp.AdvRefs) error {
//TODO: add peeled references.
iter, err := s.IterReferences()
if err != nil {
return err
}
return iter.ForEach(func(ref *plumbing.Reference) error {
if ref.Type() != plumbing.HashReference {
return nil
}
ar.References[ref.Name().String()] = ref.Hash()
return nil
})
}
func referenceExists(s storer.ReferenceStorer, n plumbing.ReferenceName) (bool, error) {
_, err := s.Reference(n)
if err == plumbing.ErrReferenceNotFound {
return false, nil
}
return err == nil, err
}
go-git-5.13.2/plumbing/transport/server/server_test.go 0000664 0000000 0000000 00000003146 14744245500 0023054 0 ustar 00root root 0000000 0000000 package server_test
import (
"testing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/client"
"github.com/go-git/go-git/v5/plumbing/transport/server"
"github.com/go-git/go-git/v5/plumbing/transport/test"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-git/v5/storage/memory"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type BaseSuite struct {
fixtures.Suite
test.ReceivePackSuite
loader server.MapLoader
client transport.Transport
clientBackup transport.Transport
asClient bool
}
func (s *BaseSuite) SetUpSuite(c *C) {
s.loader = server.MapLoader{}
if s.asClient {
s.client = server.NewClient(s.loader)
} else {
s.client = server.NewServer(s.loader)
}
s.clientBackup = client.Protocols["file"]
client.Protocols["file"] = s.client
}
func (s *BaseSuite) TearDownSuite(c *C) {
if s.clientBackup == nil {
delete(client.Protocols, "file")
} else {
client.Protocols["file"] = s.clientBackup
}
}
func (s *BaseSuite) prepareRepositories(c *C) {
var err error
fs := fixtures.Basic().One().DotGit()
s.Endpoint, err = transport.NewEndpoint(fs.Root())
c.Assert(err, IsNil)
s.loader[s.Endpoint.String()] = filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
s.EmptyEndpoint, err = transport.NewEndpoint("/empty.git")
c.Assert(err, IsNil)
s.loader[s.EmptyEndpoint.String()] = memory.NewStorage()
s.NonExistentEndpoint, err = transport.NewEndpoint("/non-existent.git")
c.Assert(err, IsNil)
}
go-git-5.13.2/plumbing/transport/server/upload_pack_test.go 0000664 0000000 0000000 00000002300 14744245500 0024017 0 ustar 00root root 0000000 0000000 package server_test
import (
"github.com/go-git/go-git/v5/plumbing/transport"
. "gopkg.in/check.v1"
)
type UploadPackSuite struct {
BaseSuite
}
var _ = Suite(&UploadPackSuite{})
func (s *UploadPackSuite) SetUpSuite(c *C) {
s.BaseSuite.SetUpSuite(c)
s.Client = s.client
}
func (s *UploadPackSuite) SetUpTest(c *C) {
s.prepareRepositories(c)
}
// Overwritten, server returns error earlier.
func (s *UploadPackSuite) TestAdvertisedReferencesNotExists(c *C) {
r, err := s.Client.NewUploadPackSession(s.NonExistentEndpoint, s.EmptyAuth)
c.Assert(err, Equals, transport.ErrRepositoryNotFound)
c.Assert(r, IsNil)
}
func (s *UploadPackSuite) TestUploadPackWithContext(c *C) {
c.Skip("UploadPack cannot be canceled on server")
}
// Tests server with `asClient = true`. This is recommended when using a server
// registered directly with `client.InstallProtocol`.
type ClientLikeUploadPackSuite struct {
UploadPackSuite
}
var _ = Suite(&ClientLikeUploadPackSuite{})
func (s *ClientLikeUploadPackSuite) SetUpSuite(c *C) {
s.asClient = true
s.UploadPackSuite.SetUpSuite(c)
}
func (s *ClientLikeUploadPackSuite) TestAdvertisedReferencesEmpty(c *C) {
s.UploadPackSuite.TestAdvertisedReferencesEmpty(c)
}
go-git-5.13.2/plumbing/transport/ssh/ 0000775 0000000 0000000 00000000000 14744245500 0017443 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/ssh/auth_method.go 0000664 0000000 0000000 00000020164 14744245500 0022276 0 ustar 00root root 0000000 0000000 package ssh
import (
"errors"
"fmt"
"os"
"os/user"
"path/filepath"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/skeema/knownhosts"
sshagent "github.com/xanzy/ssh-agent"
"golang.org/x/crypto/ssh"
)
const DefaultUsername = "git"
// AuthMethod is the interface all auth methods for the ssh client
// must implement. The clientConfig method returns the ssh client
// configuration needed to establish an ssh connection.
type AuthMethod interface {
transport.AuthMethod
// ClientConfig should return a valid ssh.ClientConfig to be used to create
// a connection to the SSH server.
ClientConfig() (*ssh.ClientConfig, error)
}
// The names of the AuthMethod implementations. To be returned by the
// Name() method. Most git servers only allow PublicKeysName and
// PublicKeysCallbackName.
const (
KeyboardInteractiveName = "ssh-keyboard-interactive"
PasswordName = "ssh-password"
PasswordCallbackName = "ssh-password-callback"
PublicKeysName = "ssh-public-keys"
PublicKeysCallbackName = "ssh-public-key-callback"
)
// KeyboardInteractive implements AuthMethod by using a
// prompt/response sequence controlled by the server.
type KeyboardInteractive struct {
User string
Challenge ssh.KeyboardInteractiveChallenge
HostKeyCallbackHelper
}
func (a *KeyboardInteractive) Name() string {
return KeyboardInteractiveName
}
func (a *KeyboardInteractive) String() string {
return fmt.Sprintf("user: %s, name: %s", a.User, a.Name())
}
func (a *KeyboardInteractive) ClientConfig() (*ssh.ClientConfig, error) {
return a.SetHostKeyCallback(&ssh.ClientConfig{
User: a.User,
Auth: []ssh.AuthMethod{
a.Challenge,
},
})
}
// Password implements AuthMethod by using the given password.
type Password struct {
User string
Password string
HostKeyCallbackHelper
}
func (a *Password) Name() string {
return PasswordName
}
func (a *Password) String() string {
return fmt.Sprintf("user: %s, name: %s", a.User, a.Name())
}
func (a *Password) ClientConfig() (*ssh.ClientConfig, error) {
return a.SetHostKeyCallback(&ssh.ClientConfig{
User: a.User,
Auth: []ssh.AuthMethod{ssh.Password(a.Password)},
})
}
// PasswordCallback implements AuthMethod by using a callback
// to fetch the password.
type PasswordCallback struct {
User string
Callback func() (pass string, err error)
HostKeyCallbackHelper
}
func (a *PasswordCallback) Name() string {
return PasswordCallbackName
}
func (a *PasswordCallback) String() string {
return fmt.Sprintf("user: %s, name: %s", a.User, a.Name())
}
func (a *PasswordCallback) ClientConfig() (*ssh.ClientConfig, error) {
return a.SetHostKeyCallback(&ssh.ClientConfig{
User: a.User,
Auth: []ssh.AuthMethod{ssh.PasswordCallback(a.Callback)},
})
}
// PublicKeys implements AuthMethod by using the given key pairs.
type PublicKeys struct {
User string
Signer ssh.Signer
HostKeyCallbackHelper
}
// NewPublicKeys returns a PublicKeys from a PEM encoded private key. An
// encryption password should be given if the pemBytes contains a password
// encrypted PEM block otherwise password should be empty. It supports RSA
// (PKCS#1), PKCS#8, DSA (OpenSSL), and ECDSA private keys.
func NewPublicKeys(user string, pemBytes []byte, password string) (*PublicKeys, error) {
signer, err := ssh.ParsePrivateKey(pemBytes)
if _, ok := err.(*ssh.PassphraseMissingError); ok {
signer, err = ssh.ParsePrivateKeyWithPassphrase(pemBytes, []byte(password))
}
if err != nil {
return nil, err
}
return &PublicKeys{User: user, Signer: signer}, nil
}
// NewPublicKeysFromFile returns a PublicKeys from a file containing a PEM
// encoded private key. An encryption password should be given if the pemBytes
// contains a password encrypted PEM block otherwise password should be empty.
func NewPublicKeysFromFile(user, pemFile, password string) (*PublicKeys, error) {
bytes, err := os.ReadFile(pemFile)
if err != nil {
return nil, err
}
return NewPublicKeys(user, bytes, password)
}
func (a *PublicKeys) Name() string {
return PublicKeysName
}
func (a *PublicKeys) String() string {
return fmt.Sprintf("user: %s, name: %s", a.User, a.Name())
}
func (a *PublicKeys) ClientConfig() (*ssh.ClientConfig, error) {
return a.SetHostKeyCallback(&ssh.ClientConfig{
User: a.User,
Auth: []ssh.AuthMethod{ssh.PublicKeys(a.Signer)},
})
}
func username() (string, error) {
var username string
if user, err := user.Current(); err == nil {
username = user.Username
} else {
username = os.Getenv("USER")
}
if username == "" {
return "", errors.New("failed to get username")
}
return username, nil
}
// PublicKeysCallback implements AuthMethod by asking a
// ssh.agent.Agent to act as a signer.
type PublicKeysCallback struct {
User string
Callback func() (signers []ssh.Signer, err error)
HostKeyCallbackHelper
}
// NewSSHAgentAuth returns a PublicKeysCallback based on a SSH agent, it opens
// a pipe with the SSH agent and uses the pipe as the implementer of the public
// key callback function.
func NewSSHAgentAuth(u string) (*PublicKeysCallback, error) {
var err error
if u == "" {
u, err = username()
if err != nil {
return nil, err
}
}
a, _, err := sshagent.New()
if err != nil {
return nil, fmt.Errorf("error creating SSH agent: %q", err)
}
return &PublicKeysCallback{
User: u,
Callback: a.Signers,
}, nil
}
func (a *PublicKeysCallback) Name() string {
return PublicKeysCallbackName
}
func (a *PublicKeysCallback) String() string {
return fmt.Sprintf("user: %s, name: %s", a.User, a.Name())
}
func (a *PublicKeysCallback) ClientConfig() (*ssh.ClientConfig, error) {
return a.SetHostKeyCallback(&ssh.ClientConfig{
User: a.User,
Auth: []ssh.AuthMethod{ssh.PublicKeysCallback(a.Callback)},
})
}
// NewKnownHostsCallback returns ssh.HostKeyCallback based on a file based on a
// known_hosts file. http://man.openbsd.org/sshd#SSH_KNOWN_HOSTS_FILE_FORMAT
//
// If list of files is empty, then it will be read from the SSH_KNOWN_HOSTS
// environment variable, example:
//
// /home/foo/custom_known_hosts_file:/etc/custom_known/hosts_file
//
// If SSH_KNOWN_HOSTS is not set the following file locations will be used:
//
// ~/.ssh/known_hosts
// /etc/ssh/ssh_known_hosts
func NewKnownHostsCallback(files ...string) (ssh.HostKeyCallback, error) {
kh, err := newKnownHosts(files...)
return ssh.HostKeyCallback(kh), err
}
func newKnownHosts(files ...string) (knownhosts.HostKeyCallback, error) {
var err error
if len(files) == 0 {
if files, err = getDefaultKnownHostsFiles(); err != nil {
return nil, err
}
}
if files, err = filterKnownHostsFiles(files...); err != nil {
return nil, err
}
return knownhosts.New(files...)
}
func getDefaultKnownHostsFiles() ([]string, error) {
files := filepath.SplitList(os.Getenv("SSH_KNOWN_HOSTS"))
if len(files) != 0 {
return files, nil
}
homeDirPath, err := os.UserHomeDir()
if err != nil {
return nil, err
}
return []string{
filepath.Join(homeDirPath, "/.ssh/known_hosts"),
"/etc/ssh/ssh_known_hosts",
}, nil
}
func filterKnownHostsFiles(files ...string) ([]string, error) {
var out []string
for _, file := range files {
_, err := os.Stat(file)
if err == nil {
out = append(out, file)
continue
}
if !os.IsNotExist(err) {
return nil, err
}
}
if len(out) == 0 {
return nil, fmt.Errorf("unable to find any valid known_hosts file, set SSH_KNOWN_HOSTS env variable")
}
return out, nil
}
// HostKeyCallbackHelper is a helper that provides common functionality to
// configure HostKeyCallback into a ssh.ClientConfig.
type HostKeyCallbackHelper struct {
// HostKeyCallback is the function type used for verifying server keys.
// If nil default callback will be create using NewKnownHostsCallback
// without argument.
HostKeyCallback ssh.HostKeyCallback
}
// SetHostKeyCallback sets the field HostKeyCallback in the given cfg. If
// HostKeyCallback is empty a default callback is created using
// NewKnownHostsCallback.
func (m *HostKeyCallbackHelper) SetHostKeyCallback(cfg *ssh.ClientConfig) (*ssh.ClientConfig, error) {
var err error
if m.HostKeyCallback == nil {
if m.HostKeyCallback, err = NewKnownHostsCallback(); err != nil {
return cfg, err
}
}
cfg.HostKeyCallback = m.HostKeyCallback
return cfg, nil
}
go-git-5.13.2/plumbing/transport/ssh/auth_method_test.go 0000664 0000000 0000000 00000013215 14744245500 0023334 0 ustar 00root root 0000000 0000000 package ssh
import (
"bufio"
"fmt"
"os"
"runtime"
"strings"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-billy/v5/util"
"golang.org/x/crypto/ssh"
"golang.org/x/crypto/ssh/testdata"
. "gopkg.in/check.v1"
)
type (
SuiteCommon struct{}
mockKnownHosts struct{}
)
func (mockKnownHosts) host() string { return "github.com" }
func (mockKnownHosts) knownHosts() []byte {
return []byte(`github.com ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ==`)
}
func (mockKnownHosts) Network() string { return "tcp" }
func (mockKnownHosts) String() string { return "github.com:22" }
var _ = Suite(&SuiteCommon{})
func (s *SuiteCommon) TestKeyboardInteractiveName(c *C) {
a := &KeyboardInteractive{
User: "test",
Challenge: nil,
}
c.Assert(a.Name(), Equals, KeyboardInteractiveName)
}
func (s *SuiteCommon) TestKeyboardInteractiveString(c *C) {
a := &KeyboardInteractive{
User: "test",
Challenge: nil,
}
c.Assert(a.String(), Equals, fmt.Sprintf("user: test, name: %s", KeyboardInteractiveName))
}
func (s *SuiteCommon) TestPasswordName(c *C) {
a := &Password{
User: "test",
Password: "",
}
c.Assert(a.Name(), Equals, PasswordName)
}
func (s *SuiteCommon) TestPasswordString(c *C) {
a := &Password{
User: "test",
Password: "",
}
c.Assert(a.String(), Equals, fmt.Sprintf("user: test, name: %s", PasswordName))
}
func (s *SuiteCommon) TestPasswordCallbackName(c *C) {
a := &PasswordCallback{
User: "test",
Callback: nil,
}
c.Assert(a.Name(), Equals, PasswordCallbackName)
}
func (s *SuiteCommon) TestPasswordCallbackString(c *C) {
a := &PasswordCallback{
User: "test",
Callback: nil,
}
c.Assert(a.String(), Equals, fmt.Sprintf("user: test, name: %s", PasswordCallbackName))
}
func (s *SuiteCommon) TestPublicKeysName(c *C) {
a := &PublicKeys{
User: "test",
Signer: nil,
}
c.Assert(a.Name(), Equals, PublicKeysName)
}
func (s *SuiteCommon) TestPublicKeysString(c *C) {
a := &PublicKeys{
User: "test",
Signer: nil,
}
c.Assert(a.String(), Equals, fmt.Sprintf("user: test, name: %s", PublicKeysName))
}
func (s *SuiteCommon) TestPublicKeysCallbackName(c *C) {
a := &PublicKeysCallback{
User: "test",
Callback: nil,
}
c.Assert(a.Name(), Equals, PublicKeysCallbackName)
}
func (s *SuiteCommon) TestPublicKeysCallbackString(c *C) {
a := &PublicKeysCallback{
User: "test",
Callback: nil,
}
c.Assert(a.String(), Equals, fmt.Sprintf("user: test, name: %s", PublicKeysCallbackName))
}
func (s *SuiteCommon) TestNewSSHAgentAuth(c *C) {
if runtime.GOOS == "js" {
c.Skip("tcp connections are not available in wasm")
}
if os.Getenv("SSH_AUTH_SOCK") == "" {
c.Skip("SSH_AUTH_SOCK or SSH_TEST_PRIVATE_KEY are required")
}
auth, err := NewSSHAgentAuth("foo")
c.Assert(err, IsNil)
c.Assert(auth, NotNil)
}
func (s *SuiteCommon) TestNewSSHAgentAuthNoAgent(c *C) {
addr := os.Getenv("SSH_AUTH_SOCK")
err := os.Unsetenv("SSH_AUTH_SOCK")
c.Assert(err, IsNil)
defer func() {
err := os.Setenv("SSH_AUTH_SOCK", addr)
c.Assert(err, IsNil)
}()
k, err := NewSSHAgentAuth("foo")
c.Assert(k, IsNil)
c.Assert(err, ErrorMatches, ".*SSH_AUTH_SOCK.*|.*SSH agent .* not detect.*")
}
func (*SuiteCommon) TestNewPublicKeys(c *C) {
auth, err := NewPublicKeys("foo", testdata.PEMBytes["rsa"], "")
c.Assert(err, IsNil)
c.Assert(auth, NotNil)
}
func (*SuiteCommon) TestNewPublicKeysWithEncryptedPEM(c *C) {
f := testdata.PEMEncryptedKeys[0]
auth, err := NewPublicKeys("foo", f.PEMBytes, f.EncryptionKey)
c.Assert(err, IsNil)
c.Assert(auth, NotNil)
}
func (*SuiteCommon) TestNewPublicKeysWithEncryptedEd25519PEM(c *C) {
f := testdata.PEMEncryptedKeys[2]
auth, err := NewPublicKeys("foo", f.PEMBytes, f.EncryptionKey)
c.Assert(err, IsNil)
c.Assert(auth, NotNil)
}
func (*SuiteCommon) TestNewPublicKeysFromFile(c *C) {
if runtime.GOOS == "js" {
c.Skip("not available in wasm")
}
f, err := util.TempFile(osfs.Default, "", "ssh-test")
c.Assert(err, IsNil)
_, err = f.Write(testdata.PEMBytes["rsa"])
c.Assert(err, IsNil)
c.Assert(f.Close(), IsNil)
defer osfs.Default.Remove(f.Name())
auth, err := NewPublicKeysFromFile("foo", f.Name(), "")
c.Assert(err, IsNil)
c.Assert(auth, NotNil)
}
func (*SuiteCommon) TestNewPublicKeysWithInvalidPEM(c *C) {
auth, err := NewPublicKeys("foo", []byte("bar"), "")
c.Assert(err, NotNil)
c.Assert(auth, IsNil)
}
func (*SuiteCommon) TestNewKnownHostsCallback(c *C) {
if runtime.GOOS == "js" {
c.Skip("not available in wasm")
}
var mock = mockKnownHosts{}
f, err := util.TempFile(osfs.Default, "", "known-hosts")
c.Assert(err, IsNil)
_, err = f.Write(mock.knownHosts())
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
defer util.RemoveAll(osfs.Default, f.Name())
f, err = osfs.Default.Open(f.Name())
c.Assert(err, IsNil)
defer f.Close()
var hostKey ssh.PublicKey
scanner := bufio.NewScanner(f)
for scanner.Scan() {
fields := strings.Split(scanner.Text(), " ")
if len(fields) != 3 {
continue
}
if strings.Contains(fields[0], mock.host()) {
var err error
hostKey, _, _, _, err = ssh.ParseAuthorizedKey(scanner.Bytes())
if err != nil {
c.Fatalf("error parsing %q: %v", fields[2], err)
}
break
}
}
if hostKey == nil {
c.Fatalf("no hostkey for %s", mock.host())
}
clb, err := NewKnownHostsCallback(f.Name())
c.Assert(err, IsNil)
err = clb(mock.String(), mock, hostKey)
c.Assert(err, IsNil)
}
go-git-5.13.2/plumbing/transport/ssh/common.go 0000664 0000000 0000000 00000014467 14744245500 0021276 0 ustar 00root root 0000000 0000000 // Package ssh implements the SSH transport protocol.
package ssh
import (
"context"
"fmt"
"net"
"reflect"
"strconv"
"strings"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/internal/common"
"github.com/skeema/knownhosts"
"github.com/kevinburke/ssh_config"
"golang.org/x/crypto/ssh"
"golang.org/x/net/proxy"
)
// DefaultClient is the default SSH client.
var DefaultClient = NewClient(nil)
// DefaultSSHConfig is the reader used to access parameters stored in the
// system's ssh_config files. If nil all the ssh_config are ignored.
var DefaultSSHConfig sshConfig = ssh_config.DefaultUserSettings
type sshConfig interface {
Get(alias, key string) string
}
// NewClient creates a new SSH client with an optional *ssh.ClientConfig.
func NewClient(config *ssh.ClientConfig) transport.Transport {
return common.NewClient(&runner{config: config})
}
// DefaultAuthBuilder is the function used to create a default AuthMethod, when
// the user doesn't provide any.
var DefaultAuthBuilder = func(user string) (AuthMethod, error) {
return NewSSHAgentAuth(user)
}
const DefaultPort = 22
type runner struct {
config *ssh.ClientConfig
}
func (r *runner) Command(cmd string, ep *transport.Endpoint, auth transport.AuthMethod) (common.Command, error) {
c := &command{command: cmd, endpoint: ep, config: r.config}
if auth != nil {
if err := c.setAuth(auth); err != nil {
return nil, err
}
}
if err := c.connect(); err != nil {
return nil, err
}
return c, nil
}
type command struct {
*ssh.Session
connected bool
command string
endpoint *transport.Endpoint
client *ssh.Client
auth AuthMethod
config *ssh.ClientConfig
}
func (c *command) setAuth(auth transport.AuthMethod) error {
a, ok := auth.(AuthMethod)
if !ok {
return transport.ErrInvalidAuthMethod
}
c.auth = a
return nil
}
func (c *command) Start() error {
return c.Session.Start(endpointToCommand(c.command, c.endpoint))
}
// Close closes the SSH session and connection.
func (c *command) Close() error {
if !c.connected {
return nil
}
c.connected = false
//XXX: If did read the full packfile, then the session might be already
// closed.
_ = c.Session.Close()
err := c.client.Close()
//XXX: in go1.16+ we can use errors.Is(err, net.ErrClosed)
if err != nil && strings.HasSuffix(err.Error(), "use of closed network connection") {
return nil
}
return err
}
// connect connects to the SSH server, unless a AuthMethod was set with
// SetAuth method, by default uses an auth method based on PublicKeysCallback,
// it connects to a SSH agent, using the address stored in the SSH_AUTH_SOCK
// environment var.
func (c *command) connect() error {
if c.connected {
return transport.ErrAlreadyConnected
}
if c.auth == nil {
if err := c.setAuthFromEndpoint(); err != nil {
return err
}
}
var err error
config, err := c.auth.ClientConfig()
if err != nil {
return err
}
hostWithPort := c.getHostWithPort()
if config.HostKeyCallback == nil {
kh, err := newKnownHosts()
if err != nil {
return err
}
config.HostKeyCallback = kh.HostKeyCallback()
config.HostKeyAlgorithms = kh.HostKeyAlgorithms(hostWithPort)
} else if len(config.HostKeyAlgorithms) == 0 {
// Set the HostKeyAlgorithms based on HostKeyCallback.
// For background see https://github.com/go-git/go-git/issues/411 as well as
// https://github.com/golang/go/issues/29286 for root cause.
config.HostKeyAlgorithms = knownhosts.HostKeyAlgorithms(config.HostKeyCallback, hostWithPort)
}
overrideConfig(c.config, config)
c.client, err = dial("tcp", hostWithPort, c.endpoint.Proxy, config)
if err != nil {
return err
}
c.Session, err = c.client.NewSession()
if err != nil {
_ = c.client.Close()
return err
}
c.connected = true
return nil
}
func dial(network, addr string, proxyOpts transport.ProxyOptions, config *ssh.ClientConfig) (*ssh.Client, error) {
var (
ctx = context.Background()
cancel context.CancelFunc
)
if config.Timeout > 0 {
ctx, cancel = context.WithTimeout(ctx, config.Timeout)
} else {
ctx, cancel = context.WithCancel(ctx)
}
defer cancel()
var conn net.Conn
var dialErr error
if proxyOpts.URL != "" {
proxyUrl, err := proxyOpts.FullURL()
if err != nil {
return nil, err
}
dialer, err := proxy.FromURL(proxyUrl, proxy.Direct)
if err != nil {
return nil, err
}
// Try to use a ContextDialer, but fall back to a Dialer if that goes south.
ctxDialer, ok := dialer.(proxy.ContextDialer)
if !ok {
return nil, fmt.Errorf("expected ssh proxy dialer to be of type %s; got %s",
reflect.TypeOf(ctxDialer), reflect.TypeOf(dialer))
}
conn, dialErr = ctxDialer.DialContext(ctx, "tcp", addr)
} else {
conn, dialErr = proxy.Dial(ctx, network, addr)
}
if dialErr != nil {
return nil, dialErr
}
c, chans, reqs, err := ssh.NewClientConn(conn, addr, config)
if err != nil {
return nil, err
}
return ssh.NewClient(c, chans, reqs), nil
}
func (c *command) getHostWithPort() string {
if addr, found := c.doGetHostWithPortFromSSHConfig(); found {
return addr
}
host := c.endpoint.Host
port := c.endpoint.Port
if port <= 0 {
port = DefaultPort
}
return net.JoinHostPort(host, strconv.Itoa(port))
}
func (c *command) doGetHostWithPortFromSSHConfig() (addr string, found bool) {
if DefaultSSHConfig == nil {
return
}
host := c.endpoint.Host
port := c.endpoint.Port
configHost := DefaultSSHConfig.Get(c.endpoint.Host, "Hostname")
if configHost != "" {
host = configHost
found = true
}
if !found {
return
}
configPort := DefaultSSHConfig.Get(c.endpoint.Host, "Port")
if configPort != "" {
if i, err := strconv.Atoi(configPort); err == nil {
port = i
}
}
addr = net.JoinHostPort(host, strconv.Itoa(port))
return
}
func (c *command) setAuthFromEndpoint() error {
var err error
c.auth, err = DefaultAuthBuilder(c.endpoint.User)
return err
}
func endpointToCommand(cmd string, ep *transport.Endpoint) string {
return fmt.Sprintf("%s '%s'", cmd, ep.Path)
}
func overrideConfig(overrides *ssh.ClientConfig, c *ssh.ClientConfig) {
if overrides == nil {
return
}
t := reflect.TypeOf(*c)
vc := reflect.ValueOf(c).Elem()
vo := reflect.ValueOf(overrides).Elem()
for i := 0; i < t.NumField(); i++ {
f := t.Field(i)
vcf := vc.FieldByName(f.Name)
vof := vo.FieldByName(f.Name)
vcf.Set(vof)
}
*c = vc.Interface().(ssh.ClientConfig)
}
go-git-5.13.2/plumbing/transport/ssh/common_test.go 0000664 0000000 0000000 00000013444 14744245500 0022327 0 ustar 00root root 0000000 0000000 package ssh
import (
"testing"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/gliderlabs/ssh"
"github.com/kevinburke/ssh_config"
stdssh "golang.org/x/crypto/ssh"
"golang.org/x/crypto/ssh/testdata"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
func (s *SuiteCommon) TestOverrideConfig(c *C) {
config := &stdssh.ClientConfig{
User: "foo",
Auth: []stdssh.AuthMethod{
stdssh.Password("yourpassword"),
},
HostKeyCallback: stdssh.FixedHostKey(nil),
}
target := &stdssh.ClientConfig{}
overrideConfig(config, target)
c.Assert(target.User, Equals, "foo")
c.Assert(target.Auth, HasLen, 1)
c.Assert(target.HostKeyCallback, NotNil)
}
func (s *SuiteCommon) TestOverrideConfigKeep(c *C) {
config := &stdssh.ClientConfig{
User: "foo",
}
target := &stdssh.ClientConfig{
User: "bar",
}
overrideConfig(config, target)
c.Assert(target.User, Equals, "foo")
}
func (s *SuiteCommon) TestDefaultSSHConfig(c *C) {
defer func() {
DefaultSSHConfig = ssh_config.DefaultUserSettings
}()
DefaultSSHConfig = &mockSSHConfig{map[string]map[string]string{
"github.com": {
"Hostname": "foo.local",
"Port": "42",
},
}}
ep, err := transport.NewEndpoint("git@github.com:foo/bar.git")
c.Assert(err, IsNil)
cmd := &command{endpoint: ep}
c.Assert(cmd.getHostWithPort(), Equals, "foo.local:42")
}
func (s *SuiteCommon) TestDefaultSSHConfigNil(c *C) {
defer func() {
DefaultSSHConfig = ssh_config.DefaultUserSettings
}()
DefaultSSHConfig = nil
ep, err := transport.NewEndpoint("git@github.com:foo/bar.git")
c.Assert(err, IsNil)
cmd := &command{endpoint: ep}
c.Assert(cmd.getHostWithPort(), Equals, "github.com:22")
}
func (s *SuiteCommon) TestDefaultSSHConfigWildcard(c *C) {
defer func() {
DefaultSSHConfig = ssh_config.DefaultUserSettings
}()
DefaultSSHConfig = &mockSSHConfig{Values: map[string]map[string]string{
"*": {
"Port": "42",
},
}}
ep, err := transport.NewEndpoint("git@github.com:foo/bar.git")
c.Assert(err, IsNil)
cmd := &command{endpoint: ep}
c.Assert(cmd.getHostWithPort(), Equals, "github.com:22")
}
func (s *SuiteCommon) TestIgnoreHostKeyCallback(c *C) {
uploadPack := &UploadPackSuite{
opts: []ssh.Option{
ssh.HostKeyPEM(testdata.PEMBytes["ed25519"]),
},
}
uploadPack.SetUpSuite(c)
// Use the default client, which does not have a host key callback
uploadPack.Client = DefaultClient
auth, err := NewPublicKeys("foo", testdata.PEMBytes["rsa"], "")
c.Assert(err, IsNil)
c.Assert(auth, NotNil)
auth.HostKeyCallback = stdssh.InsecureIgnoreHostKey()
ep := uploadPack.newEndpoint(c, "bar.git")
ps, err := uploadPack.Client.NewUploadPackSession(ep, auth)
c.Assert(err, IsNil)
c.Assert(ps, NotNil)
}
func (s *SuiteCommon) TestFixedHostKeyCallback(c *C) {
hostKey, err := stdssh.ParsePrivateKey(testdata.PEMBytes["ed25519"])
c.Assert(err, IsNil)
uploadPack := &UploadPackSuite{
opts: []ssh.Option{
ssh.HostKeyPEM(testdata.PEMBytes["ed25519"]),
},
}
uploadPack.SetUpSuite(c)
// Use the default client, which does not have a host key callback
uploadPack.Client = DefaultClient
auth, err := NewPublicKeys("foo", testdata.PEMBytes["rsa"], "")
c.Assert(err, IsNil)
c.Assert(auth, NotNil)
auth.HostKeyCallback = stdssh.FixedHostKey(hostKey.PublicKey())
ep := uploadPack.newEndpoint(c, "bar.git")
ps, err := uploadPack.Client.NewUploadPackSession(ep, auth)
c.Assert(err, IsNil)
c.Assert(ps, NotNil)
}
func (s *SuiteCommon) TestFailHostKeyCallback(c *C) {
uploadPack := &UploadPackSuite{
opts: []ssh.Option{
ssh.HostKeyPEM(testdata.PEMBytes["ed25519"]),
},
}
uploadPack.SetUpSuite(c)
// Use the default client, which does not have a host key callback
uploadPack.Client = DefaultClient
auth, err := NewPublicKeys("foo", testdata.PEMBytes["rsa"], "")
c.Assert(err, IsNil)
c.Assert(auth, NotNil)
ep := uploadPack.newEndpoint(c, "bar.git")
_, err = uploadPack.Client.NewUploadPackSession(ep, auth)
c.Assert(err, NotNil)
}
func (s *SuiteCommon) TestIssue70(c *C) {
uploadPack := &UploadPackSuite{}
uploadPack.SetUpSuite(c)
config := &stdssh.ClientConfig{
HostKeyCallback: stdssh.InsecureIgnoreHostKey(),
}
r := &runner{
config: config,
}
cmd, err := r.Command("command", uploadPack.newEndpoint(c, "endpoint"), uploadPack.EmptyAuth)
c.Assert(err, IsNil)
c.Assert(cmd.(*command).client.Close(), IsNil)
err = cmd.Close()
c.Assert(err, IsNil)
}
/*
Given, an endpoint to a git server with a socks5 proxy URL,
When, the socks5 proxy server is not reachable,
Then, there should not be any panic and an error with appropriate message should be returned.
Related issue : https://github.com/go-git/go-git/pull/900
*/
func (s *SuiteCommon) TestInvalidSocks5Proxy(c *C) {
ep, err := transport.NewEndpoint("git@github.com:foo/bar.git")
c.Assert(err, IsNil)
ep.Proxy.URL = "socks5://127.0.0.1:1080"
auth, err := NewPublicKeys("foo", testdata.PEMBytes["rsa"], "")
c.Assert(err, IsNil)
c.Assert(auth, NotNil)
ps, err := DefaultClient.NewUploadPackSession(ep, auth)
//Since the proxy server is not running, we expect an error.
c.Assert(ps, IsNil)
c.Assert(err, NotNil)
c.Assert(err, ErrorMatches, "socks connect .* dial tcp 127.0.0.1:1080: .*")
}
type mockSSHConfig struct {
Values map[string]map[string]string
}
func (c *mockSSHConfig) Get(alias, key string) string {
a, ok := c.Values[alias]
if !ok {
return c.Values["*"][key]
}
return a[key]
}
type invalidAuthMethod struct {
}
func (a *invalidAuthMethod) Name() string {
return "invalid"
}
func (a *invalidAuthMethod) String() string {
return "invalid"
}
func (s *SuiteCommon) TestCommandWithInvalidAuthMethod(c *C) {
uploadPack := &UploadPackSuite{}
uploadPack.SetUpSuite(c)
r := &runner{}
auth := &invalidAuthMethod{}
_, err := r.Command("command", uploadPack.newEndpoint(c, "endpoint"), auth)
c.Assert(err, NotNil)
c.Assert(err, ErrorMatches, "invalid auth method")
}
go-git-5.13.2/plumbing/transport/ssh/internal/ 0000775 0000000 0000000 00000000000 14744245500 0021257 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/ssh/internal/test/ 0000775 0000000 0000000 00000000000 14744245500 0022236 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/ssh/internal/test/proxy_test.go 0000664 0000000 0000000 00000005516 14744245500 0025014 0 ustar 00root root 0000000 0000000 package test
import (
"context"
"fmt"
"log"
"net"
"os"
"path/filepath"
"sync/atomic"
"testing"
"github.com/armon/go-socks5"
"github.com/gliderlabs/ssh"
"github.com/go-git/go-git/v5/plumbing/transport"
ggssh "github.com/go-git/go-git/v5/plumbing/transport/ssh"
fixtures "github.com/go-git/go-git-fixtures/v4"
stdssh "golang.org/x/crypto/ssh"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type ProxyEnvSuite struct {
fixtures.Suite
port int
base string
}
var _ = Suite(&ProxyEnvSuite{})
var socksProxiedRequests int32
// This test tests proxy support via an env var, i.e. `ALL_PROXY`.
// Its located in a separate package because golang caches the value
// of proxy env vars leading to misleading/unexpected test results.
func (s *ProxyEnvSuite) TestCommand(c *C) {
socksListener, err := net.Listen("tcp", "localhost:0")
c.Assert(err, IsNil)
socksServer, err := socks5.New(&socks5.Config{
Rules: TestProxyRule{},
})
c.Assert(err, IsNil)
go func() {
socksServer.Serve(socksListener)
}()
socksProxyAddr := fmt.Sprintf("socks5://localhost:%d", socksListener.Addr().(*net.TCPAddr).Port)
os.Setenv("ALL_PROXY", socksProxyAddr)
defer os.Unsetenv("ALL_PROXY")
sshListener, err := net.Listen("tcp", "localhost:0")
c.Assert(err, IsNil)
sshServer := &ssh.Server{Handler: HandlerSSH}
go func() {
log.Fatal(sshServer.Serve(sshListener))
}()
s.port = sshListener.Addr().(*net.TCPAddr).Port
s.base, err = os.MkdirTemp(c.MkDir(), fmt.Sprintf("go-git-ssh-%d", s.port))
c.Assert(err, IsNil)
ggssh.DefaultAuthBuilder = func(user string) (ggssh.AuthMethod, error) {
return &ggssh.Password{User: user}, nil
}
ep := s.prepareRepository(c, fixtures.Basic().One(), "basic.git")
c.Assert(err, IsNil)
client := ggssh.NewClient(&stdssh.ClientConfig{
HostKeyCallback: stdssh.InsecureIgnoreHostKey(),
})
r, err := client.NewUploadPackSession(ep, nil)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
info, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(info, NotNil)
proxyUsed := atomic.LoadInt32(&socksProxiedRequests) > 0
c.Assert(proxyUsed, Equals, true)
}
func (s *ProxyEnvSuite) prepareRepository(c *C, f *fixtures.Fixture, name string) *transport.Endpoint {
fs := f.DotGit()
err := fixtures.EnsureIsBare(fs)
c.Assert(err, IsNil)
path := filepath.Join(s.base, name)
err = os.Rename(fs.Root(), path)
c.Assert(err, IsNil)
return s.newEndpoint(c, name)
}
func (s *ProxyEnvSuite) newEndpoint(c *C, name string) *transport.Endpoint {
ep, err := transport.NewEndpoint(fmt.Sprintf(
"ssh://git@localhost:%d/%s/%s", s.port, filepath.ToSlash(s.base), name,
))
c.Assert(err, IsNil)
return ep
}
type TestProxyRule struct{}
func (dr TestProxyRule) Allow(ctx context.Context, req *socks5.Request) (context.Context, bool) {
atomic.AddInt32(&socksProxiedRequests, 1)
return ctx, true
}
go-git-5.13.2/plumbing/transport/ssh/internal/test/test_utils.go 0000664 0000000 0000000 00000002225 14744245500 0024765 0 ustar 00root root 0000000 0000000 package test
import (
"fmt"
"io"
"os/exec"
"runtime"
"strings"
"sync"
"github.com/gliderlabs/ssh"
)
func HandlerSSH(s ssh.Session) {
cmd, stdin, stderr, stdout, err := buildCommand(s.Command())
if err != nil {
fmt.Println(err)
return
}
if err := cmd.Start(); err != nil {
fmt.Println(err)
return
}
go func() {
defer stdin.Close()
io.Copy(stdin, s)
}()
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
io.Copy(s.Stderr(), stderr)
}()
go func() {
defer wg.Done()
io.Copy(s, stdout)
}()
wg.Wait()
if err := cmd.Wait(); err != nil {
return
}
}
func buildCommand(c []string) (cmd *exec.Cmd, stdin io.WriteCloser, stderr, stdout io.ReadCloser, err error) {
if len(c) != 2 {
err = fmt.Errorf("invalid command")
return
}
// fix for Windows environments
var path string
if runtime.GOOS == "windows" {
path = strings.Replace(c[1], "/C:/", "C:/", 1)
} else {
path = c[1]
}
cmd = exec.Command(c[0], path)
stdout, err = cmd.StdoutPipe()
if err != nil {
return
}
stdin, err = cmd.StdinPipe()
if err != nil {
return
}
stderr, err = cmd.StderrPipe()
if err != nil {
return
}
return
}
go-git-5.13.2/plumbing/transport/ssh/proxy_test.go 0000664 0000000 0000000 00000004125 14744245500 0022214 0 ustar 00root root 0000000 0000000 package ssh
import (
"context"
"fmt"
"log"
"net"
"os"
"sync/atomic"
"github.com/armon/go-socks5"
"github.com/gliderlabs/ssh"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/ssh/internal/test"
fixtures "github.com/go-git/go-git-fixtures/v4"
stdssh "golang.org/x/crypto/ssh"
. "gopkg.in/check.v1"
)
type ProxySuite struct {
u UploadPackSuite
fixtures.Suite
}
var _ = Suite(&ProxySuite{})
var socksProxiedRequests int32
func (s *ProxySuite) TestCommand(c *C) {
socksListener, err := net.Listen("tcp", "localhost:0")
c.Assert(err, IsNil)
socksServer, err := socks5.New(&socks5.Config{
AuthMethods: []socks5.Authenticator{socks5.UserPassAuthenticator{
Credentials: socks5.StaticCredentials{
"user": "pass",
},
}},
Rules: TestProxyRule{},
})
c.Assert(err, IsNil)
go func() {
socksServer.Serve(socksListener)
}()
socksProxyAddr := fmt.Sprintf("socks5://localhost:%d", socksListener.Addr().(*net.TCPAddr).Port)
sshListener, err := net.Listen("tcp", "localhost:0")
c.Assert(err, IsNil)
sshServer := &ssh.Server{Handler: test.HandlerSSH}
go func() {
log.Fatal(sshServer.Serve(sshListener))
}()
s.u.port = sshListener.Addr().(*net.TCPAddr).Port
s.u.base, err = os.MkdirTemp(c.MkDir(), fmt.Sprintf("go-git-ssh-%d", s.u.port))
c.Assert(err, IsNil)
DefaultAuthBuilder = func(user string) (AuthMethod, error) {
return &Password{User: user}, nil
}
ep := s.u.prepareRepository(c, fixtures.Basic().One(), "basic.git")
c.Assert(err, IsNil)
ep.Proxy = transport.ProxyOptions{
URL: socksProxyAddr,
Username: "user",
Password: "pass",
}
runner := runner{
config: &stdssh.ClientConfig{
HostKeyCallback: stdssh.InsecureIgnoreHostKey(),
},
}
_, err = runner.Command(transport.UploadPackServiceName, ep, nil)
c.Assert(err, IsNil)
proxyUsed := atomic.LoadInt32(&socksProxiedRequests) > 0
c.Assert(proxyUsed, Equals, true)
}
type TestProxyRule struct{}
func (dr TestProxyRule) Allow(ctx context.Context, req *socks5.Request) (context.Context, bool) {
atomic.AddInt32(&socksProxiedRequests, 1)
return ctx, true
}
go-git-5.13.2/plumbing/transport/ssh/upload_pack_test.go 0000664 0000000 0000000 00000006032 14744245500 0023314 0 ustar 00root root 0000000 0000000 package ssh
import (
"fmt"
"io"
"log"
"net"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"sync"
"github.com/go-git/go-git/v5/plumbing/transport"
testutils "github.com/go-git/go-git/v5/plumbing/transport/ssh/internal/test"
"github.com/go-git/go-git/v5/plumbing/transport/test"
"github.com/gliderlabs/ssh"
fixtures "github.com/go-git/go-git-fixtures/v4"
stdssh "golang.org/x/crypto/ssh"
. "gopkg.in/check.v1"
)
type UploadPackSuite struct {
test.UploadPackSuite
fixtures.Suite
opts []ssh.Option
port int
base string
}
var _ = Suite(&UploadPackSuite{})
func (s *UploadPackSuite) SetUpSuite(c *C) {
if runtime.GOOS == "js" {
c.Skip("tcp connections are not available in wasm")
}
l, err := net.Listen("tcp", "localhost:0")
c.Assert(err, IsNil)
s.port = l.Addr().(*net.TCPAddr).Port
s.base, err = os.MkdirTemp(c.MkDir(), fmt.Sprintf("go-git-ssh-%d", s.port))
c.Assert(err, IsNil)
DefaultAuthBuilder = func(user string) (AuthMethod, error) {
return &Password{User: user}, nil
}
s.UploadPackSuite.Client = NewClient(&stdssh.ClientConfig{
HostKeyCallback: stdssh.InsecureIgnoreHostKey(),
})
s.UploadPackSuite.Endpoint = s.prepareRepository(c, fixtures.Basic().One(), "basic.git")
s.UploadPackSuite.EmptyEndpoint = s.prepareRepository(c, fixtures.ByTag("empty").One(), "empty.git")
s.UploadPackSuite.NonExistentEndpoint = s.newEndpoint(c, "non-existent.git")
server := &ssh.Server{Handler: testutils.HandlerSSH}
for _, opt := range s.opts {
opt(server)
}
go func() {
log.Fatal(server.Serve(l))
}()
}
func (s *UploadPackSuite) prepareRepository(c *C, f *fixtures.Fixture, name string) *transport.Endpoint {
fs := f.DotGit()
err := fixtures.EnsureIsBare(fs)
c.Assert(err, IsNil)
path := filepath.Join(s.base, name)
err = os.Rename(fs.Root(), path)
c.Assert(err, IsNil)
return s.newEndpoint(c, name)
}
func (s *UploadPackSuite) newEndpoint(c *C, name string) *transport.Endpoint {
ep, err := transport.NewEndpoint(fmt.Sprintf(
"ssh://git@localhost:%d/%s/%s", s.port, filepath.ToSlash(s.base), name,
))
c.Assert(err, IsNil)
return ep
}
func handlerSSH(s ssh.Session) {
cmd, stdin, stderr, stdout, err := buildCommand(s.Command())
if err != nil {
fmt.Println(err)
return
}
if err := cmd.Start(); err != nil {
fmt.Println(err)
return
}
go func() {
defer stdin.Close()
io.Copy(stdin, s)
}()
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
io.Copy(s.Stderr(), stderr)
}()
go func() {
defer wg.Done()
io.Copy(s, stdout)
}()
wg.Wait()
if err := cmd.Wait(); err != nil {
return
}
}
func buildCommand(c []string) (cmd *exec.Cmd, stdin io.WriteCloser, stderr, stdout io.ReadCloser, err error) {
if len(c) != 2 {
err = fmt.Errorf("invalid command")
return
}
// fix for Windows environments
path := strings.Replace(c[1], "/C:/", "C:/", 1)
cmd = exec.Command(c[0], path)
stdout, err = cmd.StdoutPipe()
if err != nil {
return
}
stdin, err = cmd.StdinPipe()
if err != nil {
return
}
stderr, err = cmd.StderrPipe()
if err != nil {
return
}
return
}
go-git-5.13.2/plumbing/transport/test/ 0000775 0000000 0000000 00000000000 14744245500 0017625 5 ustar 00root root 0000000 0000000 go-git-5.13.2/plumbing/transport/test/receive_pack.go 0000664 0000000 0000000 00000027556 14744245500 0022613 0 ustar 00root root 0000000 0000000 // Package test implements common test suite for different transport
// implementations.
package test
import (
"bytes"
"context"
"io"
"os"
"path/filepath"
. "github.com/go-git/go-git/v5/internal/test"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/storage/memory"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type ReceivePackSuite struct {
Endpoint *transport.Endpoint
EmptyEndpoint *transport.Endpoint
NonExistentEndpoint *transport.Endpoint
EmptyAuth transport.AuthMethod
Client transport.Transport
}
func (s *ReceivePackSuite) TestAdvertisedReferencesEmpty(c *C) {
r, err := s.Client.NewReceivePackSession(s.EmptyEndpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
ar, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(ar.Head, IsNil)
}
func (s *ReceivePackSuite) TestAdvertisedReferencesNotExists(c *C) {
r, err := s.Client.NewReceivePackSession(s.NonExistentEndpoint, s.EmptyAuth)
c.Assert(err, IsNil)
ar, err := r.AdvertisedReferences()
c.Assert(err, ErrorIs, transport.ErrRepositoryNotFound)
c.Assert(ar, IsNil)
c.Assert(r.Close(), IsNil)
r, err = s.Client.NewReceivePackSession(s.NonExistentEndpoint, s.EmptyAuth)
c.Assert(err, IsNil)
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{Name: "master", Old: plumbing.ZeroHash, New: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")},
}
writer, err := r.ReceivePack(context.Background(), req)
c.Assert(err, ErrorIs, transport.ErrRepositoryNotFound)
c.Assert(writer, IsNil)
c.Assert(r.Close(), IsNil)
}
func (s *ReceivePackSuite) TestCallAdvertisedReferenceTwice(c *C) {
r, err := s.Client.NewReceivePackSession(s.Endpoint, s.EmptyAuth)
defer func() { c.Assert(r.Close(), IsNil) }()
c.Assert(err, IsNil)
ar1, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(ar1, NotNil)
ar2, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(ar2, DeepEquals, ar1)
}
func (s *ReceivePackSuite) TestDefaultBranch(c *C) {
r, err := s.Client.NewReceivePackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
info, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
ref, ok := info.References["refs/heads/master"]
c.Assert(ok, Equals, true)
c.Assert(ref.String(), Equals, fixtures.Basic().One().Head)
}
func (s *ReceivePackSuite) TestCapabilities(c *C) {
r, err := s.Client.NewReceivePackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
info, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(info.Capabilities.Get("agent"), HasLen, 1)
}
func (s *ReceivePackSuite) TestFullSendPackOnEmpty(c *C) {
endpoint := s.EmptyEndpoint
full := true
fixture := fixtures.Basic().ByTag("packfile").One()
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{Name: "refs/heads/master", Old: plumbing.ZeroHash, New: plumbing.NewHash(fixture.Head)},
}
s.receivePack(c, endpoint, req, fixture, full)
s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head))
}
func (s *ReceivePackSuite) TestSendPackWithContext(c *C) {
fixture := fixtures.Basic().ByTag("packfile").One()
req := packp.NewReferenceUpdateRequest()
req.Packfile = fixture.Packfile()
req.Commands = []*packp.Command{
{Name: "refs/heads/master", Old: plumbing.ZeroHash, New: plumbing.NewHash(fixture.Head)},
}
r, err := s.Client.NewReceivePackSession(s.EmptyEndpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
info, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(info, NotNil)
ctx, close := context.WithCancel(context.TODO())
close()
report, err := r.ReceivePack(ctx, req)
c.Assert(err, NotNil)
c.Assert(report, IsNil)
}
func (s *ReceivePackSuite) TestSendPackOnEmpty(c *C) {
endpoint := s.EmptyEndpoint
full := false
fixture := fixtures.Basic().ByTag("packfile").One()
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{Name: "refs/heads/master", Old: plumbing.ZeroHash, New: plumbing.NewHash(fixture.Head)},
}
s.receivePack(c, endpoint, req, fixture, full)
s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head))
}
func (s *ReceivePackSuite) TestSendPackOnEmptyWithReportStatus(c *C) {
endpoint := s.EmptyEndpoint
full := false
fixture := fixtures.Basic().ByTag("packfile").One()
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{Name: "refs/heads/master", Old: plumbing.ZeroHash, New: plumbing.NewHash(fixture.Head)},
}
req.Capabilities.Set(capability.ReportStatus)
s.receivePack(c, endpoint, req, fixture, full)
s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head))
}
func (s *ReceivePackSuite) TestFullSendPackOnNonEmpty(c *C) {
endpoint := s.Endpoint
full := true
fixture := fixtures.Basic().ByTag("packfile").One()
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{Name: "refs/heads/master", Old: plumbing.NewHash(fixture.Head), New: plumbing.NewHash(fixture.Head)},
}
s.receivePack(c, endpoint, req, fixture, full)
s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head))
}
func (s *ReceivePackSuite) TestSendPackOnNonEmpty(c *C) {
endpoint := s.Endpoint
full := false
fixture := fixtures.Basic().ByTag("packfile").One()
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{Name: "refs/heads/master", Old: plumbing.NewHash(fixture.Head), New: plumbing.NewHash(fixture.Head)},
}
s.receivePack(c, endpoint, req, fixture, full)
s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head))
}
func (s *ReceivePackSuite) TestSendPackOnNonEmptyWithReportStatus(c *C) {
endpoint := s.Endpoint
full := false
fixture := fixtures.Basic().ByTag("packfile").One()
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{Name: "refs/heads/master", Old: plumbing.NewHash(fixture.Head), New: plumbing.NewHash(fixture.Head)},
}
req.Capabilities.Set(capability.ReportStatus)
s.receivePack(c, endpoint, req, fixture, full)
s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head))
}
func (s *ReceivePackSuite) TestSendPackOnNonEmptyWithReportStatusWithError(c *C) {
endpoint := s.Endpoint
full := false
fixture := fixtures.Basic().ByTag("packfile").One()
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{Name: "refs/heads/master", Old: plumbing.ZeroHash, New: plumbing.NewHash(fixture.Head)},
}
req.Capabilities.Set(capability.ReportStatus)
report, err := s.receivePackNoCheck(c, endpoint, req, fixture, full)
//XXX: Recent git versions return "failed to update ref", while older
// (>=1.9) return "failed to lock".
c.Assert(err, ErrorMatches, ".*(failed to update ref|failed to lock).*")
c.Assert(report.UnpackStatus, Equals, "ok")
c.Assert(len(report.CommandStatuses), Equals, 1)
c.Assert(report.CommandStatuses[0].ReferenceName, Equals, plumbing.ReferenceName("refs/heads/master"))
c.Assert(report.CommandStatuses[0].Status, Matches, "(failed to update ref|failed to lock)")
s.checkRemoteHead(c, endpoint, plumbing.NewHash(fixture.Head))
}
func (s *ReceivePackSuite) receivePackNoCheck(c *C, ep *transport.Endpoint,
req *packp.ReferenceUpdateRequest, fixture *fixtures.Fixture,
callAdvertisedReferences bool) (*packp.ReportStatus, error) {
url := ""
if fixture != nil {
url = fixture.URL
}
comment := Commentf(
"failed with ep=%s fixture=%s callAdvertisedReferences=%s",
ep.String(), url, callAdvertisedReferences,
)
// Set write permissions to endpoint directory files. By default
// fixtures are generated with read only permissions, this casuses
// errors deleting or modifying files.
rootPath := ep.Path
stat, err := os.Stat(ep.Path)
if rootPath != "" && err == nil && stat.IsDir() {
objectPath := filepath.Join(rootPath, "objects/pack")
files, err := os.ReadDir(objectPath)
c.Assert(err, IsNil)
for _, file := range files {
path := filepath.Join(objectPath, file.Name())
err = os.Chmod(path, 0644)
c.Assert(err, IsNil)
}
}
r, err := s.Client.NewReceivePackSession(ep, s.EmptyAuth)
c.Assert(err, IsNil, comment)
defer func() { c.Assert(r.Close(), IsNil, comment) }()
if callAdvertisedReferences {
info, err := r.AdvertisedReferences()
c.Assert(err, IsNil, comment)
c.Assert(info, NotNil, comment)
}
if fixture != nil {
c.Assert(fixture.Packfile(), NotNil)
req.Packfile = fixture.Packfile()
} else {
req.Packfile = s.emptyPackfile()
}
return r.ReceivePack(context.Background(), req)
}
func (s *ReceivePackSuite) receivePack(c *C, ep *transport.Endpoint,
req *packp.ReferenceUpdateRequest, fixture *fixtures.Fixture,
callAdvertisedReferences bool) {
url := ""
if fixture != nil {
url = fixture.URL
}
comment := Commentf(
"failed with ep=%s fixture=%s callAdvertisedReferences=%s",
ep.String(), url, callAdvertisedReferences,
)
report, err := s.receivePackNoCheck(c, ep, req, fixture, callAdvertisedReferences)
c.Assert(err, IsNil, comment)
if req.Capabilities.Supports(capability.ReportStatus) {
c.Assert(report, NotNil, comment)
c.Assert(report.Error(), IsNil, comment)
} else {
c.Assert(report, IsNil, comment)
}
}
func (s *ReceivePackSuite) checkRemoteHead(c *C, ep *transport.Endpoint, head plumbing.Hash) {
s.checkRemoteReference(c, ep, "refs/heads/master", head)
}
func (s *ReceivePackSuite) checkRemoteReference(c *C, ep *transport.Endpoint,
refName string, head plumbing.Hash) {
r, err := s.Client.NewUploadPackSession(ep, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
ar, err := r.AdvertisedReferences()
c.Assert(err, IsNil, Commentf("endpoint: %s", ep.String()))
ref, ok := ar.References[refName]
if head == plumbing.ZeroHash {
c.Assert(ok, Equals, false)
} else {
c.Assert(ok, Equals, true)
c.Assert(ref, DeepEquals, head)
}
}
func (s *ReceivePackSuite) TestSendPackAddDeleteReference(c *C) {
s.testSendPackAddReference(c)
s.testSendPackDeleteReference(c)
}
func (s *ReceivePackSuite) testSendPackAddReference(c *C) {
r, err := s.Client.NewReceivePackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
fixture := fixtures.Basic().ByTag("packfile").One()
ar, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{Name: "refs/heads/newbranch", Old: plumbing.ZeroHash, New: plumbing.NewHash(fixture.Head)},
}
if ar.Capabilities.Supports(capability.ReportStatus) {
req.Capabilities.Set(capability.ReportStatus)
}
c.Assert(r.Close(), IsNil)
s.receivePack(c, s.Endpoint, req, nil, false)
s.checkRemoteReference(c, s.Endpoint, "refs/heads/newbranch", plumbing.NewHash(fixture.Head))
}
func (s *ReceivePackSuite) testSendPackDeleteReference(c *C) {
r, err := s.Client.NewReceivePackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
fixture := fixtures.Basic().ByTag("packfile").One()
ar, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{Name: "refs/heads/newbranch", Old: plumbing.NewHash(fixture.Head), New: plumbing.ZeroHash},
}
if ar.Capabilities.Supports(capability.ReportStatus) {
req.Capabilities.Set(capability.ReportStatus)
}
if !ar.Capabilities.Supports(capability.DeleteRefs) {
c.Fatal("capability delete-refs not supported")
}
c.Assert(r.Close(), IsNil)
s.receivePack(c, s.Endpoint, req, nil, false)
s.checkRemoteReference(c, s.Endpoint, "refs/heads/newbranch", plumbing.ZeroHash)
}
func (s *ReceivePackSuite) emptyPackfile() io.ReadCloser {
var buf bytes.Buffer
e := packfile.NewEncoder(&buf, memory.NewStorage(), false)
_, err := e.Encode(nil, 10)
if err != nil {
panic(err)
}
return io.NopCloser(&buf)
}
go-git-5.13.2/plumbing/transport/test/upload_pack.go 0000664 0000000 0000000 00000020216 14744245500 0022437 0 ustar 00root root 0000000 0000000 // Package test implements common test suite for different transport
// implementations.
package test
import (
"bytes"
"context"
"io"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
type UploadPackSuite struct {
Endpoint *transport.Endpoint
EmptyEndpoint *transport.Endpoint
NonExistentEndpoint *transport.Endpoint
EmptyAuth transport.AuthMethod
Client transport.Transport
}
func (s *UploadPackSuite) TestAdvertisedReferencesEmpty(c *C) {
r, err := s.Client.NewUploadPackSession(s.EmptyEndpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
ar, err := r.AdvertisedReferences()
c.Assert(err, Equals, transport.ErrEmptyRemoteRepository)
c.Assert(ar, IsNil)
}
func (s *UploadPackSuite) TestAdvertisedReferencesNotExists(c *C) {
r, err := s.Client.NewUploadPackSession(s.NonExistentEndpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
ar, err := r.AdvertisedReferences()
c.Assert(err, Equals, transport.ErrRepositoryNotFound)
c.Assert(ar, IsNil)
r, err = s.Client.NewUploadPackSession(s.NonExistentEndpoint, s.EmptyAuth)
c.Assert(err, IsNil)
req := packp.NewUploadPackRequest()
req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
reader, err := r.UploadPack(context.Background(), req)
c.Assert(err, Equals, transport.ErrRepositoryNotFound)
c.Assert(reader, IsNil)
}
func (s *UploadPackSuite) TestCallAdvertisedReferenceTwice(c *C) {
r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
ar1, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(ar1, NotNil)
ar2, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(ar2, DeepEquals, ar1)
}
func (s *UploadPackSuite) TestDefaultBranch(c *C) {
r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
info, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
symrefs := info.Capabilities.Get(capability.SymRef)
c.Assert(symrefs, HasLen, 1)
c.Assert(symrefs[0], Equals, "HEAD:refs/heads/master")
}
func (s *UploadPackSuite) TestAdvertisedReferencesFilterUnsupported(c *C) {
r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
info, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(info.Capabilities.Supports(capability.MultiACK), Equals, false)
}
func (s *UploadPackSuite) TestCapabilities(c *C) {
r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
info, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(info.Capabilities.Get(capability.Agent), HasLen, 1)
}
func (s *UploadPackSuite) TestUploadPack(c *C) {
r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
req := packp.NewUploadPackRequest()
req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
reader, err := r.UploadPack(context.Background(), req)
c.Assert(err, IsNil)
s.checkObjectNumber(c, reader, 28)
}
func (s *UploadPackSuite) TestUploadPackWithContext(c *C) {
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Millisecond)
defer cancel()
r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
info, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(info, NotNil)
req := packp.NewUploadPackRequest()
req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
reader, err := r.UploadPack(ctx, req)
c.Assert(err, NotNil)
c.Assert(reader, IsNil)
}
func (s *UploadPackSuite) TestUploadPackWithContextOnRead(c *C) {
ctx, cancel := context.WithCancel(context.Background())
r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
info, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(info, NotNil)
req := packp.NewUploadPackRequest()
req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
reader, err := r.UploadPack(ctx, req)
c.Assert(err, IsNil)
c.Assert(reader, NotNil)
cancel()
_, err = io.Copy(io.Discard, reader)
c.Assert(err, NotNil)
err = reader.Close()
c.Assert(err, IsNil)
err = r.Close()
c.Assert(err, IsNil)
}
func (s *UploadPackSuite) TestUploadPackFull(c *C) {
r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
info, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
c.Assert(info, NotNil)
req := packp.NewUploadPackRequest()
req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
reader, err := r.UploadPack(context.Background(), req)
c.Assert(err, IsNil)
s.checkObjectNumber(c, reader, 28)
}
func (s *UploadPackSuite) TestUploadPackInvalidReq(c *C) {
r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
req := packp.NewUploadPackRequest()
req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
req.Capabilities.Set(capability.Sideband)
req.Capabilities.Set(capability.Sideband64k)
_, err = r.UploadPack(context.Background(), req)
c.Assert(err, NotNil)
}
func (s *UploadPackSuite) TestUploadPackNoChanges(c *C) {
r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
req := packp.NewUploadPackRequest()
req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
req.Haves = append(req.Haves, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
reader, err := r.UploadPack(context.Background(), req)
c.Assert(err, Equals, transport.ErrEmptyUploadPackRequest)
c.Assert(reader, IsNil)
}
func (s *UploadPackSuite) TestUploadPackMulti(c *C) {
r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
req := packp.NewUploadPackRequest()
req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
req.Wants = append(req.Wants, plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"))
reader, err := r.UploadPack(context.Background(), req)
c.Assert(err, IsNil)
s.checkObjectNumber(c, reader, 31)
}
func (s *UploadPackSuite) TestUploadPackPartial(c *C) {
r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
req := packp.NewUploadPackRequest()
req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
req.Haves = append(req.Haves, plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"))
reader, err := r.UploadPack(context.Background(), req)
c.Assert(err, IsNil)
s.checkObjectNumber(c, reader, 4)
}
func (s *UploadPackSuite) TestFetchError(c *C) {
r, err := s.Client.NewUploadPackSession(s.Endpoint, s.EmptyAuth)
c.Assert(err, IsNil)
req := packp.NewUploadPackRequest()
req.Wants = append(req.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
reader, err := r.UploadPack(context.Background(), req)
c.Assert(err, NotNil)
c.Assert(reader, IsNil)
//XXX: We do not test Close error, since implementations might return
// different errors if a previous error was found.
}
func (s *UploadPackSuite) checkObjectNumber(c *C, r io.Reader, n int) {
b, err := io.ReadAll(r)
c.Assert(err, IsNil)
buf := bytes.NewBuffer(b)
storage := memory.NewStorage()
err = packfile.UpdateObjectStorage(storage, buf)
c.Assert(err, IsNil)
c.Assert(len(storage.Objects), Equals, n)
}
go-git-5.13.2/prune.go 0000664 0000000 0000000 00000003232 14744245500 0014455 0 ustar 00root root 0000000 0000000 package git
import (
"errors"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
)
type PruneHandler func(unreferencedObjectHash plumbing.Hash) error
type PruneOptions struct {
// OnlyObjectsOlderThan if set to non-zero value
// selects only objects older than the time provided.
OnlyObjectsOlderThan time.Time
// Handler is called on matching objects
Handler PruneHandler
}
var ErrLooseObjectsNotSupported = errors.New("loose objects not supported")
// DeleteObject deletes an object from a repository.
// The type conveniently matches PruneHandler.
func (r *Repository) DeleteObject(hash plumbing.Hash) error {
los, ok := r.Storer.(storer.LooseObjectStorer)
if !ok {
return ErrLooseObjectsNotSupported
}
return los.DeleteLooseObject(hash)
}
func (r *Repository) Prune(opt PruneOptions) error {
los, ok := r.Storer.(storer.LooseObjectStorer)
if !ok {
return ErrLooseObjectsNotSupported
}
pw := newObjectWalker(r.Storer)
err := pw.walkAllRefs()
if err != nil {
return err
}
// Now walk all (loose) objects in storage.
return los.ForEachObjectHash(func(hash plumbing.Hash) error {
// Get out if we have seen this object.
if pw.isSeen(hash) {
return nil
}
// Otherwise it is a candidate for pruning.
// Check out for too new objects next.
if !opt.OnlyObjectsOlderThan.IsZero() {
// Errors here are non-fatal. The object may be e.g. packed.
// Or concurrently deleted. Skip such objects.
t, err := los.LooseObjectTime(hash)
if err != nil {
return nil
}
// Skip too new objects.
if !t.Before(opt.OnlyObjectsOlderThan) {
return nil
}
}
return opt.Handler(hash)
})
}
go-git-5.13.2/prune_test.go 0000664 0000000 0000000 00000003270 14744245500 0015516 0 ustar 00root root 0000000 0000000 package git
import (
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage"
"github.com/go-git/go-git/v5/storage/filesystem"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type PruneSuite struct {
BaseSuite
}
var _ = Suite(&PruneSuite{})
func (s *PruneSuite) testPrune(c *C, deleteTime time.Time) {
srcFs := fixtures.ByTag("unpacked").One().DotGit()
var sto storage.Storer
var err error
sto = filesystem.NewStorage(srcFs, cache.NewObjectLRUDefault())
los := sto.(storer.LooseObjectStorer)
c.Assert(los, NotNil)
count := 0
err = los.ForEachObjectHash(func(_ plumbing.Hash) error {
count++
return nil
})
c.Assert(err, IsNil)
r, err := Open(sto, srcFs)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
// Remove a branch so we can prune some objects.
err = sto.RemoveReference(plumbing.ReferenceName("refs/heads/v4"))
c.Assert(err, IsNil)
err = sto.RemoveReference(plumbing.ReferenceName("refs/remotes/origin/v4"))
c.Assert(err, IsNil)
err = r.Prune(PruneOptions{
OnlyObjectsOlderThan: deleteTime,
Handler: r.DeleteObject,
})
c.Assert(err, IsNil)
newCount := 0
err = los.ForEachObjectHash(func(_ plumbing.Hash) error {
newCount++
return nil
})
c.Assert(err, IsNil)
if deleteTime.IsZero() {
c.Assert(newCount < count, Equals, true)
} else {
// Assume a delete time older than any of the objects was passed in.
c.Assert(newCount, Equals, count)
}
}
func (s *PruneSuite) TestPrune(c *C) {
s.testPrune(c, time.Time{})
}
func (s *PruneSuite) TestPruneWithNoDelete(c *C) {
s.testPrune(c, time.Unix(0, 1))
}
go-git-5.13.2/remote.go 0000664 0000000 0000000 00000107604 14744245500 0014627 0 ustar 00root root 0000000 0000000 package git
import (
"context"
"errors"
"fmt"
"io"
"strings"
"time"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/internal/url"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband"
"github.com/go-git/go-git/v5/plumbing/revlist"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/plumbing/transport/client"
"github.com/go-git/go-git/v5/storage"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-git/v5/storage/memory"
"github.com/go-git/go-git/v5/utils/ioutil"
)
var (
NoErrAlreadyUpToDate = errors.New("already up-to-date")
ErrDeleteRefNotSupported = errors.New("server does not support delete-refs")
ErrForceNeeded = errors.New("some refs were not updated")
ErrExactSHA1NotSupported = errors.New("server does not support exact SHA1 refspec")
ErrEmptyUrls = errors.New("URLs cannot be empty")
)
type NoMatchingRefSpecError struct {
refSpec config.RefSpec
}
func (e NoMatchingRefSpecError) Error() string {
return fmt.Sprintf("couldn't find remote ref %q", e.refSpec.Src())
}
func (e NoMatchingRefSpecError) Is(target error) bool {
_, ok := target.(NoMatchingRefSpecError)
return ok
}
const (
// This describes the maximum number of commits to walk when
// computing the haves to send to a server, for each ref in the
// repo containing this remote, when not using the multi-ack
// protocol. Setting this to 0 means there is no limit.
maxHavesToVisitPerRef = 100
// peeledSuffix is the suffix used to build peeled reference names.
peeledSuffix = "^{}"
)
// Remote represents a connection to a remote repository.
type Remote struct {
c *config.RemoteConfig
s storage.Storer
}
// NewRemote creates a new Remote.
// The intended purpose is to use the Remote for tasks such as listing remote references (like using git ls-remote).
// Otherwise Remotes should be created via the use of a Repository.
func NewRemote(s storage.Storer, c *config.RemoteConfig) *Remote {
return &Remote{s: s, c: c}
}
// Config returns the RemoteConfig object used to instantiate this Remote.
func (r *Remote) Config() *config.RemoteConfig {
return r.c
}
func (r *Remote) String() string {
var fetch, push string
if len(r.c.URLs) > 0 {
fetch = r.c.URLs[0]
push = r.c.URLs[len(r.c.URLs)-1]
}
return fmt.Sprintf("%s\t%s (fetch)\n%[1]s\t%[3]s (push)", r.c.Name, fetch, push)
}
// Push performs a push to the remote. Returns NoErrAlreadyUpToDate if the
// remote was already up-to-date.
func (r *Remote) Push(o *PushOptions) error {
return r.PushContext(context.Background(), o)
}
// PushContext performs a push to the remote. Returns NoErrAlreadyUpToDate if
// the remote was already up-to-date.
//
// The provided Context must be non-nil. If the context expires before the
// operation is complete, an error is returned. The context only affects the
// transport operations.
func (r *Remote) PushContext(ctx context.Context, o *PushOptions) (err error) {
if err := o.Validate(); err != nil {
return err
}
if o.RemoteName != r.c.Name {
return fmt.Errorf("remote names don't match: %s != %s", o.RemoteName, r.c.Name)
}
if o.RemoteURL == "" && len(r.c.URLs) > 0 {
o.RemoteURL = r.c.URLs[len(r.c.URLs)-1]
}
s, err := newSendPackSession(o.RemoteURL, o.Auth, o.InsecureSkipTLS, o.CABundle, o.ProxyOptions)
if err != nil {
return err
}
defer ioutil.CheckClose(s, &err)
ar, err := s.AdvertisedReferencesContext(ctx)
if err != nil {
return err
}
remoteRefs, err := ar.AllReferences()
if err != nil {
return err
}
if err := r.checkRequireRemoteRefs(o.RequireRemoteRefs, remoteRefs); err != nil {
return err
}
isDelete := false
allDelete := true
for _, rs := range o.RefSpecs {
if rs.IsDelete() {
isDelete = true
} else {
allDelete = false
}
if isDelete && !allDelete {
break
}
}
if isDelete && !ar.Capabilities.Supports(capability.DeleteRefs) {
return ErrDeleteRefNotSupported
}
if o.Force {
for i := 0; i < len(o.RefSpecs); i++ {
rs := &o.RefSpecs[i]
if !rs.IsForceUpdate() && !rs.IsDelete() {
o.RefSpecs[i] = config.RefSpec("+" + rs.String())
}
}
}
localRefs, err := r.references()
if err != nil {
return err
}
req, err := r.newReferenceUpdateRequest(o, localRefs, remoteRefs, ar)
if err != nil {
return err
}
if len(req.Commands) == 0 {
return NoErrAlreadyUpToDate
}
objects := objectsToPush(req.Commands)
haves, err := referencesToHashes(remoteRefs)
if err != nil {
return err
}
stop, err := r.s.Shallow()
if err != nil {
return err
}
// if we have shallow we should include this as part of the objects that
// we are aware.
haves = append(haves, stop...)
var hashesToPush []plumbing.Hash
// Avoid the expensive revlist operation if we're only doing deletes.
if !allDelete {
if url.IsLocalEndpoint(o.RemoteURL) {
// If we're are pushing to a local repo, it might be much
// faster to use a local storage layer to get the commits
// to ignore, when calculating the object revlist.
localStorer := filesystem.NewStorage(
osfs.New(o.RemoteURL), cache.NewObjectLRUDefault())
hashesToPush, err = revlist.ObjectsWithStorageForIgnores(
r.s, localStorer, objects, haves)
} else {
hashesToPush, err = revlist.Objects(r.s, objects, haves)
}
if err != nil {
return err
}
}
if len(hashesToPush) == 0 {
allDelete = true
for _, command := range req.Commands {
if command.Action() != packp.Delete {
allDelete = false
break
}
}
}
rs, err := pushHashes(ctx, s, r.s, req, hashesToPush, r.useRefDeltas(ar), allDelete)
if err != nil {
return err
}
if rs != nil {
if err = rs.Error(); err != nil {
return err
}
}
return r.updateRemoteReferenceStorage(req)
}
func (r *Remote) useRefDeltas(ar *packp.AdvRefs) bool {
return !ar.Capabilities.Supports(capability.OFSDelta)
}
func (r *Remote) addReachableTags(localRefs []*plumbing.Reference, remoteRefs storer.ReferenceStorer, req *packp.ReferenceUpdateRequest) error {
tags := make(map[plumbing.Reference]struct{})
// get a list of all tags locally
for _, ref := range localRefs {
if strings.HasPrefix(string(ref.Name()), "refs/tags") {
tags[*ref] = struct{}{}
}
}
remoteRefIter, err := remoteRefs.IterReferences()
if err != nil {
return err
}
// remove any that are already on the remote
if err := remoteRefIter.ForEach(func(reference *plumbing.Reference) error {
delete(tags, *reference)
return nil
}); err != nil {
return err
}
for tag := range tags {
tagObject, err := object.GetObject(r.s, tag.Hash())
var tagCommit *object.Commit
if err != nil {
return fmt.Errorf("get tag object: %w", err)
}
if tagObject.Type() != plumbing.TagObject {
continue
}
annotatedTag, ok := tagObject.(*object.Tag)
if !ok {
return errors.New("could not get annotated tag object")
}
tagCommit, err = object.GetCommit(r.s, annotatedTag.Target)
if err != nil {
return fmt.Errorf("get annotated tag commit: %w", err)
}
// only include tags that are reachable from one of the refs
// already being pushed
for _, cmd := range req.Commands {
if tag.Name() == cmd.Name {
continue
}
if strings.HasPrefix(cmd.Name.String(), "refs/tags") {
continue
}
c, err := object.GetCommit(r.s, cmd.New)
if err != nil {
return fmt.Errorf("get commit %v: %w", cmd.Name, err)
}
if isAncestor, err := tagCommit.IsAncestor(c); err == nil && isAncestor {
req.Commands = append(req.Commands, &packp.Command{Name: tag.Name(), New: tag.Hash()})
}
}
}
return nil
}
func (r *Remote) newReferenceUpdateRequest(
o *PushOptions,
localRefs []*plumbing.Reference,
remoteRefs storer.ReferenceStorer,
ar *packp.AdvRefs,
) (*packp.ReferenceUpdateRequest, error) {
req := packp.NewReferenceUpdateRequestFromCapabilities(ar.Capabilities)
if o.Progress != nil {
req.Progress = o.Progress
if ar.Capabilities.Supports(capability.Sideband64k) {
_ = req.Capabilities.Set(capability.Sideband64k)
} else if ar.Capabilities.Supports(capability.Sideband) {
_ = req.Capabilities.Set(capability.Sideband)
}
}
if ar.Capabilities.Supports(capability.PushOptions) {
_ = req.Capabilities.Set(capability.PushOptions)
for k, v := range o.Options {
req.Options = append(req.Options, &packp.Option{Key: k, Value: v})
}
}
if o.Atomic && ar.Capabilities.Supports(capability.Atomic) {
_ = req.Capabilities.Set(capability.Atomic)
}
if err := r.addReferencesToUpdate(o.RefSpecs, localRefs, remoteRefs, req, o.Prune, o.ForceWithLease); err != nil {
return nil, err
}
if o.FollowTags {
if err := r.addReachableTags(localRefs, remoteRefs, req); err != nil {
return nil, err
}
}
return req, nil
}
func (r *Remote) updateRemoteReferenceStorage(
req *packp.ReferenceUpdateRequest,
) error {
for _, spec := range r.c.Fetch {
for _, c := range req.Commands {
if !spec.Match(c.Name) {
continue
}
local := spec.Dst(c.Name)
ref := plumbing.NewHashReference(local, c.New)
switch c.Action() {
case packp.Create, packp.Update:
if err := r.s.SetReference(ref); err != nil {
return err
}
case packp.Delete:
if err := r.s.RemoveReference(local); err != nil {
return err
}
}
}
}
return nil
}
// FetchContext fetches references along with the objects necessary to complete
// their histories.
//
// Returns nil if the operation is successful, NoErrAlreadyUpToDate if there are
// no changes to be fetched, or an error.
//
// The provided Context must be non-nil. If the context expires before the
// operation is complete, an error is returned. The context only affects the
// transport operations.
func (r *Remote) FetchContext(ctx context.Context, o *FetchOptions) error {
_, err := r.fetch(ctx, o)
return err
}
// Fetch fetches references along with the objects necessary to complete their
// histories.
//
// Returns nil if the operation is successful, NoErrAlreadyUpToDate if there are
// no changes to be fetched, or an error.
func (r *Remote) Fetch(o *FetchOptions) error {
return r.FetchContext(context.Background(), o)
}
func (r *Remote) fetch(ctx context.Context, o *FetchOptions) (sto storer.ReferenceStorer, err error) {
if o.RemoteName == "" {
o.RemoteName = r.c.Name
}
if err = o.Validate(); err != nil {
return nil, err
}
if len(o.RefSpecs) == 0 {
o.RefSpecs = r.c.Fetch
}
if o.RemoteURL == "" {
o.RemoteURL = r.c.URLs[0]
}
s, err := newUploadPackSession(o.RemoteURL, o.Auth, o.InsecureSkipTLS, o.CABundle, o.ProxyOptions)
if err != nil {
return nil, err
}
defer ioutil.CheckClose(s, &err)
ar, err := s.AdvertisedReferencesContext(ctx)
if err != nil {
return nil, err
}
req, err := r.newUploadPackRequest(o, ar)
if err != nil {
return nil, err
}
if err := r.isSupportedRefSpec(o.RefSpecs, ar); err != nil {
return nil, err
}
remoteRefs, err := ar.AllReferences()
if err != nil {
return nil, err
}
localRefs, err := r.references()
if err != nil {
return nil, err
}
refs, specToRefs, err := calculateRefs(o.RefSpecs, remoteRefs, o.Tags)
if err != nil {
return nil, err
}
if !req.Depth.IsZero() {
req.Shallows, err = r.s.Shallow()
if err != nil {
return nil, fmt.Errorf("existing checkout is not shallow")
}
}
req.Wants, err = getWants(r.s, refs, o.Depth)
if len(req.Wants) > 0 {
req.Haves, err = getHaves(localRefs, remoteRefs, r.s, o.Depth)
if err != nil {
return nil, err
}
if err = r.fetchPack(ctx, o, s, req); err != nil {
return nil, err
}
}
var updatedPrune bool
if o.Prune {
updatedPrune, err = r.pruneRemotes(o.RefSpecs, localRefs, remoteRefs)
if err != nil {
return nil, err
}
}
updated, err := r.updateLocalReferenceStorage(o.RefSpecs, refs, remoteRefs, specToRefs, o.Tags, o.Force)
if err != nil {
return nil, err
}
if !updated {
updated, err = depthChanged(req.Shallows, r.s)
if err != nil {
return nil, fmt.Errorf("error checking depth change: %v", err)
}
}
if !updated && !updatedPrune {
// No references updated, but may have fetched new objects, check if we now have any of our wants
for _, hash := range req.Wants {
exists, _ := objectExists(r.s, hash)
if exists {
updated = true
break
}
}
if !updated {
return remoteRefs, NoErrAlreadyUpToDate
}
}
return remoteRefs, nil
}
func depthChanged(before []plumbing.Hash, s storage.Storer) (bool, error) {
after, err := s.Shallow()
if err != nil {
return false, err
}
if len(before) != len(after) {
return true, nil
}
bm := make(map[plumbing.Hash]bool, len(before))
for _, b := range before {
bm[b] = true
}
for _, a := range after {
if _, ok := bm[a]; !ok {
return true, nil
}
}
return false, nil
}
func newUploadPackSession(url string, auth transport.AuthMethod, insecure bool, cabundle []byte, proxyOpts transport.ProxyOptions) (transport.UploadPackSession, error) {
c, ep, err := newClient(url, insecure, cabundle, proxyOpts)
if err != nil {
return nil, err
}
return c.NewUploadPackSession(ep, auth)
}
func newSendPackSession(url string, auth transport.AuthMethod, insecure bool, cabundle []byte, proxyOpts transport.ProxyOptions) (transport.ReceivePackSession, error) {
c, ep, err := newClient(url, insecure, cabundle, proxyOpts)
if err != nil {
return nil, err
}
return c.NewReceivePackSession(ep, auth)
}
func newClient(url string, insecure bool, cabundle []byte, proxyOpts transport.ProxyOptions) (transport.Transport, *transport.Endpoint, error) {
ep, err := transport.NewEndpoint(url)
if err != nil {
return nil, nil, err
}
ep.InsecureSkipTLS = insecure
ep.CaBundle = cabundle
ep.Proxy = proxyOpts
c, err := client.NewClient(ep)
if err != nil {
return nil, nil, err
}
return c, ep, err
}
func (r *Remote) fetchPack(ctx context.Context, o *FetchOptions, s transport.UploadPackSession,
req *packp.UploadPackRequest) (err error) {
reader, err := s.UploadPack(ctx, req)
if err != nil {
if errors.Is(err, transport.ErrEmptyUploadPackRequest) {
// XXX: no packfile provided, everything is up-to-date.
return nil
}
return err
}
defer ioutil.CheckClose(reader, &err)
if err = r.updateShallow(o, reader); err != nil {
return err
}
if err = packfile.UpdateObjectStorage(r.s,
buildSidebandIfSupported(req.Capabilities, reader, o.Progress),
); err != nil {
return err
}
return err
}
func (r *Remote) pruneRemotes(specs []config.RefSpec, localRefs []*plumbing.Reference, remoteRefs memory.ReferenceStorage) (bool, error) {
var updatedPrune bool
for _, spec := range specs {
rev := spec.Reverse()
for _, ref := range localRefs {
if !rev.Match(ref.Name()) {
continue
}
_, err := remoteRefs.Reference(rev.Dst(ref.Name()))
if errors.Is(err, plumbing.ErrReferenceNotFound) {
updatedPrune = true
err := r.s.RemoveReference(ref.Name())
if err != nil {
return false, err
}
}
}
}
return updatedPrune, nil
}
func (r *Remote) addReferencesToUpdate(
refspecs []config.RefSpec,
localRefs []*plumbing.Reference,
remoteRefs storer.ReferenceStorer,
req *packp.ReferenceUpdateRequest,
prune bool,
forceWithLease *ForceWithLease,
) error {
// This references dictionary will be used to search references by name.
refsDict := make(map[string]*plumbing.Reference)
for _, ref := range localRefs {
refsDict[ref.Name().String()] = ref
}
for _, rs := range refspecs {
if rs.IsDelete() {
if err := r.deleteReferences(rs, remoteRefs, refsDict, req, false); err != nil {
return err
}
} else {
err := r.addOrUpdateReferences(rs, localRefs, refsDict, remoteRefs, req, forceWithLease)
if err != nil {
return err
}
if prune {
if err := r.deleteReferences(rs, remoteRefs, refsDict, req, true); err != nil {
return err
}
}
}
}
return nil
}
func (r *Remote) addOrUpdateReferences(
rs config.RefSpec,
localRefs []*plumbing.Reference,
refsDict map[string]*plumbing.Reference,
remoteRefs storer.ReferenceStorer,
req *packp.ReferenceUpdateRequest,
forceWithLease *ForceWithLease,
) error {
// If it is not a wildcard refspec we can directly search for the reference
// in the references dictionary.
if !rs.IsWildcard() {
ref, ok := refsDict[rs.Src()]
if !ok {
commit, err := object.GetCommit(r.s, plumbing.NewHash(rs.Src()))
if err == nil {
return r.addCommit(rs, remoteRefs, commit.Hash, req)
}
return nil
}
return r.addReferenceIfRefSpecMatches(rs, remoteRefs, ref, req, forceWithLease)
}
for _, ref := range localRefs {
err := r.addReferenceIfRefSpecMatches(rs, remoteRefs, ref, req, forceWithLease)
if err != nil {
return err
}
}
return nil
}
func (r *Remote) deleteReferences(rs config.RefSpec,
remoteRefs storer.ReferenceStorer,
refsDict map[string]*plumbing.Reference,
req *packp.ReferenceUpdateRequest,
prune bool) error {
iter, err := remoteRefs.IterReferences()
if err != nil {
return err
}
return iter.ForEach(func(ref *plumbing.Reference) error {
if ref.Type() != plumbing.HashReference {
return nil
}
if prune {
rs := rs.Reverse()
if !rs.Match(ref.Name()) {
return nil
}
if _, ok := refsDict[rs.Dst(ref.Name()).String()]; ok {
return nil
}
} else if rs.Dst("") != ref.Name() {
return nil
}
cmd := &packp.Command{
Name: ref.Name(),
Old: ref.Hash(),
New: plumbing.ZeroHash,
}
req.Commands = append(req.Commands, cmd)
return nil
})
}
func (r *Remote) addCommit(rs config.RefSpec,
remoteRefs storer.ReferenceStorer, localCommit plumbing.Hash,
req *packp.ReferenceUpdateRequest) error {
if rs.IsWildcard() {
return errors.New("can't use wildcard together with hash refspecs")
}
cmd := &packp.Command{
Name: rs.Dst(""),
Old: plumbing.ZeroHash,
New: localCommit,
}
remoteRef, err := remoteRefs.Reference(cmd.Name)
if err == nil {
if remoteRef.Type() != plumbing.HashReference {
// TODO: check actual git behavior here
return nil
}
cmd.Old = remoteRef.Hash()
} else if err != plumbing.ErrReferenceNotFound {
return err
}
if cmd.Old == cmd.New {
return nil
}
if !rs.IsForceUpdate() {
if err := checkFastForwardUpdate(r.s, remoteRefs, cmd); err != nil {
return err
}
}
req.Commands = append(req.Commands, cmd)
return nil
}
func (r *Remote) addReferenceIfRefSpecMatches(rs config.RefSpec,
remoteRefs storer.ReferenceStorer, localRef *plumbing.Reference,
req *packp.ReferenceUpdateRequest, forceWithLease *ForceWithLease) error {
if localRef.Type() != plumbing.HashReference {
return nil
}
if !rs.Match(localRef.Name()) {
return nil
}
cmd := &packp.Command{
Name: rs.Dst(localRef.Name()),
Old: plumbing.ZeroHash,
New: localRef.Hash(),
}
remoteRef, err := remoteRefs.Reference(cmd.Name)
if err == nil {
if remoteRef.Type() != plumbing.HashReference {
// TODO: check actual git behavior here
return nil
}
cmd.Old = remoteRef.Hash()
} else if err != plumbing.ErrReferenceNotFound {
return err
}
if cmd.Old == cmd.New {
return nil
}
if forceWithLease != nil {
if err = r.checkForceWithLease(localRef, cmd, forceWithLease); err != nil {
return err
}
} else if !rs.IsForceUpdate() {
if err := checkFastForwardUpdate(r.s, remoteRefs, cmd); err != nil {
return err
}
}
req.Commands = append(req.Commands, cmd)
return nil
}
func (r *Remote) checkForceWithLease(localRef *plumbing.Reference, cmd *packp.Command, forceWithLease *ForceWithLease) error {
remotePrefix := fmt.Sprintf("refs/remotes/%s/", r.Config().Name)
ref, err := storer.ResolveReference(
r.s,
plumbing.ReferenceName(remotePrefix+strings.Replace(localRef.Name().String(), "refs/heads/", "", -1)))
if err != nil {
return err
}
if forceWithLease.RefName.String() == "" || (forceWithLease.RefName == cmd.Name) {
expectedOID := ref.Hash()
if !forceWithLease.Hash.IsZero() {
expectedOID = forceWithLease.Hash
}
if cmd.Old != expectedOID {
return fmt.Errorf("non-fast-forward update: %s", cmd.Name.String())
}
}
return nil
}
func (r *Remote) references() ([]*plumbing.Reference, error) {
var localRefs []*plumbing.Reference
iter, err := r.s.IterReferences()
if err != nil {
return nil, err
}
for {
ref, err := iter.Next()
if err == io.EOF {
break
}
if err != nil {
return nil, err
}
localRefs = append(localRefs, ref)
}
return localRefs, nil
}
func getRemoteRefsFromStorer(remoteRefStorer storer.ReferenceStorer) (
map[plumbing.Hash]bool, error) {
remoteRefs := map[plumbing.Hash]bool{}
iter, err := remoteRefStorer.IterReferences()
if err != nil {
return nil, err
}
err = iter.ForEach(func(ref *plumbing.Reference) error {
if ref.Type() != plumbing.HashReference {
return nil
}
remoteRefs[ref.Hash()] = true
return nil
})
if err != nil {
return nil, err
}
return remoteRefs, nil
}
// getHavesFromRef populates the given `haves` map with the given
// reference, and up to `maxHavesToVisitPerRef` ancestor commits.
func getHavesFromRef(
ref *plumbing.Reference,
remoteRefs map[plumbing.Hash]bool,
s storage.Storer,
haves map[plumbing.Hash]bool,
depth int,
) error {
h := ref.Hash()
if haves[h] {
return nil
}
commit, err := object.GetCommit(s, h)
if err != nil {
if !errors.Is(err, plumbing.ErrObjectNotFound) {
// Ignore the error if this isn't a commit.
haves[ref.Hash()] = true
}
return nil
}
// Until go-git supports proper commit negotiation during an
// upload pack request, include up to `maxHavesToVisitPerRef`
// commits from the history of each ref.
walker := object.NewCommitPreorderIter(commit, haves, nil)
toVisit := maxHavesToVisitPerRef
// But only need up to the requested depth
if depth > 0 && depth < maxHavesToVisitPerRef {
toVisit = depth
}
// It is safe to ignore any error here as we are just trying to find the references that we already have
// An example of a legitimate failure is we have a shallow clone and don't have the previous commit(s)
_ = walker.ForEach(func(c *object.Commit) error {
haves[c.Hash] = true
toVisit--
// If toVisit starts out at 0 (indicating there is no
// max), then it will be negative here and we won't stop
// early.
if toVisit == 0 || remoteRefs[c.Hash] {
return storer.ErrStop
}
return nil
})
return nil
}
func getHaves(
localRefs []*plumbing.Reference,
remoteRefStorer storer.ReferenceStorer,
s storage.Storer,
depth int,
) ([]plumbing.Hash, error) {
haves := map[plumbing.Hash]bool{}
// Build a map of all the remote references, to avoid loading too
// many parent commits for references we know don't need to be
// transferred.
remoteRefs, err := getRemoteRefsFromStorer(remoteRefStorer)
if err != nil {
return nil, err
}
for _, ref := range localRefs {
if haves[ref.Hash()] {
continue
}
if ref.Type() != plumbing.HashReference {
continue
}
err = getHavesFromRef(ref, remoteRefs, s, haves, depth)
if err != nil {
return nil, err
}
}
var result []plumbing.Hash
for h := range haves {
result = append(result, h)
}
return result, nil
}
const refspecAllTags = "+refs/tags/*:refs/tags/*"
func calculateRefs(
spec []config.RefSpec,
remoteRefs storer.ReferenceStorer,
tagMode TagMode,
) (memory.ReferenceStorage, [][]*plumbing.Reference, error) {
if tagMode == AllTags {
spec = append(spec, refspecAllTags)
}
refs := make(memory.ReferenceStorage)
// list of references matched for each spec
specToRefs := make([][]*plumbing.Reference, len(spec))
for i := range spec {
var err error
specToRefs[i], err = doCalculateRefs(spec[i], remoteRefs, refs)
if err != nil {
return nil, nil, err
}
}
return refs, specToRefs, nil
}
func doCalculateRefs(
s config.RefSpec,
remoteRefs storer.ReferenceStorer,
refs memory.ReferenceStorage,
) ([]*plumbing.Reference, error) {
var refList []*plumbing.Reference
if s.IsExactSHA1() {
ref := plumbing.NewHashReference(s.Dst(""), plumbing.NewHash(s.Src()))
refList = append(refList, ref)
return refList, refs.SetReference(ref)
}
var matched bool
onMatched := func(ref *plumbing.Reference) error {
if ref.Type() == plumbing.SymbolicReference {
target, err := storer.ResolveReference(remoteRefs, ref.Name())
if err != nil {
return err
}
ref = plumbing.NewHashReference(ref.Name(), target.Hash())
}
if ref.Type() != plumbing.HashReference {
return nil
}
matched = true
refList = append(refList, ref)
return refs.SetReference(ref)
}
var ret error
if s.IsWildcard() {
iter, err := remoteRefs.IterReferences()
if err != nil {
return nil, err
}
ret = iter.ForEach(func(ref *plumbing.Reference) error {
if !s.Match(ref.Name()) {
return nil
}
return onMatched(ref)
})
} else {
var resolvedRef *plumbing.Reference
src := s.Src()
resolvedRef, ret = expand_ref(remoteRefs, plumbing.ReferenceName(src))
if ret == nil {
ret = onMatched(resolvedRef)
}
}
if !matched && !s.IsWildcard() {
return nil, NoMatchingRefSpecError{refSpec: s}
}
return refList, ret
}
func getWants(localStorer storage.Storer, refs memory.ReferenceStorage, depth int) ([]plumbing.Hash, error) {
// If depth is anything other than 1 and the repo has shallow commits then just because we have the commit
// at the reference doesn't mean that we don't still need to fetch the parents
shallow := false
if depth != 1 {
if s, _ := localStorer.Shallow(); len(s) > 0 {
shallow = true
}
}
wants := map[plumbing.Hash]bool{}
for _, ref := range refs {
hash := ref.Hash()
exists, err := objectExists(localStorer, ref.Hash())
if err != nil {
return nil, err
}
if !exists || shallow {
wants[hash] = true
}
}
var result []plumbing.Hash
for h := range wants {
result = append(result, h)
}
return result, nil
}
func objectExists(s storer.EncodedObjectStorer, h plumbing.Hash) (bool, error) {
_, err := s.EncodedObject(plumbing.AnyObject, h)
if err == plumbing.ErrObjectNotFound {
return false, nil
}
return true, err
}
func checkFastForwardUpdate(s storer.EncodedObjectStorer, remoteRefs storer.ReferenceStorer, cmd *packp.Command) error {
if cmd.Old == plumbing.ZeroHash {
_, err := remoteRefs.Reference(cmd.Name)
if err == plumbing.ErrReferenceNotFound {
return nil
}
if err != nil {
return err
}
return fmt.Errorf("non-fast-forward update: %s", cmd.Name.String())
}
ff, err := isFastForward(s, cmd.Old, cmd.New, nil)
if err != nil {
return err
}
if !ff {
return fmt.Errorf("non-fast-forward update: %s", cmd.Name.String())
}
return nil
}
func isFastForward(s storer.EncodedObjectStorer, old, new plumbing.Hash, earliestShallow *plumbing.Hash) (bool, error) {
c, err := object.GetCommit(s, new)
if err != nil {
return false, err
}
parentsToIgnore := []plumbing.Hash{}
if earliestShallow != nil {
earliestCommit, err := object.GetCommit(s, *earliestShallow)
if err != nil {
return false, err
}
parentsToIgnore = earliestCommit.ParentHashes
}
found := false
// stop iterating at the earliest shallow commit, ignoring its parents
// note: when pull depth is smaller than the number of new changes on the remote, this fails due to missing parents.
// as far as i can tell, without the commits in-between the shallow pull and the earliest shallow, there's no
// real way of telling whether it will be a fast-forward merge.
iter := object.NewCommitPreorderIter(c, nil, parentsToIgnore)
err = iter.ForEach(func(c *object.Commit) error {
if c.Hash != old {
return nil
}
found = true
return storer.ErrStop
})
return found, err
}
func (r *Remote) newUploadPackRequest(o *FetchOptions,
ar *packp.AdvRefs) (*packp.UploadPackRequest, error) {
req := packp.NewUploadPackRequestFromCapabilities(ar.Capabilities)
if o.Depth != 0 {
req.Depth = packp.DepthCommits(o.Depth)
if err := req.Capabilities.Set(capability.Shallow); err != nil {
return nil, err
}
}
if o.Progress == nil && ar.Capabilities.Supports(capability.NoProgress) {
if err := req.Capabilities.Set(capability.NoProgress); err != nil {
return nil, err
}
}
isWildcard := true
for _, s := range o.RefSpecs {
if !s.IsWildcard() {
isWildcard = false
break
}
}
if isWildcard && o.Tags == TagFollowing && ar.Capabilities.Supports(capability.IncludeTag) {
if err := req.Capabilities.Set(capability.IncludeTag); err != nil {
return nil, err
}
}
return req, nil
}
func (r *Remote) isSupportedRefSpec(refs []config.RefSpec, ar *packp.AdvRefs) error {
var containsIsExact bool
for _, ref := range refs {
if ref.IsExactSHA1() {
containsIsExact = true
}
}
if !containsIsExact {
return nil
}
if ar.Capabilities.Supports(capability.AllowReachableSHA1InWant) ||
ar.Capabilities.Supports(capability.AllowTipSHA1InWant) {
return nil
}
return ErrExactSHA1NotSupported
}
func buildSidebandIfSupported(l *capability.List, reader io.Reader, p sideband.Progress) io.Reader {
var t sideband.Type
switch {
case l.Supports(capability.Sideband):
t = sideband.Sideband
case l.Supports(capability.Sideband64k):
t = sideband.Sideband64k
default:
return reader
}
d := sideband.NewDemuxer(t, reader)
d.Progress = p
return d
}
func (r *Remote) updateLocalReferenceStorage(
specs []config.RefSpec,
fetchedRefs, remoteRefs memory.ReferenceStorage,
specToRefs [][]*plumbing.Reference,
tagMode TagMode,
force bool,
) (updated bool, err error) {
isWildcard := true
forceNeeded := false
for i, spec := range specs {
if !spec.IsWildcard() {
isWildcard = false
}
for _, ref := range specToRefs[i] {
if ref.Type() != plumbing.HashReference {
continue
}
localName := spec.Dst(ref.Name())
// If localName doesn't start with "refs/" then treat as a branch.
if !strings.HasPrefix(localName.String(), "refs/") {
localName = plumbing.NewBranchReferenceName(localName.String())
}
old, _ := storer.ResolveReference(r.s, localName)
new := plumbing.NewHashReference(localName, ref.Hash())
// If the ref exists locally as a non-tag and force is not
// specified, only update if the new ref is an ancestor of the old
if old != nil && !old.Name().IsTag() && !force && !spec.IsForceUpdate() {
ff, err := isFastForward(r.s, old.Hash(), new.Hash(), nil)
if err != nil {
return updated, err
}
if !ff {
forceNeeded = true
continue
}
}
refUpdated, err := checkAndUpdateReferenceStorerIfNeeded(r.s, new, old)
if err != nil {
return updated, err
}
if refUpdated {
updated = true
}
}
}
if tagMode == NoTags {
return updated, nil
}
tags := fetchedRefs
if isWildcard {
tags = remoteRefs
}
tagUpdated, err := r.buildFetchedTags(tags)
if err != nil {
return updated, err
}
if tagUpdated {
updated = true
}
if forceNeeded {
err = ErrForceNeeded
}
return
}
func (r *Remote) buildFetchedTags(refs memory.ReferenceStorage) (updated bool, err error) {
for _, ref := range refs {
if !ref.Name().IsTag() {
continue
}
_, err := r.s.EncodedObject(plumbing.AnyObject, ref.Hash())
if err == plumbing.ErrObjectNotFound {
continue
}
if err != nil {
return false, err
}
refUpdated, err := updateReferenceStorerIfNeeded(r.s, ref)
if err != nil {
return updated, err
}
if refUpdated {
updated = true
}
}
return
}
// List the references on the remote repository.
// The provided Context must be non-nil. If the context expires before the
// operation is complete, an error is returned. The context only affects to the
// transport operations.
func (r *Remote) ListContext(ctx context.Context, o *ListOptions) (rfs []*plumbing.Reference, err error) {
return r.list(ctx, o)
}
func (r *Remote) List(o *ListOptions) (rfs []*plumbing.Reference, err error) {
timeout := o.Timeout
// Default to the old hardcoded 10s value if a timeout is not explicitly set.
if timeout == 0 {
timeout = 10
}
if timeout < 0 {
return nil, fmt.Errorf("invalid timeout: %d", timeout)
}
ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second)
defer cancel()
return r.ListContext(ctx, o)
}
func (r *Remote) list(ctx context.Context, o *ListOptions) (rfs []*plumbing.Reference, err error) {
if r.c == nil || len(r.c.URLs) == 0 {
return nil, ErrEmptyUrls
}
s, err := newUploadPackSession(r.c.URLs[0], o.Auth, o.InsecureSkipTLS, o.CABundle, o.ProxyOptions)
if err != nil {
return nil, err
}
defer ioutil.CheckClose(s, &err)
ar, err := s.AdvertisedReferencesContext(ctx)
if err != nil {
return nil, err
}
allRefs, err := ar.AllReferences()
if err != nil {
return nil, err
}
refs, err := allRefs.IterReferences()
if err != nil {
return nil, err
}
var resultRefs []*plumbing.Reference
if o.PeelingOption == AppendPeeled || o.PeelingOption == IgnorePeeled {
err = refs.ForEach(func(ref *plumbing.Reference) error {
resultRefs = append(resultRefs, ref)
return nil
})
if err != nil {
return nil, err
}
}
if o.PeelingOption == AppendPeeled || o.PeelingOption == OnlyPeeled {
for k, v := range ar.Peeled {
resultRefs = append(resultRefs, plumbing.NewReferenceFromStrings(k+"^{}", v.String()))
}
}
return resultRefs, nil
}
func objectsToPush(commands []*packp.Command) []plumbing.Hash {
objects := make([]plumbing.Hash, 0, len(commands))
for _, cmd := range commands {
if cmd.New == plumbing.ZeroHash {
continue
}
objects = append(objects, cmd.New)
}
return objects
}
func referencesToHashes(refs storer.ReferenceStorer) ([]plumbing.Hash, error) {
iter, err := refs.IterReferences()
if err != nil {
return nil, err
}
var hs []plumbing.Hash
err = iter.ForEach(func(ref *plumbing.Reference) error {
if ref.Type() != plumbing.HashReference {
return nil
}
hs = append(hs, ref.Hash())
return nil
})
if err != nil {
return nil, err
}
return hs, nil
}
func pushHashes(
ctx context.Context,
sess transport.ReceivePackSession,
s storage.Storer,
req *packp.ReferenceUpdateRequest,
hs []plumbing.Hash,
useRefDeltas bool,
allDelete bool,
) (*packp.ReportStatus, error) {
rd, wr := io.Pipe()
config, err := s.Config()
if err != nil {
return nil, err
}
// Set buffer size to 1 so the error message can be written when
// ReceivePack fails. Otherwise the goroutine will be blocked writing
// to the channel.
done := make(chan error, 1)
if !allDelete {
req.Packfile = rd
go func() {
e := packfile.NewEncoder(wr, s, useRefDeltas)
if _, err := e.Encode(hs, config.Pack.Window); err != nil {
done <- wr.CloseWithError(err)
return
}
done <- wr.Close()
}()
} else {
close(done)
}
rs, err := sess.ReceivePack(ctx, req)
if err != nil {
// close the pipe to unlock encode write
_ = rd.Close()
return nil, err
}
if err := <-done; err != nil {
return nil, err
}
return rs, nil
}
func (r *Remote) updateShallow(o *FetchOptions, resp *packp.UploadPackResponse) error {
if o.Depth == 0 || len(resp.Shallows) == 0 {
return nil
}
shallows, err := r.s.Shallow()
if err != nil {
return err
}
outer:
for _, s := range resp.Shallows {
for _, oldS := range shallows {
if s == oldS {
continue outer
}
}
shallows = append(shallows, s)
}
return r.s.SetShallow(shallows)
}
func (r *Remote) checkRequireRemoteRefs(requires []config.RefSpec, remoteRefs storer.ReferenceStorer) error {
for _, require := range requires {
if require.IsWildcard() {
return fmt.Errorf("wildcards not supported in RequireRemoteRefs, got %s", require.String())
}
name := require.Dst("")
remote, err := remoteRefs.Reference(name)
if err != nil {
return fmt.Errorf("remote ref %s required to be %s but is absent", name.String(), require.Src())
}
var requireHash string
if require.IsExactSHA1() {
requireHash = require.Src()
} else {
target, err := storer.ResolveReference(remoteRefs, plumbing.ReferenceName(require.Src()))
if err != nil {
return fmt.Errorf("could not resolve ref %s in RequireRemoteRefs", require.Src())
}
requireHash = target.Hash().String()
}
if remote.Hash().String() != requireHash {
return fmt.Errorf("remote ref %s required to be %s but is %s", name.String(), requireHash, remote.Hash().String())
}
}
return nil
}
go-git-5.13.2/remote_test.go 0000664 0000000 0000000 00000146776 14744245500 0015703 0 ustar 00root root 0000000 0000000 package git
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"runtime"
"strings"
"testing"
"time"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-billy/v5/util"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/protocol/packp"
"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-git/v5/storage/memory"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type RemoteSuite struct {
BaseSuite
}
var _ = Suite(&RemoteSuite{})
func (s *RemoteSuite) TestFetchInvalidEndpoint(c *C) {
r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"http://\\"}})
err := r.Fetch(&FetchOptions{RemoteName: "foo"})
c.Assert(err, ErrorMatches, ".*invalid character.*")
}
func (s *RemoteSuite) TestFetchNonExistentEndpoint(c *C) {
r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"ssh://non-existent/foo.git"}})
err := r.Fetch(&FetchOptions{})
c.Assert(err, NotNil)
}
func (s *RemoteSuite) TestFetchInvalidSchemaEndpoint(c *C) {
r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"qux://foo"}})
err := r.Fetch(&FetchOptions{})
c.Assert(err, ErrorMatches, ".*unsupported scheme.*")
}
func (s *RemoteSuite) TestFetchOverriddenEndpoint(c *C) {
r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"http://perfectly-valid-url.example.com"}})
err := r.Fetch(&FetchOptions{RemoteURL: "http://\\"})
c.Assert(err, ErrorMatches, ".*invalid character.*")
}
func (s *RemoteSuite) TestFetchInvalidFetchOptions(c *C) {
r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"qux://foo"}})
invalid := config.RefSpec("^*$ñ")
err := r.Fetch(&FetchOptions{RefSpecs: []config.RefSpec{invalid}})
c.Assert(err, Equals, config.ErrRefSpecMalformedSeparator)
}
func (s *RemoteSuite) TestFetchWildcard(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetBasicLocalRepositoryURL()},
})
s.testFetch(c, r, &FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/*:refs/remotes/origin/*"),
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/remotes/origin/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
plumbing.NewReferenceFromStrings("refs/remotes/origin/branch", "e8d3ffab552895c19b9fcf7aa264d277cde33881"),
plumbing.NewReferenceFromStrings("refs/tags/v1.0.0", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
})
}
func (s *RemoteSuite) TestFetchExactSHA1(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{"https://github.com/git-fixtures/basic.git"},
})
s.testFetch(c, r, &FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("35e85108805c84807bc66a02d91535e1e24b38b9:refs/heads/foo"),
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/heads/foo", "35e85108805c84807bc66a02d91535e1e24b38b9"),
})
}
func (s *RemoteSuite) TestFetchExactSHA1_NotSoported(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetBasicLocalRepositoryURL()},
})
err := r.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("35e85108805c84807bc66a02d91535e1e24b38b9:refs/heads/foo"),
},
})
c.Assert(err, Equals, ErrExactSHA1NotSupported)
}
func (s *RemoteSuite) TestFetchWildcardTags(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
})
s.testFetch(c, r, &FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/*:refs/remotes/origin/*"),
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/remotes/origin/master", "f7b877701fbf855b44c0a9e86f3fdce2c298b07f"),
plumbing.NewReferenceFromStrings("refs/tags/annotated-tag", "b742a2a9fa0afcfa9a6fad080980fbc26b007c69"),
plumbing.NewReferenceFromStrings("refs/tags/tree-tag", "152175bf7e5580299fa1f0ba41ef6474cc043b70"),
plumbing.NewReferenceFromStrings("refs/tags/commit-tag", "ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc"),
plumbing.NewReferenceFromStrings("refs/tags/blob-tag", "fe6cb94756faa81e5ed9240f9191b833db5f40ae"),
plumbing.NewReferenceFromStrings("refs/tags/lightweight-tag", "f7b877701fbf855b44c0a9e86f3fdce2c298b07f"),
})
}
func (s *RemoteSuite) TestFetch(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
})
s.testFetch(c, r, &FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/master:refs/remotes/origin/master"),
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/remotes/origin/master", "f7b877701fbf855b44c0a9e86f3fdce2c298b07f"),
})
}
func (s *RemoteSuite) TestFetchToNewBranch(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
})
s.testFetch(c, r, &FetchOptions{
RefSpecs: []config.RefSpec{
// qualified branch to unqualified branch
"refs/heads/master:foo",
// unqualified branch to unqualified branch
"+master:bar",
// unqualified tag to unqualified branch
config.RefSpec("tree-tag:tree-tag"),
// unqualified tag to qualified tag
config.RefSpec("+commit-tag:refs/tags/renamed-tag"),
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/heads/foo", "f7b877701fbf855b44c0a9e86f3fdce2c298b07f"),
plumbing.NewReferenceFromStrings("refs/heads/bar", "f7b877701fbf855b44c0a9e86f3fdce2c298b07f"),
plumbing.NewReferenceFromStrings("refs/heads/tree-tag", "152175bf7e5580299fa1f0ba41ef6474cc043b70"),
plumbing.NewReferenceFromStrings("refs/tags/tree-tag", "152175bf7e5580299fa1f0ba41ef6474cc043b70"),
plumbing.NewReferenceFromStrings("refs/tags/renamed-tag", "ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc"),
plumbing.NewReferenceFromStrings("refs/tags/commit-tag", "ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc"),
})
}
func (s *RemoteSuite) TestFetchToNewBranchWithAllTags(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
})
s.testFetch(c, r, &FetchOptions{
Tags: AllTags,
RefSpecs: []config.RefSpec{
// qualified branch to unqualified branch
"+refs/heads/master:foo",
// unqualified branch to unqualified branch
"master:bar",
// unqualified tag to unqualified branch
config.RefSpec("+tree-tag:tree-tag"),
// unqualified tag to qualified tag
config.RefSpec("commit-tag:refs/tags/renamed-tag"),
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/heads/foo", "f7b877701fbf855b44c0a9e86f3fdce2c298b07f"),
plumbing.NewReferenceFromStrings("refs/heads/bar", "f7b877701fbf855b44c0a9e86f3fdce2c298b07f"),
plumbing.NewReferenceFromStrings("refs/heads/tree-tag", "152175bf7e5580299fa1f0ba41ef6474cc043b70"),
plumbing.NewReferenceFromStrings("refs/tags/tree-tag", "152175bf7e5580299fa1f0ba41ef6474cc043b70"),
plumbing.NewReferenceFromStrings("refs/tags/renamed-tag", "ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc"),
plumbing.NewReferenceFromStrings("refs/tags/commit-tag", "ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc"),
plumbing.NewReferenceFromStrings("refs/tags/annotated-tag", "b742a2a9fa0afcfa9a6fad080980fbc26b007c69"),
plumbing.NewReferenceFromStrings("refs/tags/blob-tag", "fe6cb94756faa81e5ed9240f9191b833db5f40ae"),
plumbing.NewReferenceFromStrings("refs/tags/lightweight-tag", "f7b877701fbf855b44c0a9e86f3fdce2c298b07f"),
})
}
func (s *RemoteSuite) TestFetchNonExistentReference(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
})
err := r.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/foo:refs/remotes/origin/foo"),
},
})
c.Assert(err, ErrorMatches, "couldn't find remote ref.*")
c.Assert(errors.Is(err, NoMatchingRefSpecError{}), Equals, true)
}
func (s *RemoteSuite) TestFetchContext(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
})
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
err := r.FetchContext(ctx, &FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/master:refs/remotes/origin/master"),
},
})
c.Assert(err, IsNil)
}
func (s *RemoteSuite) TestFetchContextCanceled(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
})
ctx, cancel := context.WithCancel(context.Background())
cancel()
err := r.FetchContext(ctx, &FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/master:refs/remotes/origin/master"),
},
})
c.Assert(err, Equals, context.Canceled)
}
func (s *RemoteSuite) TestFetchWithAllTags(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
})
s.testFetch(c, r, &FetchOptions{
Tags: AllTags,
RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/master:refs/remotes/origin/master"),
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/remotes/origin/master", "f7b877701fbf855b44c0a9e86f3fdce2c298b07f"),
plumbing.NewReferenceFromStrings("refs/tags/annotated-tag", "b742a2a9fa0afcfa9a6fad080980fbc26b007c69"),
plumbing.NewReferenceFromStrings("refs/tags/tree-tag", "152175bf7e5580299fa1f0ba41ef6474cc043b70"),
plumbing.NewReferenceFromStrings("refs/tags/commit-tag", "ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc"),
plumbing.NewReferenceFromStrings("refs/tags/blob-tag", "fe6cb94756faa81e5ed9240f9191b833db5f40ae"),
plumbing.NewReferenceFromStrings("refs/tags/lightweight-tag", "f7b877701fbf855b44c0a9e86f3fdce2c298b07f"),
})
}
func (s *RemoteSuite) TestFetchWithNoTags(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
})
s.testFetch(c, r, &FetchOptions{
Tags: NoTags,
RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/*:refs/remotes/origin/*"),
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/remotes/origin/master", "f7b877701fbf855b44c0a9e86f3fdce2c298b07f"),
})
}
func (s *RemoteSuite) TestFetchWithDepth(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetBasicLocalRepositoryURL()},
})
s.testFetch(c, r, &FetchOptions{
Depth: 1,
RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/*:refs/remotes/origin/*"),
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/remotes/origin/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
plumbing.NewReferenceFromStrings("refs/remotes/origin/branch", "e8d3ffab552895c19b9fcf7aa264d277cde33881"),
plumbing.NewReferenceFromStrings("refs/tags/v1.0.0", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
})
c.Assert(r.s.(*memory.Storage).Objects, HasLen, 18)
}
func (s *RemoteSuite) TestFetchWithDepthChange(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetBasicLocalRepositoryURL()},
})
s.testFetch(c, r, &FetchOptions{
Depth: 1,
RefSpecs: []config.RefSpec{
config.RefSpec("refs/heads/master:refs/heads/master"),
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/heads/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
})
c.Assert(r.s.(*memory.Storage).Commits, HasLen, 1)
s.testFetch(c, r, &FetchOptions{
Depth: 3,
RefSpecs: []config.RefSpec{
config.RefSpec("refs/heads/master:refs/heads/master"),
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/heads/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
})
c.Assert(r.s.(*memory.Storage).Commits, HasLen, 3)
}
func (s *RemoteSuite) testFetch(c *C, r *Remote, o *FetchOptions, expected []*plumbing.Reference) {
err := r.Fetch(o)
c.Assert(err, IsNil)
var refs int
l, err := r.s.IterReferences()
c.Assert(err, IsNil)
l.ForEach(func(r *plumbing.Reference) error { refs++; return nil })
c.Assert(refs, Equals, len(expected))
for _, exp := range expected {
r, err := r.s.Reference(exp.Name())
c.Assert(err, IsNil)
c.Assert(exp.String(), Equals, r.String())
}
}
func (s *RemoteSuite) TestFetchOfMissingObjects(c *C) {
tmp := c.MkDir()
// clone to a local temp folder
_, err := PlainClone(tmp, true, &CloneOptions{
URL: fixtures.Basic().One().DotGit().Root(),
})
c.Assert(err, IsNil)
// Delete the pack files
fsTmp := osfs.New(tmp)
err = util.RemoveAll(fsTmp, "objects/pack")
c.Assert(err, IsNil)
// Reopen the repo from the filesystem (with missing objects)
r, err := Open(filesystem.NewStorage(fsTmp, cache.NewObjectLRUDefault()), nil)
c.Assert(err, IsNil)
// Confirm we are missing a commit
_, err = r.CommitObject(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
// Refetch to get all the missing objects
err = r.Fetch(&FetchOptions{})
c.Assert(err, IsNil)
// Confirm we now have the commit
_, err = r.CommitObject(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
c.Assert(err, IsNil)
}
func (s *RemoteSuite) TestFetchWithProgress(c *C) {
url := s.GetBasicLocalRepositoryURL()
sto := memory.NewStorage()
buf := bytes.NewBuffer(nil)
r := NewRemote(sto, &config.RemoteConfig{Name: "foo", URLs: []string{url}})
refspec := config.RefSpec("+refs/heads/*:refs/remotes/origin/*")
err := r.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{refspec},
Progress: buf,
})
c.Assert(err, IsNil)
c.Assert(sto.Objects, HasLen, 31)
c.Assert(buf.Len(), Not(Equals), 0)
}
type mockPackfileWriter struct {
storage.Storer
PackfileWriterCalled bool
}
func (m *mockPackfileWriter) PackfileWriter() (io.WriteCloser, error) {
m.PackfileWriterCalled = true
return m.Storer.(storer.PackfileWriter).PackfileWriter()
}
func (s *RemoteSuite) TestFetchWithPackfileWriter(c *C) {
fs := s.TemporalFilesystem(c)
fss := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
mock := &mockPackfileWriter{Storer: fss}
url := s.GetBasicLocalRepositoryURL()
r := NewRemote(mock, &config.RemoteConfig{Name: "foo", URLs: []string{url}})
refspec := config.RefSpec("+refs/heads/*:refs/remotes/origin/*")
err := r.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{refspec},
})
c.Assert(err, IsNil)
var count int
iter, err := mock.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
iter.ForEach(func(plumbing.EncodedObject) error {
count++
return nil
})
c.Assert(count, Equals, 31)
c.Assert(mock.PackfileWriterCalled, Equals, true)
}
func (s *RemoteSuite) TestFetchNoErrAlreadyUpToDate(c *C) {
url := s.GetBasicLocalRepositoryURL()
s.doTestFetchNoErrAlreadyUpToDate(c, url)
}
func (s *RemoteSuite) TestFetchNoErrAlreadyUpToDateButStillUpdateLocalRemoteRefs(c *C) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{
URLs: []string{s.GetBasicLocalRepositoryURL()},
})
o := &FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/*:refs/remotes/origin/*"),
},
}
err := r.Fetch(o)
c.Assert(err, IsNil)
// Simulate an out of date remote ref even though we have the new commit locally
r.s.SetReference(plumbing.NewReferenceFromStrings(
"refs/remotes/origin/master", "918c48b83bd081e863dbe1b80f8998f058cd8294",
))
err = r.Fetch(o)
c.Assert(err, IsNil)
exp := plumbing.NewReferenceFromStrings(
"refs/remotes/origin/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
)
ref, err := r.s.Reference("refs/remotes/origin/master")
c.Assert(err, IsNil)
c.Assert(exp.String(), Equals, ref.String())
}
func (s *RemoteSuite) TestFetchNoErrAlreadyUpToDateWithNonCommitObjects(c *C) {
fixture := fixtures.ByTag("tags").One()
url := s.GetLocalRepositoryURL(fixture)
s.doTestFetchNoErrAlreadyUpToDate(c, url)
}
func (s *RemoteSuite) doTestFetchNoErrAlreadyUpToDate(c *C, url string) {
r := NewRemote(memory.NewStorage(), &config.RemoteConfig{URLs: []string{url}})
o := &FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/*:refs/remotes/origin/*"),
},
}
err := r.Fetch(o)
c.Assert(err, IsNil)
err = r.Fetch(o)
c.Assert(err, Equals, NoErrAlreadyUpToDate)
}
func (s *RemoteSuite) testFetchFastForward(c *C, sto storage.Storer) {
r := NewRemote(sto, &config.RemoteConfig{
URLs: []string{s.GetBasicLocalRepositoryURL()},
})
s.testFetch(c, r, &FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/master:refs/heads/master"),
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/heads/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
})
// First make sure that we error correctly when a force is required.
err := r.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("refs/heads/branch:refs/heads/master"),
},
})
c.Assert(err, Equals, ErrForceNeeded)
// And that forcing it fixes the problem.
err = r.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/branch:refs/heads/master"),
},
})
c.Assert(err, IsNil)
// Now test that a fast-forward, non-force fetch works.
r.s.SetReference(plumbing.NewReferenceFromStrings(
"refs/heads/master", "918c48b83bd081e863dbe1b80f8998f058cd8294",
))
s.testFetch(c, r, &FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("refs/heads/master:refs/heads/master"),
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/heads/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
})
}
func (s *RemoteSuite) TestFetchFastForwardMem(c *C) {
s.testFetchFastForward(c, memory.NewStorage())
}
func (s *RemoteSuite) TestFetchFastForwardFS(c *C) {
fs := s.TemporalFilesystem(c)
fss := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
// This exercises `storage.filesystem.Storage.CheckAndSetReference()`.
s.testFetchFastForward(c, fss)
}
func (s *RemoteSuite) TestString(c *C) {
r := NewRemote(nil, &config.RemoteConfig{
Name: "foo",
URLs: []string{"https://github.com/git-fixtures/basic.git"},
})
c.Assert(r.String(), Equals, ""+
"foo\thttps://github.com/git-fixtures/basic.git (fetch)\n"+
"foo\thttps://github.com/git-fixtures/basic.git (push)",
)
}
func (s *RemoteSuite) TestPushToEmptyRepository(c *C) {
url := c.MkDir()
server, err := PlainInit(url, true)
c.Assert(err, IsNil)
srcFs := fixtures.Basic().One().DotGit()
sto := filesystem.NewStorage(srcFs, cache.NewObjectLRUDefault())
r := NewRemote(sto, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{url},
})
rs := config.RefSpec("refs/heads/*:refs/heads/*")
err = r.Push(&PushOptions{
RefSpecs: []config.RefSpec{rs},
})
c.Assert(err, IsNil)
iter, err := r.s.IterReferences()
c.Assert(err, IsNil)
expected := make(map[string]string)
iter.ForEach(func(ref *plumbing.Reference) error {
if !ref.Name().IsBranch() {
return nil
}
expected[ref.Name().String()] = ref.Hash().String()
return nil
})
c.Assert(err, IsNil)
AssertReferences(c, server, expected)
}
func (s *RemoteSuite) TestPushContext(c *C) {
url := c.MkDir()
_, err := PlainInit(url, true)
c.Assert(err, IsNil)
fs := fixtures.ByURL("https://github.com/git-fixtures/tags.git").One().DotGit()
sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
r := NewRemote(sto, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{url},
})
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
numGoroutines := runtime.NumGoroutine()
err = r.PushContext(ctx, &PushOptions{
RefSpecs: []config.RefSpec{"refs/tags/*:refs/tags/*"},
})
c.Assert(err, IsNil)
eventually(c, func() bool {
return runtime.NumGoroutine() <= numGoroutines
})
}
func eventually(c *C, condition func() bool) {
select {
case <-time.After(5 * time.Second):
default:
if condition() {
break
}
time.Sleep(100 * time.Millisecond)
}
c.Assert(condition(), Equals, true)
}
func (s *RemoteSuite) TestPushContextCanceled(c *C) {
url := c.MkDir()
_, err := PlainInit(url, true)
c.Assert(err, IsNil)
fs := fixtures.ByURL("https://github.com/git-fixtures/tags.git").One().DotGit()
sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
r := NewRemote(sto, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{url},
})
ctx, cancel := context.WithCancel(context.Background())
cancel()
numGoroutines := runtime.NumGoroutine()
err = r.PushContext(ctx, &PushOptions{
RefSpecs: []config.RefSpec{"refs/tags/*:refs/tags/*"},
})
c.Assert(err, Equals, context.Canceled)
eventually(c, func() bool {
return runtime.NumGoroutine() <= numGoroutines
})
}
func (s *RemoteSuite) TestPushTags(c *C) {
url := c.MkDir()
server, err := PlainInit(url, true)
c.Assert(err, IsNil)
fs := fixtures.ByURL("https://github.com/git-fixtures/tags.git").One().DotGit()
sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
r := NewRemote(sto, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{url},
})
err = r.Push(&PushOptions{
RefSpecs: []config.RefSpec{"refs/tags/*:refs/tags/*"},
})
c.Assert(err, IsNil)
AssertReferences(c, server, map[string]string{
"refs/tags/lightweight-tag": "f7b877701fbf855b44c0a9e86f3fdce2c298b07f",
"refs/tags/annotated-tag": "b742a2a9fa0afcfa9a6fad080980fbc26b007c69",
"refs/tags/commit-tag": "ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc",
"refs/tags/blob-tag": "fe6cb94756faa81e5ed9240f9191b833db5f40ae",
"refs/tags/tree-tag": "152175bf7e5580299fa1f0ba41ef6474cc043b70",
})
}
func (s *RemoteSuite) TestPushFollowTags(c *C) {
url := c.MkDir()
server, err := PlainInit(url, true)
c.Assert(err, IsNil)
fs := fixtures.ByURL("https://github.com/git-fixtures/basic.git").One().DotGit()
sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
r := NewRemote(sto, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{url},
})
localRepo := newRepository(sto, fs)
tipTag, err := localRepo.CreateTag(
"tip",
plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"),
&CreateTagOptions{
Message: "an annotated tag",
},
)
c.Assert(err, IsNil)
initialTag, err := localRepo.CreateTag(
"initial-commit",
plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
&CreateTagOptions{
Message: "a tag for the initial commit",
},
)
c.Assert(err, IsNil)
_, err = localRepo.CreateTag(
"master-tag",
plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
&CreateTagOptions{
Message: "a tag with a commit not reachable from branch",
},
)
c.Assert(err, IsNil)
err = r.Push(&PushOptions{
RefSpecs: []config.RefSpec{"+refs/heads/branch:refs/heads/branch"},
FollowTags: true,
})
c.Assert(err, IsNil)
AssertReferences(c, server, map[string]string{
"refs/heads/branch": "e8d3ffab552895c19b9fcf7aa264d277cde33881",
"refs/tags/tip": tipTag.Hash().String(),
"refs/tags/initial-commit": initialTag.Hash().String(),
})
AssertReferencesMissing(c, server, []string{
"refs/tags/master-tag",
})
}
func (s *RemoteSuite) TestPushNoErrAlreadyUpToDate(c *C) {
fs := fixtures.Basic().One().DotGit()
sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
r := NewRemote(sto, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{fs.Root()},
})
err := r.Push(&PushOptions{
RefSpecs: []config.RefSpec{"refs/heads/*:refs/heads/*"},
})
c.Assert(err, Equals, NoErrAlreadyUpToDate)
}
func (s *RemoteSuite) TestPushDeleteReference(c *C) {
fs := fixtures.Basic().One().DotGit()
sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
url := c.MkDir()
r, err := PlainClone(url, true, &CloneOptions{
URL: fs.Root(),
})
c.Assert(err, IsNil)
remote, err := r.Remote(DefaultRemoteName)
c.Assert(err, IsNil)
err = remote.Push(&PushOptions{
RefSpecs: []config.RefSpec{":refs/heads/branch"},
})
c.Assert(err, IsNil)
_, err = sto.Reference(plumbing.ReferenceName("refs/heads/branch"))
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
_, err = r.Storer.Reference(plumbing.ReferenceName("refs/heads/branch"))
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
}
func (s *RemoteSuite) TestForcePushDeleteReference(c *C) {
fs := fixtures.Basic().One().DotGit()
sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
url := c.MkDir()
r, err := PlainClone(url, true, &CloneOptions{
URL: fs.Root(),
})
c.Assert(err, IsNil)
remote, err := r.Remote(DefaultRemoteName)
c.Assert(err, IsNil)
err = remote.Push(&PushOptions{
RefSpecs: []config.RefSpec{":refs/heads/branch"},
Force: true,
})
c.Assert(err, IsNil)
_, err = sto.Reference(plumbing.ReferenceName("refs/heads/branch"))
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
_, err = r.Storer.Reference(plumbing.ReferenceName("refs/heads/branch"))
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
}
func (s *RemoteSuite) TestPushRejectNonFastForward(c *C) {
fs := fixtures.Basic().One().DotGit()
server := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
url := c.MkDir()
r, err := PlainClone(url, true, &CloneOptions{
URL: fs.Root(),
})
c.Assert(err, IsNil)
remote, err := r.Remote(DefaultRemoteName)
c.Assert(err, IsNil)
branch := plumbing.ReferenceName("refs/heads/branch")
oldRef, err := server.Reference(branch)
c.Assert(err, IsNil)
c.Assert(oldRef, NotNil)
err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{
"refs/heads/master:refs/heads/branch",
}})
c.Assert(err, ErrorMatches, "non-fast-forward update: refs/heads/branch")
newRef, err := server.Reference(branch)
c.Assert(err, IsNil)
c.Assert(newRef, DeepEquals, oldRef)
}
func (s *RemoteSuite) TestPushForce(c *C) {
f := fixtures.Basic().One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
dstFs := f.DotGit()
dstSto := filesystem.NewStorage(dstFs, cache.NewObjectLRUDefault())
url := dstFs.Root()
r := NewRemote(sto, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{url},
})
oldRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/branch"))
c.Assert(err, IsNil)
c.Assert(oldRef, NotNil)
err = r.Push(&PushOptions{RefSpecs: []config.RefSpec{
config.RefSpec("+refs/heads/master:refs/heads/branch"),
}})
c.Assert(err, IsNil)
newRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/branch"))
c.Assert(err, IsNil)
c.Assert(newRef, Not(DeepEquals), oldRef)
}
func (s *RemoteSuite) TestPushForceWithOption(c *C) {
f := fixtures.Basic().One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
dstFs := f.DotGit()
dstSto := filesystem.NewStorage(dstFs, cache.NewObjectLRUDefault())
url := dstFs.Root()
r := NewRemote(sto, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{url},
})
oldRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/branch"))
c.Assert(err, IsNil)
c.Assert(oldRef, NotNil)
err = r.Push(&PushOptions{
RefSpecs: []config.RefSpec{"refs/heads/master:refs/heads/branch"},
Force: true,
})
c.Assert(err, IsNil)
newRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/branch"))
c.Assert(err, IsNil)
c.Assert(newRef, Not(DeepEquals), oldRef)
}
func (s *RemoteSuite) TestPushForceWithLease_success(c *C) {
testCases := []struct {
desc string
forceWithLease ForceWithLease
}{
{
desc: "no arguments",
forceWithLease: ForceWithLease{},
},
{
desc: "ref name",
forceWithLease: ForceWithLease{
RefName: plumbing.ReferenceName("refs/heads/branch"),
},
},
{
desc: "ref name and sha",
forceWithLease: ForceWithLease{
RefName: plumbing.ReferenceName("refs/heads/branch"),
Hash: plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"),
},
},
}
for _, tc := range testCases {
c.Log("Executing test cases:", tc.desc)
f := fixtures.Basic().One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
dstFs := f.DotGit()
dstSto := filesystem.NewStorage(dstFs, cache.NewObjectLRUDefault())
newCommit := plumbing.NewHashReference(
"refs/heads/branch", plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"),
)
c.Assert(sto.SetReference(newCommit), IsNil)
ref, err := sto.Reference("refs/heads/branch")
c.Assert(err, IsNil)
c.Log(ref.String())
url := dstFs.Root()
r := NewRemote(sto, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{url},
})
oldRef, err := dstSto.Reference("refs/heads/branch")
c.Assert(err, IsNil)
c.Assert(oldRef, NotNil)
c.Assert(r.Push(&PushOptions{
RefSpecs: []config.RefSpec{"refs/heads/branch:refs/heads/branch"},
ForceWithLease: &ForceWithLease{},
}), IsNil)
newRef, err := dstSto.Reference("refs/heads/branch")
c.Assert(err, IsNil)
c.Assert(newRef, DeepEquals, newCommit)
}
}
func (s *RemoteSuite) TestPushForceWithLease_failure(c *C) {
testCases := []struct {
desc string
forceWithLease ForceWithLease
}{
{
desc: "no arguments",
forceWithLease: ForceWithLease{},
},
{
desc: "ref name",
forceWithLease: ForceWithLease{
RefName: plumbing.ReferenceName("refs/heads/branch"),
},
},
{
desc: "ref name and sha",
forceWithLease: ForceWithLease{
RefName: plumbing.ReferenceName("refs/heads/branch"),
Hash: plumbing.NewHash("152175bf7e5580299fa1f0ba41ef6474cc043b70"),
},
},
}
for _, tc := range testCases {
c.Log("Executing test cases:", tc.desc)
f := fixtures.Basic().One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
c.Assert(sto.SetReference(
plumbing.NewHashReference(
"refs/heads/branch", plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"),
),
), IsNil)
dstFs := f.DotGit()
dstSto := filesystem.NewStorage(dstFs, cache.NewObjectLRUDefault())
c.Assert(dstSto.SetReference(
plumbing.NewHashReference(
"refs/heads/branch", plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc"),
),
), IsNil)
url := dstFs.Root()
r := NewRemote(sto, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{url},
})
oldRef, err := dstSto.Reference("refs/heads/branch")
c.Assert(err, IsNil)
c.Assert(oldRef, NotNil)
err = r.Push(&PushOptions{
RefSpecs: []config.RefSpec{"refs/heads/branch:refs/heads/branch"},
ForceWithLease: &ForceWithLease{},
})
c.Assert(err, DeepEquals, errors.New("non-fast-forward update: refs/heads/branch"))
newRef, err := dstSto.Reference("refs/heads/branch")
c.Assert(err, IsNil)
c.Assert(newRef, Not(DeepEquals), plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"))
}
}
func (s *RemoteSuite) TestPushPrune(c *C) {
fs := fixtures.Basic().One().DotGit()
url := c.MkDir()
server, err := PlainClone(url, true, &CloneOptions{
URL: fs.Root(),
})
c.Assert(err, IsNil)
dir := c.MkDir()
r, err := PlainClone(dir, true, &CloneOptions{
URL: url,
})
c.Assert(err, IsNil)
tag, err := r.Reference(plumbing.ReferenceName("refs/tags/v1.0.0"), true)
c.Assert(err, IsNil)
err = r.DeleteTag("v1.0.0")
c.Assert(err, IsNil)
remote, err := r.Remote(DefaultRemoteName)
c.Assert(err, IsNil)
ref, err := r.Reference(plumbing.ReferenceName("refs/heads/master"), true)
c.Assert(err, IsNil)
err = remote.Push(&PushOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("refs/heads/*:refs/heads/*"),
},
Prune: true,
})
c.Assert(err, Equals, NoErrAlreadyUpToDate)
AssertReferences(c, server, map[string]string{
"refs/tags/v1.0.0": tag.Hash().String(),
})
err = remote.Push(&PushOptions{
RefSpecs: []config.RefSpec{
config.RefSpec("*:*"),
},
Prune: true,
})
c.Assert(err, IsNil)
AssertReferences(c, server, map[string]string{
"refs/remotes/origin/master": ref.Hash().String(),
})
AssertReferences(c, server, map[string]string{
"refs/remotes/origin/master": ref.Hash().String(),
})
_, err = server.Reference(plumbing.ReferenceName("refs/tags/v1.0.0"), true)
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
}
func (s *RemoteSuite) TestPushNewReference(c *C) {
fs := fixtures.Basic().One().DotGit()
url := c.MkDir()
server, err := PlainClone(url, true, &CloneOptions{
URL: fs.Root(),
})
c.Assert(err, IsNil)
dir := c.MkDir()
r, err := PlainClone(dir, true, &CloneOptions{
URL: url,
})
c.Assert(err, IsNil)
remote, err := r.Remote(DefaultRemoteName)
c.Assert(err, IsNil)
ref, err := r.Reference(plumbing.ReferenceName("refs/heads/master"), true)
c.Assert(err, IsNil)
err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{
"refs/heads/master:refs/heads/branch2",
}})
c.Assert(err, IsNil)
AssertReferences(c, server, map[string]string{
"refs/heads/branch2": ref.Hash().String(),
})
AssertReferences(c, r, map[string]string{
"refs/remotes/origin/branch2": ref.Hash().String(),
})
}
func (s *RemoteSuite) TestPushNewReferenceAndDeleteInBatch(c *C) {
fs := fixtures.Basic().One().DotGit()
url := c.MkDir()
server, err := PlainClone(url, true, &CloneOptions{
URL: fs.Root(),
})
c.Assert(err, IsNil)
dir := c.MkDir()
r, err := PlainClone(dir, true, &CloneOptions{
URL: url,
})
c.Assert(err, IsNil)
remote, err := r.Remote(DefaultRemoteName)
c.Assert(err, IsNil)
ref, err := r.Reference(plumbing.ReferenceName("refs/heads/master"), true)
c.Assert(err, IsNil)
err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{
"refs/heads/master:refs/heads/branch2",
":refs/heads/branch",
}})
c.Assert(err, IsNil)
AssertReferences(c, server, map[string]string{
"refs/heads/branch2": ref.Hash().String(),
})
AssertReferences(c, r, map[string]string{
"refs/remotes/origin/branch2": ref.Hash().String(),
})
_, err = server.Storer.Reference(plumbing.ReferenceName("refs/heads/branch"))
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
}
func (s *RemoteSuite) TestPushInvalidEndpoint(c *C) {
r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"http://\\"}})
err := r.Push(&PushOptions{RemoteName: "foo"})
c.Assert(err, ErrorMatches, ".*invalid character.*")
}
func (s *RemoteSuite) TestPushNonExistentEndpoint(c *C) {
r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"ssh://non-existent/foo.git"}})
err := r.Push(&PushOptions{})
c.Assert(err, NotNil)
}
func (s *RemoteSuite) TestPushOverriddenEndpoint(c *C) {
r := NewRemote(nil, &config.RemoteConfig{Name: "origin", URLs: []string{"http://perfectly-valid-url.example.com"}})
err := r.Push(&PushOptions{RemoteURL: "http://\\"})
c.Assert(err, ErrorMatches, ".*invalid character.*")
}
func (s *RemoteSuite) TestPushInvalidSchemaEndpoint(c *C) {
r := NewRemote(nil, &config.RemoteConfig{Name: "origin", URLs: []string{"qux://foo"}})
err := r.Push(&PushOptions{})
c.Assert(err, ErrorMatches, ".*unsupported scheme.*")
}
func (s *RemoteSuite) TestPushInvalidFetchOptions(c *C) {
r := NewRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"qux://foo"}})
invalid := config.RefSpec("^*$ñ")
err := r.Push(&PushOptions{RefSpecs: []config.RefSpec{invalid}})
c.Assert(err, Equals, config.ErrRefSpecMalformedSeparator)
}
func (s *RemoteSuite) TestPushInvalidRefSpec(c *C) {
r := NewRemote(nil, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{"some-url"},
})
rs := config.RefSpec("^*$**")
err := r.Push(&PushOptions{
RefSpecs: []config.RefSpec{rs},
})
c.Assert(err, Equals, config.ErrRefSpecMalformedSeparator)
}
func (s *RemoteSuite) TestPushWrongRemoteName(c *C) {
r := NewRemote(nil, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{"some-url"},
})
err := r.Push(&PushOptions{
RemoteName: "other-remote",
})
c.Assert(err, ErrorMatches, ".*remote names don't match.*")
}
func (s *RemoteSuite) TestGetHaves(c *C) {
f := fixtures.Basic().One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
var localRefs = []*plumbing.Reference{
// Exists
plumbing.NewReferenceFromStrings(
"foo",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
),
// Exists
plumbing.NewReferenceFromStrings(
"bar",
"b8e471f58bcbca63b07bda20e428190409c2db47",
),
// Doesn't Exist
plumbing.NewReferenceFromStrings(
"qux",
"0000000",
),
}
l, err := getHaves(localRefs, memory.NewStorage(), sto, 0)
c.Assert(err, IsNil)
c.Assert(l, HasLen, 2)
}
func (s *RemoteSuite) TestList(c *C) {
repo := fixtures.Basic().One()
remote := NewRemote(memory.NewStorage(), &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{repo.URL},
})
refs, err := remote.List(&ListOptions{})
c.Assert(err, IsNil)
expected := []*plumbing.Reference{
plumbing.NewSymbolicReference("HEAD", "refs/heads/master"),
plumbing.NewReferenceFromStrings("refs/heads/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
plumbing.NewReferenceFromStrings("refs/heads/branch", "e8d3ffab552895c19b9fcf7aa264d277cde33881"),
plumbing.NewReferenceFromStrings("refs/pull/1/head", "b8e471f58bcbca63b07bda20e428190409c2db47"),
plumbing.NewReferenceFromStrings("refs/pull/2/head", "9632f02833b2f9613afb5e75682132b0b22e4a31"),
plumbing.NewReferenceFromStrings("refs/pull/2/merge", "c37f58a130ca555e42ff96a071cb9ccb3f437504"),
}
c.Assert(len(refs), Equals, len(expected))
for _, e := range expected {
found := false
for _, r := range refs {
if r.Name() == e.Name() {
found = true
c.Assert(r, DeepEquals, e)
}
}
c.Assert(found, Equals, true)
}
}
func (s *RemoteSuite) TestListPeeling(c *C) {
remote := NewRemote(memory.NewStorage(), &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{"https://github.com/git-fixtures/tags.git"},
})
for _, tc := range []struct {
peelingOption PeelingOption
expectPeeled bool
expectNonPeeled bool
}{
{peelingOption: AppendPeeled, expectPeeled: true, expectNonPeeled: true},
{peelingOption: IgnorePeeled, expectPeeled: false, expectNonPeeled: true},
{peelingOption: OnlyPeeled, expectPeeled: true, expectNonPeeled: false},
} {
refs, err := remote.List(&ListOptions{
PeelingOption: tc.peelingOption,
})
c.Assert(err, IsNil)
c.Assert(len(refs) > 0, Equals, true)
foundPeeled, foundNonPeeled := false, false
for _, ref := range refs {
if strings.HasSuffix(ref.Name().String(), peeledSuffix) {
foundPeeled = true
} else {
foundNonPeeled = true
}
}
c.Assert(foundPeeled, Equals, tc.expectPeeled)
c.Assert(foundNonPeeled, Equals, tc.expectNonPeeled)
}
}
func (s *RemoteSuite) TestListTimeout(c *C) {
remote := NewRemote(memory.NewStorage(), &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{"https://deelay.me/60000/https://httpstat.us/503"},
})
_, err := remote.List(&ListOptions{})
c.Assert(err, NotNil)
}
func (s *RemoteSuite) TestUpdateShallows(c *C) {
hashes := []plumbing.Hash{
plumbing.NewHash("0000000000000000000000000000000000000001"),
plumbing.NewHash("0000000000000000000000000000000000000002"),
plumbing.NewHash("0000000000000000000000000000000000000003"),
plumbing.NewHash("0000000000000000000000000000000000000004"),
plumbing.NewHash("0000000000000000000000000000000000000005"),
plumbing.NewHash("0000000000000000000000000000000000000006"),
}
tests := []struct {
hashes []plumbing.Hash
result []plumbing.Hash
}{
// add to empty shallows
{hashes[0:2], hashes[0:2]},
// add new hashes
{hashes[2:4], hashes[0:4]},
// add some hashes already in shallow list
{hashes[2:6], hashes[0:6]},
// add all hashes
{hashes[0:6], hashes[0:6]},
// add empty list
{nil, hashes[0:6]},
}
remote := NewRemote(memory.NewStorage(), &config.RemoteConfig{
Name: DefaultRemoteName,
})
shallows, err := remote.s.Shallow()
c.Assert(err, IsNil)
c.Assert(len(shallows), Equals, 0)
resp := new(packp.UploadPackResponse)
o := &FetchOptions{
Depth: 1,
}
for _, t := range tests {
resp.Shallows = t.hashes
err = remote.updateShallow(o, resp)
c.Assert(err, IsNil)
shallow, err := remote.s.Shallow()
c.Assert(err, IsNil)
c.Assert(len(shallow), Equals, len(t.result))
c.Assert(shallow, DeepEquals, t.result)
}
}
func (s *RemoteSuite) TestUseRefDeltas(c *C) {
url := c.MkDir()
_, err := PlainInit(url, true)
c.Assert(err, IsNil)
fs := fixtures.ByURL("https://github.com/git-fixtures/tags.git").One().DotGit()
sto := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
r := NewRemote(sto, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{url},
})
ar := packp.NewAdvRefs()
ar.Capabilities.Add(capability.OFSDelta)
c.Assert(r.useRefDeltas(ar), Equals, false)
ar.Capabilities.Delete(capability.OFSDelta)
c.Assert(r.useRefDeltas(ar), Equals, true)
}
func (s *RemoteSuite) TestPushRequireRemoteRefs(c *C) {
f := fixtures.Basic().One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
dstFs := f.DotGit()
dstSto := filesystem.NewStorage(dstFs, cache.NewObjectLRUDefault())
url := dstFs.Root()
r := NewRemote(sto, &config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{url},
})
oldRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/branch"))
c.Assert(err, IsNil)
c.Assert(oldRef, NotNil)
otherRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/master"))
c.Assert(err, IsNil)
c.Assert(otherRef, NotNil)
err = r.Push(&PushOptions{
RefSpecs: []config.RefSpec{"refs/heads/master:refs/heads/branch"},
RequireRemoteRefs: []config.RefSpec{config.RefSpec(otherRef.Hash().String() + ":refs/heads/branch")},
})
c.Assert(err, ErrorMatches, "remote ref refs/heads/branch required to be .* but is .*")
newRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/branch"))
c.Assert(err, IsNil)
c.Assert(newRef, DeepEquals, oldRef)
err = r.Push(&PushOptions{
RefSpecs: []config.RefSpec{"refs/heads/master:refs/heads/branch"},
RequireRemoteRefs: []config.RefSpec{config.RefSpec(oldRef.Hash().String() + ":refs/heads/branch")},
})
c.Assert(err, ErrorMatches, "non-fast-forward update: .*")
newRef, err = dstSto.Reference(plumbing.ReferenceName("refs/heads/branch"))
c.Assert(err, IsNil)
c.Assert(newRef, DeepEquals, oldRef)
err = r.Push(&PushOptions{
RefSpecs: []config.RefSpec{"refs/heads/master:refs/heads/branch"},
RequireRemoteRefs: []config.RefSpec{config.RefSpec(oldRef.Hash().String() + ":refs/heads/branch")},
Force: true,
})
c.Assert(err, IsNil)
newRef, err = dstSto.Reference(plumbing.ReferenceName("refs/heads/branch"))
c.Assert(err, IsNil)
c.Assert(newRef, Not(DeepEquals), oldRef)
}
func (s *RemoteSuite) TestFetchPrune(c *C) {
fs := fixtures.Basic().One().DotGit()
url := c.MkDir()
_, err := PlainClone(url, true, &CloneOptions{
URL: fs.Root(),
})
c.Assert(err, IsNil)
dir := c.MkDir()
r, err := PlainClone(dir, true, &CloneOptions{
URL: url,
})
c.Assert(err, IsNil)
remote, err := r.Remote(DefaultRemoteName)
c.Assert(err, IsNil)
ref, err := r.Reference(plumbing.ReferenceName("refs/heads/master"), true)
c.Assert(err, IsNil)
err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{
"refs/heads/master:refs/heads/branch",
}})
c.Assert(err, IsNil)
dirSave := c.MkDir()
rSave, err := PlainClone(dirSave, true, &CloneOptions{
URL: url,
})
c.Assert(err, IsNil)
AssertReferences(c, rSave, map[string]string{
"refs/remotes/origin/branch": ref.Hash().String(),
})
err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{
":refs/heads/branch",
}})
c.Assert(err, IsNil)
AssertReferences(c, rSave, map[string]string{
"refs/remotes/origin/branch": ref.Hash().String(),
})
err = rSave.Fetch(&FetchOptions{Prune: true})
c.Assert(err, IsNil)
_, err = rSave.Reference("refs/remotes/origin/branch", true)
c.Assert(err, ErrorMatches, "reference not found")
}
func (s *RemoteSuite) TestFetchPruneTags(c *C) {
fs := fixtures.Basic().One().DotGit()
url := c.MkDir()
_, err := PlainClone(url, true, &CloneOptions{
URL: fs.Root(),
})
c.Assert(err, IsNil)
dir := c.MkDir()
r, err := PlainClone(dir, true, &CloneOptions{
URL: url,
})
c.Assert(err, IsNil)
remote, err := r.Remote(DefaultRemoteName)
c.Assert(err, IsNil)
ref, err := r.Reference(plumbing.ReferenceName("refs/heads/master"), true)
c.Assert(err, IsNil)
err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{
"refs/heads/master:refs/tags/v1",
}})
c.Assert(err, IsNil)
dirSave := c.MkDir()
rSave, err := PlainClone(dirSave, true, &CloneOptions{
URL: url,
})
c.Assert(err, IsNil)
AssertReferences(c, rSave, map[string]string{
"refs/tags/v1": ref.Hash().String(),
})
err = remote.Push(&PushOptions{RefSpecs: []config.RefSpec{
":refs/tags/v1",
}})
c.Assert(err, IsNil)
AssertReferences(c, rSave, map[string]string{
"refs/tags/v1": ref.Hash().String(),
})
err = rSave.Fetch(&FetchOptions{Prune: true, RefSpecs: []config.RefSpec{"refs/tags/*:refs/tags/*"}})
c.Assert(err, IsNil)
_, err = rSave.Reference("refs/tags/v1", true)
c.Assert(err, ErrorMatches, "reference not found")
}
func (s *RemoteSuite) TestCanPushShasToReference(c *C) {
d := c.MkDir()
d, err := os.MkdirTemp(d, "TestCanPushShasToReference")
c.Assert(err, IsNil)
if err != nil {
return
}
// remote currently forces a plain path for path based remotes inside the PushContext function.
// This makes it impossible, in the current state to use memfs.
// For the sake of readability, use the same osFS everywhere and use plain git repositories on temporary files
remote, err := PlainInit(filepath.Join(d, "remote"), true)
c.Assert(err, IsNil)
c.Assert(remote, NotNil)
repo, err := PlainInit(filepath.Join(d, "repo"), false)
c.Assert(err, IsNil)
c.Assert(repo, NotNil)
sha := CommitNewFile(c, repo, "README.md")
gitremote, err := repo.CreateRemote(&config.RemoteConfig{
Name: "local",
URLs: []string{filepath.Join(d, "remote")},
})
c.Assert(err, IsNil)
if err != nil {
return
}
err = gitremote.Push(&PushOptions{
RemoteName: "local",
RefSpecs: []config.RefSpec{
// TODO: check with short hashes that this is still respected
config.RefSpec(sha.String() + ":refs/heads/branch"),
},
})
c.Assert(err, IsNil)
if err != nil {
return
}
ref, err := remote.Reference(plumbing.ReferenceName("refs/heads/branch"), false)
c.Assert(err, IsNil)
if err != nil {
return
}
c.Assert(ref.Hash().String(), Equals, sha.String())
}
func (s *RemoteSuite) TestFetchAfterShallowClone(c *C) {
tempDir := c.MkDir()
remoteUrl := filepath.Join(tempDir, "remote")
repoDir := filepath.Join(tempDir, "repo")
// Create a new repo and add more than 1 commit (so we can have a shallow commit)
remote, err := PlainInit(remoteUrl, false)
c.Assert(err, IsNil)
c.Assert(remote, NotNil)
_ = CommitNewFile(c, remote, "File1")
_ = CommitNewFile(c, remote, "File2")
// Clone the repo with a depth of 1
repo, err := PlainClone(repoDir, false, &CloneOptions{
URL: remoteUrl,
Depth: 1,
Tags: NoTags,
SingleBranch: true,
ReferenceName: "master",
})
c.Assert(err, IsNil)
// Add new commits to the origin (more than 1 so that our next test hits a missing commit)
_ = CommitNewFile(c, remote, "File3")
sha4 := CommitNewFile(c, remote, "File4")
// Try fetch with depth of 1 again (note, we need to ensure no remote branch remains pointing at the old commit)
r, err := repo.Remote(DefaultRemoteName)
c.Assert(err, IsNil)
s.testFetch(c, r, &FetchOptions{
Depth: 2,
Tags: NoTags,
RefSpecs: []config.RefSpec{
"+refs/heads/master:refs/heads/master",
"+refs/heads/master:refs/remotes/origin/master",
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/heads/master", sha4.String()),
plumbing.NewReferenceFromStrings("refs/remotes/origin/master", sha4.String()),
plumbing.NewSymbolicReference("HEAD", "refs/heads/master"),
})
// Add another commit to the origin
sha5 := CommitNewFile(c, remote, "File5")
// Try fetch with depth of 2 this time (to reach a commit that we don't have locally)
r, err = repo.Remote(DefaultRemoteName)
c.Assert(err, IsNil)
s.testFetch(c, r, &FetchOptions{
Depth: 1,
Tags: NoTags,
RefSpecs: []config.RefSpec{
"+refs/heads/master:refs/heads/master",
"+refs/heads/master:refs/remotes/origin/master",
},
}, []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/heads/master", sha5.String()),
plumbing.NewReferenceFromStrings("refs/remotes/origin/master", sha5.String()),
plumbing.NewSymbolicReference("HEAD", "refs/heads/master"),
})
}
func TestFetchFastForwardForCustomRef(t *testing.T) {
customRef := "refs/custom/branch"
// 1. Set up a remote with a URL
remoteURL := t.TempDir()
remoteRepo, err := PlainInit(remoteURL, true)
if err != nil {
t.Fatal(err)
}
// 2. Add a commit with an empty tree to master and custom ref, also set HEAD
emptyTreeID := writeEmptyTree(t, remoteRepo)
writeCommitToRef(t, remoteRepo, "refs/heads/master", emptyTreeID, time.Now())
writeCommitToRef(t, remoteRepo, customRef, emptyTreeID, time.Now())
if err := remoteRepo.Storer.SetReference(plumbing.NewSymbolicReference(plumbing.HEAD, "refs/heads/master")); err != nil {
t.Fatal(err)
}
// 3. Clone repo, then fetch the custom ref
// Note that using custom ref in ReferenceName has an IsBranch issue
localRepo, err := Clone(memory.NewStorage(), memfs.New(), &CloneOptions{
URL: remoteURL,
})
if err != nil {
t.Fatal(err)
}
if err := localRepo.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{
config.RefSpec(fmt.Sprintf("%s:%s", customRef, customRef)),
},
}); err != nil {
t.Fatal(err)
}
// 4. Make divergent changes
remoteCommitID := writeCommitToRef(t, remoteRepo, customRef, emptyTreeID, time.Now())
// Consecutive calls to writeCommitToRef with time.Now() might have the same
// time value, explicitly set distinct ones to ensure the commit hashes
// differ
writeCommitToRef(t, localRepo, customRef, emptyTreeID, time.Now().Add(time.Second))
// 5. Try to fetch with fast-forward only mode
remote, err := localRepo.Remote(DefaultRemoteName)
if err != nil {
t.Fatal(err)
}
err = remote.Fetch(&FetchOptions{RefSpecs: []config.RefSpec{
config.RefSpec(fmt.Sprintf("%s:%s", customRef, customRef)),
}})
if !errors.Is(err, ErrForceNeeded) {
t.Errorf("expected %v, got %v", ErrForceNeeded, err)
}
// 6. Fetch with force
err = remote.Fetch(&FetchOptions{RefSpecs: []config.RefSpec{
config.RefSpec(fmt.Sprintf("+%s:%s", customRef, customRef)),
}})
if err != nil {
t.Errorf("unexpected error %v", err)
}
// 7. Assert commit ID matches
ref, err := localRepo.Reference(plumbing.ReferenceName(customRef), true)
if err != nil {
t.Fatal(err)
}
if remoteCommitID != ref.Hash() {
t.Errorf("expected %s, got %s", remoteCommitID.String(), ref.Hash().String())
}
}
func writeEmptyTree(t *testing.T, repo *Repository) plumbing.Hash {
t.Helper()
obj := repo.Storer.NewEncodedObject()
obj.SetType(plumbing.TreeObject)
tree := object.Tree{Entries: nil}
if err := tree.Encode(obj); err != nil {
t.Fatal(err)
}
treeID, err := repo.Storer.SetEncodedObject(obj)
if err != nil {
t.Fatal(err)
}
return treeID
}
func writeCommitToRef(t *testing.T, repo *Repository, refName string, treeID plumbing.Hash, when time.Time) plumbing.Hash {
t.Helper()
ref, err := repo.Reference(plumbing.ReferenceName(refName), true)
if err != nil {
if errors.Is(err, plumbing.ErrReferenceNotFound) {
if err := repo.Storer.SetReference(plumbing.NewHashReference(plumbing.ReferenceName(refName), plumbing.ZeroHash)); err != nil {
t.Fatal(err)
}
ref, err = repo.Reference(plumbing.ReferenceName(refName), true)
if err != nil {
t.Fatal(err)
}
} else {
t.Fatal(err)
}
}
commit := &object.Commit{
TreeHash: treeID,
Author: object.Signature{
When: when,
},
}
if !ref.Hash().IsZero() {
commit.ParentHashes = []plumbing.Hash{ref.Hash()}
}
obj := repo.Storer.NewEncodedObject()
if err := commit.Encode(obj); err != nil {
t.Fatal(err)
}
commitID, err := repo.Storer.SetEncodedObject(obj)
if err != nil {
t.Fatal(err)
}
newRef := plumbing.NewHashReference(plumbing.ReferenceName(refName), commitID)
if err := repo.Storer.CheckAndSetReference(newRef, ref); err != nil {
t.Fatal(err)
}
return commitID
}
go-git-5.13.2/repository.go 0000664 0000000 0000000 00000136255 14744245500 0015557 0 ustar 00root root 0000000 0000000 package git
import (
"bytes"
"context"
"crypto"
"encoding/hex"
"errors"
"fmt"
"io"
"os"
"path"
"path/filepath"
"strings"
"time"
"dario.cat/mergo"
"github.com/ProtonMail/go-crypto/openpgp"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-billy/v5/util"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/internal/path_util"
"github.com/go-git/go-git/v5/internal/revision"
"github.com/go-git/go-git/v5/internal/url"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
formatcfg "github.com/go-git/go-git/v5/plumbing/format/config"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-git/v5/storage/filesystem/dotgit"
"github.com/go-git/go-git/v5/utils/ioutil"
)
// GitDirName this is a special folder where all the git stuff is.
const GitDirName = ".git"
var (
// ErrBranchExists an error stating the specified branch already exists
ErrBranchExists = errors.New("branch already exists")
// ErrBranchNotFound an error stating the specified branch does not exist
ErrBranchNotFound = errors.New("branch not found")
// ErrTagExists an error stating the specified tag already exists
ErrTagExists = errors.New("tag already exists")
// ErrTagNotFound an error stating the specified tag does not exist
ErrTagNotFound = errors.New("tag not found")
// ErrFetching is returned when the packfile could not be downloaded
ErrFetching = errors.New("unable to fetch packfile")
ErrInvalidReference = errors.New("invalid reference, should be a tag or a branch")
ErrRepositoryNotExists = errors.New("repository does not exist")
ErrRepositoryIncomplete = errors.New("repository's commondir path does not exist")
ErrRepositoryAlreadyExists = errors.New("repository already exists")
ErrRemoteNotFound = errors.New("remote not found")
ErrRemoteExists = errors.New("remote already exists")
ErrAnonymousRemoteName = errors.New("anonymous remote name must be 'anonymous'")
ErrWorktreeNotProvided = errors.New("worktree should be provided")
ErrIsBareRepository = errors.New("worktree not available in a bare repository")
ErrUnableToResolveCommit = errors.New("unable to resolve commit")
ErrPackedObjectsNotSupported = errors.New("packed objects not supported")
ErrSHA256NotSupported = errors.New("go-git was not compiled with SHA256 support")
ErrAlternatePathNotSupported = errors.New("alternate path must use the file scheme")
ErrUnsupportedMergeStrategy = errors.New("unsupported merge strategy")
ErrFastForwardMergeNotPossible = errors.New("not possible to fast-forward merge changes")
)
// Repository represents a git repository
type Repository struct {
Storer storage.Storer
r map[string]*Remote
wt billy.Filesystem
}
type InitOptions struct {
// The default branch (e.g. "refs/heads/master")
DefaultBranch plumbing.ReferenceName
}
// Init creates an empty git repository, based on the given Storer and worktree.
// The worktree Filesystem is optional, if nil a bare repository is created. If
// the given storer is not empty ErrRepositoryAlreadyExists is returned
func Init(s storage.Storer, worktree billy.Filesystem) (*Repository, error) {
options := InitOptions{
DefaultBranch: plumbing.Master,
}
return InitWithOptions(s, worktree, options)
}
func InitWithOptions(s storage.Storer, worktree billy.Filesystem, options InitOptions) (*Repository, error) {
if err := initStorer(s); err != nil {
return nil, err
}
if options.DefaultBranch == "" {
options.DefaultBranch = plumbing.Master
}
if err := options.DefaultBranch.Validate(); err != nil {
return nil, err
}
r := newRepository(s, worktree)
_, err := r.Reference(plumbing.HEAD, false)
switch err {
case plumbing.ErrReferenceNotFound:
case nil:
return nil, ErrRepositoryAlreadyExists
default:
return nil, err
}
h := plumbing.NewSymbolicReference(plumbing.HEAD, options.DefaultBranch)
if err := s.SetReference(h); err != nil {
return nil, err
}
if worktree == nil {
_ = r.setIsBare(true)
return r, nil
}
return r, setWorktreeAndStoragePaths(r, worktree)
}
func initStorer(s storer.Storer) error {
i, ok := s.(storer.Initializer)
if !ok {
return nil
}
return i.Init()
}
func setWorktreeAndStoragePaths(r *Repository, worktree billy.Filesystem) error {
type fsBased interface {
Filesystem() billy.Filesystem
}
// .git file is only created if the storage is file based and the file
// system is osfs.OS
fs, isFSBased := r.Storer.(fsBased)
if !isFSBased {
return nil
}
if err := createDotGitFile(worktree, fs.Filesystem()); err != nil {
return err
}
return setConfigWorktree(r, worktree, fs.Filesystem())
}
func createDotGitFile(worktree, storage billy.Filesystem) error {
path, err := filepath.Rel(worktree.Root(), storage.Root())
if err != nil {
path = storage.Root()
}
if path == GitDirName {
// not needed, since the folder is the default place
return nil
}
f, err := worktree.Create(GitDirName)
if err != nil {
return err
}
defer f.Close()
_, err = fmt.Fprintf(f, "gitdir: %s\n", path)
return err
}
func setConfigWorktree(r *Repository, worktree, storage billy.Filesystem) error {
path, err := filepath.Rel(storage.Root(), worktree.Root())
if err != nil {
path = worktree.Root()
}
if path == ".." {
// not needed, since the folder is the default place
return nil
}
cfg, err := r.Config()
if err != nil {
return err
}
cfg.Core.Worktree = path
return r.Storer.SetConfig(cfg)
}
// Open opens a git repository using the given Storer and worktree filesystem,
// if the given storer is complete empty ErrRepositoryNotExists is returned.
// The worktree can be nil when the repository being opened is bare, if the
// repository is a normal one (not bare) and worktree is nil the err
// ErrWorktreeNotProvided is returned
func Open(s storage.Storer, worktree billy.Filesystem) (*Repository, error) {
_, err := s.Reference(plumbing.HEAD)
if err == plumbing.ErrReferenceNotFound {
return nil, ErrRepositoryNotExists
}
if err != nil {
return nil, err
}
return newRepository(s, worktree), nil
}
// Clone a repository into the given Storer and worktree Filesystem with the
// given options, if worktree is nil a bare repository is created. If the given
// storer is not empty ErrRepositoryAlreadyExists is returned.
func Clone(s storage.Storer, worktree billy.Filesystem, o *CloneOptions) (*Repository, error) {
return CloneContext(context.Background(), s, worktree, o)
}
// CloneContext a repository into the given Storer and worktree Filesystem with
// the given options, if worktree is nil a bare repository is created. If the
// given storer is not empty ErrRepositoryAlreadyExists is returned.
//
// The provided Context must be non-nil. If the context expires before the
// operation is complete, an error is returned. The context only affects the
// transport operations.
func CloneContext(
ctx context.Context, s storage.Storer, worktree billy.Filesystem, o *CloneOptions,
) (*Repository, error) {
r, err := Init(s, worktree)
if err != nil {
return nil, err
}
return r, r.clone(ctx, o)
}
// PlainInit create an empty git repository at the given path. isBare defines
// if the repository will have worktree (non-bare) or not (bare), if the path
// is not empty ErrRepositoryAlreadyExists is returned.
func PlainInit(path string, isBare bool) (*Repository, error) {
return PlainInitWithOptions(path, &PlainInitOptions{
Bare: isBare,
})
}
func PlainInitWithOptions(path string, opts *PlainInitOptions) (*Repository, error) {
if opts == nil {
opts = &PlainInitOptions{}
}
var wt, dot billy.Filesystem
if opts.Bare {
dot = osfs.New(path)
} else {
wt = osfs.New(path)
dot, _ = wt.Chroot(GitDirName)
}
s := filesystem.NewStorage(dot, cache.NewObjectLRUDefault())
r, err := InitWithOptions(s, wt, opts.InitOptions)
if err != nil {
return nil, err
}
cfg, err := r.Config()
if err != nil {
return nil, err
}
if opts.ObjectFormat != "" {
if opts.ObjectFormat == formatcfg.SHA256 && hash.CryptoType != crypto.SHA256 {
return nil, ErrSHA256NotSupported
}
cfg.Core.RepositoryFormatVersion = formatcfg.Version_1
cfg.Extensions.ObjectFormat = opts.ObjectFormat
}
err = r.Storer.SetConfig(cfg)
if err != nil {
return nil, err
}
return r, err
}
// PlainOpen opens a git repository from the given path. It detects if the
// repository is bare or a normal one. If the path doesn't contain a valid
// repository ErrRepositoryNotExists is returned
func PlainOpen(path string) (*Repository, error) {
return PlainOpenWithOptions(path, &PlainOpenOptions{})
}
// PlainOpenWithOptions opens a git repository from the given path with specific
// options. See PlainOpen for more info.
func PlainOpenWithOptions(path string, o *PlainOpenOptions) (*Repository, error) {
dot, wt, err := dotGitToOSFilesystems(path, o.DetectDotGit)
if err != nil {
return nil, err
}
if _, err := dot.Stat(""); err != nil {
if os.IsNotExist(err) {
return nil, ErrRepositoryNotExists
}
return nil, err
}
var repositoryFs billy.Filesystem
if o.EnableDotGitCommonDir {
dotGitCommon, err := dotGitCommonDirectory(dot)
if err != nil {
return nil, err
}
repositoryFs = dotgit.NewRepositoryFilesystem(dot, dotGitCommon)
} else {
repositoryFs = dot
}
s := filesystem.NewStorage(repositoryFs, cache.NewObjectLRUDefault())
return Open(s, wt)
}
func dotGitToOSFilesystems(path string, detect bool) (dot, wt billy.Filesystem, err error) {
path, err = path_util.ReplaceTildeWithHome(path)
if err != nil {
return nil, nil, err
}
if path, err = filepath.Abs(path); err != nil {
return nil, nil, err
}
var fs billy.Filesystem
var fi os.FileInfo
for {
fs = osfs.New(path)
pathinfo, err := fs.Stat("/")
if !os.IsNotExist(err) {
if pathinfo == nil {
return nil, nil, err
}
if !pathinfo.IsDir() && detect {
fs = osfs.New(filepath.Dir(path))
}
}
fi, err = fs.Stat(GitDirName)
if err == nil {
// no error; stop
break
}
if !os.IsNotExist(err) {
// unknown error; stop
return nil, nil, err
}
if detect {
// try its parent as long as we haven't reached
// the root dir
if dir := filepath.Dir(path); dir != path {
path = dir
continue
}
}
// not detecting via parent dirs and the dir does not exist;
// stop
return fs, nil, nil
}
if fi.IsDir() {
dot, err = fs.Chroot(GitDirName)
return dot, fs, err
}
dot, err = dotGitFileToOSFilesystem(path, fs)
if err != nil {
return nil, nil, err
}
return dot, fs, nil
}
func dotGitFileToOSFilesystem(path string, fs billy.Filesystem) (bfs billy.Filesystem, err error) {
f, err := fs.Open(GitDirName)
if err != nil {
return nil, err
}
defer ioutil.CheckClose(f, &err)
b, err := io.ReadAll(f)
if err != nil {
return nil, err
}
line := string(b)
const prefix = "gitdir: "
if !strings.HasPrefix(line, prefix) {
return nil, fmt.Errorf(".git file has no %s prefix", prefix)
}
gitdir := strings.Split(line[len(prefix):], "\n")[0]
gitdir = strings.TrimSpace(gitdir)
if filepath.IsAbs(gitdir) {
return osfs.New(gitdir), nil
}
return osfs.New(fs.Join(path, gitdir)), nil
}
func dotGitCommonDirectory(fs billy.Filesystem) (commonDir billy.Filesystem, err error) {
f, err := fs.Open("commondir")
if os.IsNotExist(err) {
return nil, nil
}
if err != nil {
return nil, err
}
b, err := io.ReadAll(f)
if err != nil {
return nil, err
}
if len(b) > 0 {
path := strings.TrimSpace(string(b))
if filepath.IsAbs(path) {
commonDir = osfs.New(path)
} else {
commonDir = osfs.New(filepath.Join(fs.Root(), path))
}
if _, err := commonDir.Stat(""); err != nil {
if os.IsNotExist(err) {
return nil, ErrRepositoryIncomplete
}
return nil, err
}
}
return commonDir, nil
}
// PlainClone a repository into the path with the given options, isBare defines
// if the new repository will be bare or normal. If the path is not empty
// ErrRepositoryAlreadyExists is returned.
//
// TODO(mcuadros): move isBare to CloneOptions in v5
func PlainClone(path string, isBare bool, o *CloneOptions) (*Repository, error) {
return PlainCloneContext(context.Background(), path, isBare, o)
}
// PlainCloneContext a repository into the path with the given options, isBare
// defines if the new repository will be bare or normal. If the path is not empty
// ErrRepositoryAlreadyExists is returned.
//
// The provided Context must be non-nil. If the context expires before the
// operation is complete, an error is returned. The context only affects the
// transport operations.
//
// TODO(mcuadros): move isBare to CloneOptions in v5
// TODO(smola): refuse upfront to clone on a non-empty directory in v5, see #1027
func PlainCloneContext(ctx context.Context, path string, isBare bool, o *CloneOptions) (*Repository, error) {
cleanup, cleanupParent, err := checkIfCleanupIsNeeded(path)
if err != nil {
return nil, err
}
if o.Mirror {
isBare = true
}
r, err := PlainInit(path, isBare)
if err != nil {
return nil, err
}
err = r.clone(ctx, o)
if err != nil && err != ErrRepositoryAlreadyExists {
if cleanup {
_ = cleanUpDir(path, cleanupParent)
}
}
return r, err
}
func newRepository(s storage.Storer, worktree billy.Filesystem) *Repository {
return &Repository{
Storer: s,
wt: worktree,
r: make(map[string]*Remote),
}
}
func checkIfCleanupIsNeeded(path string) (cleanup bool, cleanParent bool, err error) {
fi, err := osfs.Default.Stat(path)
if err != nil {
if os.IsNotExist(err) {
return true, true, nil
}
return false, false, err
}
if !fi.IsDir() {
return false, false, fmt.Errorf("path is not a directory: %s", path)
}
files, err := osfs.Default.ReadDir(path)
if err != nil {
return false, false, err
}
if len(files) == 0 {
return true, false, nil
}
return false, false, nil
}
func cleanUpDir(path string, all bool) error {
if all {
return util.RemoveAll(osfs.Default, path)
}
files, err := osfs.Default.ReadDir(path)
if err != nil {
return err
}
for _, fi := range files {
if err := util.RemoveAll(osfs.Default, osfs.Default.Join(path, fi.Name())); err != nil {
return err
}
}
return err
}
// Config return the repository config. In a filesystem backed repository this
// means read the `.git/config`.
func (r *Repository) Config() (*config.Config, error) {
return r.Storer.Config()
}
// SetConfig marshall and writes the repository config. In a filesystem backed
// repository this means write the `.git/config`. This function should be called
// with the result of `Repository.Config` and never with the output of
// `Repository.ConfigScoped`.
func (r *Repository) SetConfig(cfg *config.Config) error {
return r.Storer.SetConfig(cfg)
}
// ConfigScoped returns the repository config, merged with requested scope and
// lower. For example if, config.GlobalScope is given the local and global config
// are returned merged in one config value.
func (r *Repository) ConfigScoped(scope config.Scope) (*config.Config, error) {
// TODO(mcuadros): v6, add this as ConfigOptions.Scoped
var err error
system := config.NewConfig()
if scope >= config.SystemScope {
system, err = config.LoadConfig(config.SystemScope)
if err != nil {
return nil, err
}
}
global := config.NewConfig()
if scope >= config.GlobalScope {
global, err = config.LoadConfig(config.GlobalScope)
if err != nil {
return nil, err
}
}
local, err := r.Storer.Config()
if err != nil {
return nil, err
}
_ = mergo.Merge(global, system)
_ = mergo.Merge(local, global)
return local, nil
}
// Remote return a remote if exists
func (r *Repository) Remote(name string) (*Remote, error) {
cfg, err := r.Config()
if err != nil {
return nil, err
}
c, ok := cfg.Remotes[name]
if !ok {
return nil, ErrRemoteNotFound
}
return NewRemote(r.Storer, c), nil
}
// Remotes returns a list with all the remotes
func (r *Repository) Remotes() ([]*Remote, error) {
cfg, err := r.Config()
if err != nil {
return nil, err
}
remotes := make([]*Remote, len(cfg.Remotes))
var i int
for _, c := range cfg.Remotes {
remotes[i] = NewRemote(r.Storer, c)
i++
}
return remotes, nil
}
// CreateRemote creates a new remote
func (r *Repository) CreateRemote(c *config.RemoteConfig) (*Remote, error) {
if err := c.Validate(); err != nil {
return nil, err
}
remote := NewRemote(r.Storer, c)
cfg, err := r.Config()
if err != nil {
return nil, err
}
if _, ok := cfg.Remotes[c.Name]; ok {
return nil, ErrRemoteExists
}
cfg.Remotes[c.Name] = c
return remote, r.Storer.SetConfig(cfg)
}
// CreateRemoteAnonymous creates a new anonymous remote. c.Name must be "anonymous".
// It's used like 'git fetch git@github.com:src-d/go-git.git master:master'.
func (r *Repository) CreateRemoteAnonymous(c *config.RemoteConfig) (*Remote, error) {
if err := c.Validate(); err != nil {
return nil, err
}
if c.Name != "anonymous" {
return nil, ErrAnonymousRemoteName
}
remote := NewRemote(r.Storer, c)
return remote, nil
}
// DeleteRemote delete a remote from the repository and delete the config
func (r *Repository) DeleteRemote(name string) error {
cfg, err := r.Config()
if err != nil {
return err
}
if _, ok := cfg.Remotes[name]; !ok {
return ErrRemoteNotFound
}
delete(cfg.Remotes, name)
return r.Storer.SetConfig(cfg)
}
// Branch return a Branch if exists
func (r *Repository) Branch(name string) (*config.Branch, error) {
cfg, err := r.Config()
if err != nil {
return nil, err
}
b, ok := cfg.Branches[name]
if !ok {
return nil, ErrBranchNotFound
}
return b, nil
}
// CreateBranch creates a new Branch
func (r *Repository) CreateBranch(c *config.Branch) error {
if err := c.Validate(); err != nil {
return err
}
cfg, err := r.Config()
if err != nil {
return err
}
if _, ok := cfg.Branches[c.Name]; ok {
return ErrBranchExists
}
cfg.Branches[c.Name] = c
return r.Storer.SetConfig(cfg)
}
// DeleteBranch delete a Branch from the repository and delete the config
func (r *Repository) DeleteBranch(name string) error {
cfg, err := r.Config()
if err != nil {
return err
}
if _, ok := cfg.Branches[name]; !ok {
return ErrBranchNotFound
}
delete(cfg.Branches, name)
return r.Storer.SetConfig(cfg)
}
// CreateTag creates a tag. If opts is included, the tag is an annotated tag,
// otherwise a lightweight tag is created.
func (r *Repository) CreateTag(name string, hash plumbing.Hash, opts *CreateTagOptions) (*plumbing.Reference, error) {
rname := plumbing.NewTagReferenceName(name)
if err := rname.Validate(); err != nil {
return nil, err
}
_, err := r.Storer.Reference(rname)
switch err {
case nil:
// Tag exists, this is an error
return nil, ErrTagExists
case plumbing.ErrReferenceNotFound:
// Tag missing, available for creation, pass this
default:
// Some other error
return nil, err
}
var target plumbing.Hash
if opts != nil {
target, err = r.createTagObject(name, hash, opts)
if err != nil {
return nil, err
}
} else {
target = hash
}
ref := plumbing.NewHashReference(rname, target)
if err = r.Storer.SetReference(ref); err != nil {
return nil, err
}
return ref, nil
}
func (r *Repository) createTagObject(name string, hash plumbing.Hash, opts *CreateTagOptions) (plumbing.Hash, error) {
if err := opts.Validate(r, hash); err != nil {
return plumbing.ZeroHash, err
}
rawobj, err := object.GetObject(r.Storer, hash)
if err != nil {
return plumbing.ZeroHash, err
}
tag := &object.Tag{
Name: name,
Tagger: *opts.Tagger,
Message: opts.Message,
TargetType: rawobj.Type(),
Target: hash,
}
if opts.SignKey != nil {
sig, err := r.buildTagSignature(tag, opts.SignKey)
if err != nil {
return plumbing.ZeroHash, err
}
tag.PGPSignature = sig
}
obj := r.Storer.NewEncodedObject()
if err := tag.Encode(obj); err != nil {
return plumbing.ZeroHash, err
}
return r.Storer.SetEncodedObject(obj)
}
func (r *Repository) buildTagSignature(tag *object.Tag, signKey *openpgp.Entity) (string, error) {
encoded := &plumbing.MemoryObject{}
if err := tag.Encode(encoded); err != nil {
return "", err
}
rdr, err := encoded.Reader()
if err != nil {
return "", err
}
var b bytes.Buffer
if err := openpgp.ArmoredDetachSign(&b, signKey, rdr, nil); err != nil {
return "", err
}
return b.String(), nil
}
// Tag returns a tag from the repository.
//
// If you want to check to see if the tag is an annotated tag, you can call
// TagObject on the hash of the reference in ForEach:
//
// ref, err := r.Tag("v0.1.0")
// if err != nil {
// // Handle error
// }
//
// obj, err := r.TagObject(ref.Hash())
// switch err {
// case nil:
// // Tag object present
// case plumbing.ErrObjectNotFound:
// // Not a tag object
// default:
// // Some other error
// }
func (r *Repository) Tag(name string) (*plumbing.Reference, error) {
ref, err := r.Reference(plumbing.ReferenceName(path.Join("refs", "tags", name)), false)
if err != nil {
if err == plumbing.ErrReferenceNotFound {
// Return a friendly error for this one, versus just ReferenceNotFound.
return nil, ErrTagNotFound
}
return nil, err
}
return ref, nil
}
// DeleteTag deletes a tag from the repository.
func (r *Repository) DeleteTag(name string) error {
_, err := r.Tag(name)
if err != nil {
return err
}
return r.Storer.RemoveReference(plumbing.ReferenceName(path.Join("refs", "tags", name)))
}
func (r *Repository) resolveToCommitHash(h plumbing.Hash) (plumbing.Hash, error) {
obj, err := r.Storer.EncodedObject(plumbing.AnyObject, h)
if err != nil {
return plumbing.ZeroHash, err
}
switch obj.Type() {
case plumbing.TagObject:
t, err := object.DecodeTag(r.Storer, obj)
if err != nil {
return plumbing.ZeroHash, err
}
return r.resolveToCommitHash(t.Target)
case plumbing.CommitObject:
return h, nil
default:
return plumbing.ZeroHash, ErrUnableToResolveCommit
}
}
// Clone clones a remote repository
func (r *Repository) clone(ctx context.Context, o *CloneOptions) error {
if err := o.Validate(); err != nil {
return err
}
c := &config.RemoteConfig{
Name: o.RemoteName,
URLs: []string{o.URL},
Fetch: r.cloneRefSpec(o),
Mirror: o.Mirror,
}
if _, err := r.CreateRemote(c); err != nil {
return err
}
// When the repository to clone is on the local machine,
// instead of using hard links, automatically setup .git/objects/info/alternates
// to share the objects with the source repository
if o.Shared {
if !url.IsLocalEndpoint(o.URL) {
return ErrAlternatePathNotSupported
}
altpath := o.URL
remoteRepo, err := PlainOpen(o.URL)
if err != nil {
return fmt.Errorf("failed to open remote repository: %w", err)
}
conf, err := remoteRepo.Config()
if err != nil {
return fmt.Errorf("failed to read remote repository configuration: %w", err)
}
if !conf.Core.IsBare {
altpath = path.Join(altpath, GitDirName)
}
if err := r.Storer.AddAlternate(altpath); err != nil {
return fmt.Errorf("failed to add alternate file to git objects dir: %w", err)
}
}
ref, err := r.fetchAndUpdateReferences(ctx, &FetchOptions{
RefSpecs: c.Fetch,
Depth: o.Depth,
Auth: o.Auth,
Progress: o.Progress,
Tags: o.Tags,
RemoteName: o.RemoteName,
InsecureSkipTLS: o.InsecureSkipTLS,
CABundle: o.CABundle,
ProxyOptions: o.ProxyOptions,
}, o.ReferenceName)
if err != nil {
return err
}
if r.wt != nil && !o.NoCheckout {
w, err := r.Worktree()
if err != nil {
return err
}
head, err := r.Head()
if err != nil {
return err
}
if err := w.Reset(&ResetOptions{
Mode: MergeReset,
Commit: head.Hash(),
}); err != nil {
return err
}
if o.RecurseSubmodules != NoRecurseSubmodules {
if err := w.updateSubmodules(ctx, &SubmoduleUpdateOptions{
RecurseSubmodules: o.RecurseSubmodules,
Depth: func() int {
if o.ShallowSubmodules {
return 1
}
return 0
}(),
Auth: o.Auth,
}); err != nil {
return err
}
}
}
if err := r.updateRemoteConfigIfNeeded(o, c, ref); err != nil {
return err
}
if !o.Mirror && ref.Name().IsBranch() {
branchRef := ref.Name()
branchName := strings.Split(string(branchRef), "refs/heads/")[1]
b := &config.Branch{
Name: branchName,
Merge: branchRef,
}
if o.RemoteName == "" {
b.Remote = "origin"
} else {
b.Remote = o.RemoteName
}
if err := r.CreateBranch(b); err != nil {
return err
}
}
return nil
}
const (
refspecTag = "+refs/tags/%s:refs/tags/%[1]s"
refspecSingleBranch = "+refs/heads/%s:refs/remotes/%s/%[1]s"
refspecSingleBranchHEAD = "+HEAD:refs/remotes/%s/HEAD"
)
func (r *Repository) cloneRefSpec(o *CloneOptions) []config.RefSpec {
switch {
case o.Mirror:
return []config.RefSpec{"+refs/*:refs/*"}
case o.ReferenceName.IsTag():
return []config.RefSpec{
config.RefSpec(fmt.Sprintf(refspecTag, o.ReferenceName.Short())),
}
case o.SingleBranch && o.ReferenceName == plumbing.HEAD:
return []config.RefSpec{
config.RefSpec(fmt.Sprintf(refspecSingleBranchHEAD, o.RemoteName)),
}
case o.SingleBranch:
return []config.RefSpec{
config.RefSpec(fmt.Sprintf(refspecSingleBranch, o.ReferenceName.Short(), o.RemoteName)),
}
default:
return []config.RefSpec{
config.RefSpec(fmt.Sprintf(config.DefaultFetchRefSpec, o.RemoteName)),
}
}
}
func (r *Repository) setIsBare(isBare bool) error {
cfg, err := r.Config()
if err != nil {
return err
}
cfg.Core.IsBare = isBare
return r.Storer.SetConfig(cfg)
}
func (r *Repository) updateRemoteConfigIfNeeded(o *CloneOptions, c *config.RemoteConfig, _ *plumbing.Reference) error {
if !o.SingleBranch {
return nil
}
c.Fetch = r.cloneRefSpec(o)
cfg, err := r.Config()
if err != nil {
return err
}
cfg.Remotes[c.Name] = c
return r.Storer.SetConfig(cfg)
}
func (r *Repository) fetchAndUpdateReferences(
ctx context.Context, o *FetchOptions, ref plumbing.ReferenceName,
) (*plumbing.Reference, error) {
if err := o.Validate(); err != nil {
return nil, err
}
remote, err := r.Remote(o.RemoteName)
if err != nil {
return nil, err
}
objsUpdated := true
remoteRefs, err := remote.fetch(ctx, o)
if err == NoErrAlreadyUpToDate {
objsUpdated = false
} else if err == packfile.ErrEmptyPackfile {
return nil, ErrFetching
} else if err != nil {
return nil, err
}
resolvedRef, err := expand_ref(remoteRefs, ref)
if err != nil {
return nil, err
}
refsUpdated, err := r.updateReferences(remote.c.Fetch, resolvedRef)
if err != nil {
return nil, err
}
if !objsUpdated && !refsUpdated {
return nil, NoErrAlreadyUpToDate
}
return resolvedRef, nil
}
func (r *Repository) updateReferences(spec []config.RefSpec,
resolvedRef *plumbing.Reference) (updated bool, err error) {
if !resolvedRef.Name().IsBranch() {
// Detached HEAD mode
h, err := r.resolveToCommitHash(resolvedRef.Hash())
if err != nil {
return false, err
}
head := plumbing.NewHashReference(plumbing.HEAD, h)
return updateReferenceStorerIfNeeded(r.Storer, head)
}
refs := []*plumbing.Reference{
// Create local reference for the resolved ref
resolvedRef,
// Create local symbolic HEAD
plumbing.NewSymbolicReference(plumbing.HEAD, resolvedRef.Name()),
}
refs = append(refs, r.calculateRemoteHeadReference(spec, resolvedRef)...)
for _, ref := range refs {
u, err := updateReferenceStorerIfNeeded(r.Storer, ref)
if err != nil {
return updated, err
}
if u {
updated = true
}
}
return
}
func (r *Repository) calculateRemoteHeadReference(spec []config.RefSpec,
resolvedHead *plumbing.Reference) []*plumbing.Reference {
var refs []*plumbing.Reference
// Create resolved HEAD reference with remote prefix if it does not
// exist. This is needed when using single branch and HEAD.
for _, rs := range spec {
name := resolvedHead.Name()
if !rs.Match(name) {
continue
}
name = rs.Dst(name)
_, err := r.Storer.Reference(name)
if err == plumbing.ErrReferenceNotFound {
refs = append(refs, plumbing.NewHashReference(name, resolvedHead.Hash()))
}
}
return refs
}
func checkAndUpdateReferenceStorerIfNeeded(
s storer.ReferenceStorer, r, old *plumbing.Reference) (
updated bool, err error) {
p, err := s.Reference(r.Name())
if err != nil && err != plumbing.ErrReferenceNotFound {
return false, err
}
// we use the string method to compare references, is the easiest way
if err == plumbing.ErrReferenceNotFound || r.String() != p.String() {
if err := s.CheckAndSetReference(r, old); err != nil {
return false, err
}
return true, nil
}
return false, nil
}
func updateReferenceStorerIfNeeded(
s storer.ReferenceStorer, r *plumbing.Reference) (updated bool, err error) {
return checkAndUpdateReferenceStorerIfNeeded(s, r, nil)
}
// Fetch fetches references along with the objects necessary to complete
// their histories, from the remote named as FetchOptions.RemoteName.
//
// Returns nil if the operation is successful, NoErrAlreadyUpToDate if there are
// no changes to be fetched, or an error.
func (r *Repository) Fetch(o *FetchOptions) error {
return r.FetchContext(context.Background(), o)
}
// FetchContext fetches references along with the objects necessary to complete
// their histories, from the remote named as FetchOptions.RemoteName.
//
// Returns nil if the operation is successful, NoErrAlreadyUpToDate if there are
// no changes to be fetched, or an error.
//
// The provided Context must be non-nil. If the context expires before the
// operation is complete, an error is returned. The context only affects the
// transport operations.
func (r *Repository) FetchContext(ctx context.Context, o *FetchOptions) error {
if err := o.Validate(); err != nil {
return err
}
remote, err := r.Remote(o.RemoteName)
if err != nil {
return err
}
return remote.FetchContext(ctx, o)
}
// Push performs a push to the remote. Returns NoErrAlreadyUpToDate if
// the remote was already up-to-date, from the remote named as
// FetchOptions.RemoteName.
func (r *Repository) Push(o *PushOptions) error {
return r.PushContext(context.Background(), o)
}
// PushContext performs a push to the remote. Returns NoErrAlreadyUpToDate if
// the remote was already up-to-date, from the remote named as
// FetchOptions.RemoteName.
//
// The provided Context must be non-nil. If the context expires before the
// operation is complete, an error is returned. The context only affects the
// transport operations.
func (r *Repository) PushContext(ctx context.Context, o *PushOptions) error {
if err := o.Validate(); err != nil {
return err
}
remote, err := r.Remote(o.RemoteName)
if err != nil {
return err
}
return remote.PushContext(ctx, o)
}
// Log returns the commit history from the given LogOptions.
func (r *Repository) Log(o *LogOptions) (object.CommitIter, error) {
fn := commitIterFunc(o.Order)
if fn == nil {
return nil, fmt.Errorf("invalid Order=%v", o.Order)
}
var (
it object.CommitIter
err error
)
if o.All {
it, err = r.logAll(fn)
} else {
it, err = r.log(o.From, fn)
}
if err != nil {
return nil, err
}
if o.FileName != nil {
// for `git log --all` also check parent (if the next commit comes from the real parent)
it = r.logWithFile(*o.FileName, it, o.All)
}
if o.PathFilter != nil {
it = r.logWithPathFilter(o.PathFilter, it, o.All)
}
if o.Since != nil || o.Until != nil {
limitOptions := object.LogLimitOptions{Since: o.Since, Until: o.Until}
it = r.logWithLimit(it, limitOptions)
}
return it, nil
}
func (r *Repository) log(from plumbing.Hash, commitIterFunc func(*object.Commit) object.CommitIter) (object.CommitIter, error) {
h := from
if from == plumbing.ZeroHash {
head, err := r.Head()
if err != nil {
return nil, err
}
h = head.Hash()
}
commit, err := r.CommitObject(h)
if err != nil {
return nil, err
}
return commitIterFunc(commit), nil
}
func (r *Repository) logAll(commitIterFunc func(*object.Commit) object.CommitIter) (object.CommitIter, error) {
return object.NewCommitAllIter(r.Storer, commitIterFunc)
}
func (*Repository) logWithFile(fileName string, commitIter object.CommitIter, checkParent bool) object.CommitIter {
return object.NewCommitPathIterFromIter(
func(path string) bool {
return path == fileName
},
commitIter,
checkParent,
)
}
func (*Repository) logWithPathFilter(pathFilter func(string) bool, commitIter object.CommitIter, checkParent bool) object.CommitIter {
return object.NewCommitPathIterFromIter(
pathFilter,
commitIter,
checkParent,
)
}
func (*Repository) logWithLimit(commitIter object.CommitIter, limitOptions object.LogLimitOptions) object.CommitIter {
return object.NewCommitLimitIterFromIter(commitIter, limitOptions)
}
func commitIterFunc(order LogOrder) func(c *object.Commit) object.CommitIter {
switch order {
case LogOrderDefault:
return func(c *object.Commit) object.CommitIter {
return object.NewCommitPreorderIter(c, nil, nil)
}
case LogOrderDFS:
return func(c *object.Commit) object.CommitIter {
return object.NewCommitPreorderIter(c, nil, nil)
}
case LogOrderDFSPost:
return func(c *object.Commit) object.CommitIter {
return object.NewCommitPostorderIter(c, nil)
}
case LogOrderBSF:
return func(c *object.Commit) object.CommitIter {
return object.NewCommitIterBSF(c, nil, nil)
}
case LogOrderCommitterTime:
return func(c *object.Commit) object.CommitIter {
return object.NewCommitIterCTime(c, nil, nil)
}
}
return nil
}
// Tags returns all the tag References in a repository.
//
// If you want to check to see if the tag is an annotated tag, you can call
// TagObject on the hash Reference passed in through ForEach:
//
// iter, err := r.Tags()
// if err != nil {
// // Handle error
// }
//
// if err := iter.ForEach(func (ref *plumbing.Reference) error {
// obj, err := r.TagObject(ref.Hash())
// switch err {
// case nil:
// // Tag object present
// case plumbing.ErrObjectNotFound:
// // Not a tag object
// default:
// // Some other error
// return err
// }
// }); err != nil {
// // Handle outer iterator error
// }
func (r *Repository) Tags() (storer.ReferenceIter, error) {
refIter, err := r.Storer.IterReferences()
if err != nil {
return nil, err
}
return storer.NewReferenceFilteredIter(
func(r *plumbing.Reference) bool {
return r.Name().IsTag()
}, refIter), nil
}
// Branches returns all the References that are Branches.
func (r *Repository) Branches() (storer.ReferenceIter, error) {
refIter, err := r.Storer.IterReferences()
if err != nil {
return nil, err
}
return storer.NewReferenceFilteredIter(
func(r *plumbing.Reference) bool {
return r.Name().IsBranch()
}, refIter), nil
}
// Notes returns all the References that are notes. For more information:
// https://git-scm.com/docs/git-notes
func (r *Repository) Notes() (storer.ReferenceIter, error) {
refIter, err := r.Storer.IterReferences()
if err != nil {
return nil, err
}
return storer.NewReferenceFilteredIter(
func(r *plumbing.Reference) bool {
return r.Name().IsNote()
}, refIter), nil
}
// TreeObject return a Tree with the given hash. If not found
// plumbing.ErrObjectNotFound is returned
func (r *Repository) TreeObject(h plumbing.Hash) (*object.Tree, error) {
return object.GetTree(r.Storer, h)
}
// TreeObjects returns an unsorted TreeIter with all the trees in the repository
func (r *Repository) TreeObjects() (*object.TreeIter, error) {
iter, err := r.Storer.IterEncodedObjects(plumbing.TreeObject)
if err != nil {
return nil, err
}
return object.NewTreeIter(r.Storer, iter), nil
}
// CommitObject return a Commit with the given hash. If not found
// plumbing.ErrObjectNotFound is returned.
func (r *Repository) CommitObject(h plumbing.Hash) (*object.Commit, error) {
return object.GetCommit(r.Storer, h)
}
// CommitObjects returns an unsorted CommitIter with all the commits in the repository.
func (r *Repository) CommitObjects() (object.CommitIter, error) {
iter, err := r.Storer.IterEncodedObjects(plumbing.CommitObject)
if err != nil {
return nil, err
}
return object.NewCommitIter(r.Storer, iter), nil
}
// BlobObject returns a Blob with the given hash. If not found
// plumbing.ErrObjectNotFound is returned.
func (r *Repository) BlobObject(h plumbing.Hash) (*object.Blob, error) {
return object.GetBlob(r.Storer, h)
}
// BlobObjects returns an unsorted BlobIter with all the blobs in the repository.
func (r *Repository) BlobObjects() (*object.BlobIter, error) {
iter, err := r.Storer.IterEncodedObjects(plumbing.BlobObject)
if err != nil {
return nil, err
}
return object.NewBlobIter(r.Storer, iter), nil
}
// TagObject returns a Tag with the given hash. If not found
// plumbing.ErrObjectNotFound is returned. This method only returns
// annotated Tags, no lightweight Tags.
func (r *Repository) TagObject(h plumbing.Hash) (*object.Tag, error) {
return object.GetTag(r.Storer, h)
}
// TagObjects returns a unsorted TagIter that can step through all of the annotated
// tags in the repository.
func (r *Repository) TagObjects() (*object.TagIter, error) {
iter, err := r.Storer.IterEncodedObjects(plumbing.TagObject)
if err != nil {
return nil, err
}
return object.NewTagIter(r.Storer, iter), nil
}
// Object returns an Object with the given hash. If not found
// plumbing.ErrObjectNotFound is returned.
func (r *Repository) Object(t plumbing.ObjectType, h plumbing.Hash) (object.Object, error) {
obj, err := r.Storer.EncodedObject(t, h)
if err != nil {
return nil, err
}
return object.DecodeObject(r.Storer, obj)
}
// Objects returns an unsorted ObjectIter with all the objects in the repository.
func (r *Repository) Objects() (*object.ObjectIter, error) {
iter, err := r.Storer.IterEncodedObjects(plumbing.AnyObject)
if err != nil {
return nil, err
}
return object.NewObjectIter(r.Storer, iter), nil
}
// Head returns the reference where HEAD is pointing to.
func (r *Repository) Head() (*plumbing.Reference, error) {
return storer.ResolveReference(r.Storer, plumbing.HEAD)
}
// Reference returns the reference for a given reference name. If resolved is
// true, any symbolic reference will be resolved.
func (r *Repository) Reference(name plumbing.ReferenceName, resolved bool) (
*plumbing.Reference, error) {
if resolved {
return storer.ResolveReference(r.Storer, name)
}
return r.Storer.Reference(name)
}
// References returns an unsorted ReferenceIter for all references.
func (r *Repository) References() (storer.ReferenceIter, error) {
return r.Storer.IterReferences()
}
// Worktree returns a worktree based on the given fs, if nil the default
// worktree will be used.
func (r *Repository) Worktree() (*Worktree, error) {
if r.wt == nil {
return nil, ErrIsBareRepository
}
return &Worktree{r: r, Filesystem: r.wt}, nil
}
func expand_ref(s storer.ReferenceStorer, ref plumbing.ReferenceName) (*plumbing.Reference, error) {
// For improving troubleshooting, this preserves the error for the provided `ref`,
// and returns the error for that specific ref in case all parse rules fails.
var ret error
for _, rule := range plumbing.RefRevParseRules {
resolvedRef, err := storer.ResolveReference(s, plumbing.ReferenceName(fmt.Sprintf(rule, ref)))
if err == nil {
return resolvedRef, nil
} else if ret == nil {
ret = err
}
}
return nil, ret
}
// ResolveRevision resolves revision to corresponding hash. It will always
// resolve to a commit hash, not a tree or annotated tag.
//
// Implemented resolvers : HEAD, branch, tag, heads/branch, refs/heads/branch,
// refs/tags/tag, refs/remotes/origin/branch, refs/remotes/origin/HEAD, tilde and caret (HEAD~1, master~^, tag~2, ref/heads/master~1, ...), selection by text (HEAD^{/fix nasty bug}), hash (prefix and full)
func (r *Repository) ResolveRevision(in plumbing.Revision) (*plumbing.Hash, error) {
rev := in.String()
if rev == "" {
return &plumbing.ZeroHash, plumbing.ErrReferenceNotFound
}
p := revision.NewParserFromString(rev)
items, err := p.Parse()
if err != nil {
return nil, err
}
var commit *object.Commit
for _, item := range items {
switch item := item.(type) {
case revision.Ref:
revisionRef := item
var tryHashes []plumbing.Hash
tryHashes = append(tryHashes, r.resolveHashPrefix(string(revisionRef))...)
ref, err := expand_ref(r.Storer, plumbing.ReferenceName(revisionRef))
if err == nil {
tryHashes = append(tryHashes, ref.Hash())
}
// in ambiguous cases, `git rev-parse` will emit a warning, but
// will always return the oid in preference to a ref; we don't have
// the ability to emit a warning here, so (for speed purposes)
// don't bother to detect the ambiguity either, just return in the
// priority that git would.
gotOne := false
for _, hash := range tryHashes {
commitObj, err := r.CommitObject(hash)
if err == nil {
commit = commitObj
gotOne = true
break
}
tagObj, err := r.TagObject(hash)
if err == nil {
// If the tag target lookup fails here, this most likely
// represents some sort of repo corruption, so let the
// error bubble up.
tagCommit, err := tagObj.Commit()
if err != nil {
return &plumbing.ZeroHash, err
}
commit = tagCommit
gotOne = true
break
}
}
if !gotOne {
return &plumbing.ZeroHash, plumbing.ErrReferenceNotFound
}
case revision.CaretPath:
depth := item.Depth
if depth == 0 {
break
}
iter := commit.Parents()
c, err := iter.Next()
if err != nil {
return &plumbing.ZeroHash, err
}
if depth == 1 {
commit = c
break
}
c, err = iter.Next()
if err != nil {
return &plumbing.ZeroHash, err
}
commit = c
case revision.TildePath:
for i := 0; i < item.Depth; i++ {
c, err := commit.Parents().Next()
if err != nil {
return &plumbing.ZeroHash, err
}
commit = c
}
case revision.CaretReg:
history := object.NewCommitPreorderIter(commit, nil, nil)
re := item.Regexp
negate := item.Negate
var c *object.Commit
err := history.ForEach(func(hc *object.Commit) error {
if !negate && re.MatchString(hc.Message) {
c = hc
return storer.ErrStop
}
if negate && !re.MatchString(hc.Message) {
c = hc
return storer.ErrStop
}
return nil
})
if err != nil {
return &plumbing.ZeroHash, err
}
if c == nil {
return &plumbing.ZeroHash, fmt.Errorf("no commit message match regexp: %q", re.String())
}
commit = c
}
}
if commit == nil {
return &plumbing.ZeroHash, plumbing.ErrReferenceNotFound
}
return &commit.Hash, nil
}
// resolveHashPrefix returns a list of potential hashes that the given string
// is a prefix of. It quietly swallows errors, returning nil.
func (r *Repository) resolveHashPrefix(hashStr string) []plumbing.Hash {
// Handle complete and partial hashes.
// plumbing.NewHash forces args into a full 20 byte hash, which isn't suitable
// for partial hashes since they will become zero-filled.
if hashStr == "" {
return nil
}
if len(hashStr) == len(plumbing.ZeroHash)*2 {
// Only a full hash is possible.
hexb, err := hex.DecodeString(hashStr)
if err != nil {
return nil
}
var h plumbing.Hash
copy(h[:], hexb)
return []plumbing.Hash{h}
}
// Partial hash.
// hex.DecodeString only decodes to complete bytes, so only works with pairs of hex digits.
evenHex := hashStr[:len(hashStr)&^1]
hexb, err := hex.DecodeString(evenHex)
if err != nil {
return nil
}
candidates := expandPartialHash(r.Storer, hexb)
if len(evenHex) == len(hashStr) {
// The prefix was an exact number of bytes.
return candidates
}
// Do another prefix check to ensure the dangling nybble is correct.
var hashes []plumbing.Hash
for _, h := range candidates {
if strings.HasPrefix(h.String(), hashStr) {
hashes = append(hashes, h)
}
}
return hashes
}
type RepackConfig struct {
// UseRefDeltas configures whether packfile encoder will use reference deltas.
// By default OFSDeltaObject is used.
UseRefDeltas bool
// OnlyDeletePacksOlderThan if set to non-zero value
// selects only objects older than the time provided.
OnlyDeletePacksOlderThan time.Time
}
func (r *Repository) RepackObjects(cfg *RepackConfig) (err error) {
pos, ok := r.Storer.(storer.PackedObjectStorer)
if !ok {
return ErrPackedObjectsNotSupported
}
// Get the existing object packs.
hs, err := pos.ObjectPacks()
if err != nil {
return err
}
// Create a new pack.
nh, err := r.createNewObjectPack(cfg)
if err != nil {
return err
}
// Delete old packs.
for _, h := range hs {
// Skip if new hash is the same as an old one.
if h == nh {
continue
}
err = pos.DeleteOldObjectPackAndIndex(h, cfg.OnlyDeletePacksOlderThan)
if err != nil {
return err
}
}
return nil
}
// Merge merges the reference branch into the current branch.
//
// If the merge is not possible (or supported) returns an error without changing
// the HEAD for the current branch. Possible errors include:
// - The merge strategy is not supported.
// - The specific strategy cannot be used (e.g. using FastForwardMerge when one is not possible).
func (r *Repository) Merge(ref plumbing.Reference, opts MergeOptions) error {
if opts.Strategy != FastForwardMerge {
return ErrUnsupportedMergeStrategy
}
// Ignore error as not having a shallow list is optional here.
shallowList, _ := r.Storer.Shallow()
var earliestShallow *plumbing.Hash
if len(shallowList) > 0 {
earliestShallow = &shallowList[0]
}
head, err := r.Head()
if err != nil {
return err
}
ff, err := isFastForward(r.Storer, head.Hash(), ref.Hash(), earliestShallow)
if err != nil {
return err
}
if !ff {
return ErrFastForwardMergeNotPossible
}
return r.Storer.SetReference(plumbing.NewHashReference(head.Name(), ref.Hash()))
}
// createNewObjectPack is a helper for RepackObjects taking care
// of creating a new pack. It is used so the PackfileWriter
// deferred close has the right scope.
func (r *Repository) createNewObjectPack(cfg *RepackConfig) (h plumbing.Hash, err error) {
ow := newObjectWalker(r.Storer)
err = ow.walkAllRefs()
if err != nil {
return h, err
}
objs := make([]plumbing.Hash, 0, len(ow.seen))
for h := range ow.seen {
objs = append(objs, h)
}
pfw, ok := r.Storer.(storer.PackfileWriter)
if !ok {
return h, fmt.Errorf("Repository storer is not a storer.PackfileWriter")
}
wc, err := pfw.PackfileWriter()
if err != nil {
return h, err
}
defer ioutil.CheckClose(wc, &err)
scfg, err := r.Config()
if err != nil {
return h, err
}
enc := packfile.NewEncoder(wc, r.Storer, cfg.UseRefDeltas)
h, err = enc.Encode(objs, scfg.Pack.Window)
if err != nil {
return h, err
}
// Delete the packed, loose objects.
if los, ok := r.Storer.(storer.LooseObjectStorer); ok {
err = los.ForEachObjectHash(func(hash plumbing.Hash) error {
if ow.isSeen(hash) {
err = los.DeleteLooseObject(hash)
if err != nil {
return err
}
}
return nil
})
if err != nil {
return h, err
}
}
return h, err
}
func expandPartialHash(st storer.EncodedObjectStorer, prefix []byte) (hashes []plumbing.Hash) {
// The fast version is implemented by storage/filesystem.ObjectStorage.
type fastIter interface {
HashesWithPrefix(prefix []byte) ([]plumbing.Hash, error)
}
if fi, ok := st.(fastIter); ok {
h, err := fi.HashesWithPrefix(prefix)
if err != nil {
return nil
}
return h
}
// Slow path.
iter, err := st.IterEncodedObjects(plumbing.AnyObject)
if err != nil {
return nil
}
iter.ForEach(func(obj plumbing.EncodedObject) error {
h := obj.Hash()
if bytes.HasPrefix(h[:], prefix) {
hashes = append(hashes, h)
}
return nil
})
return
}
go-git-5.13.2/repository_plan9_test.go 0000664 0000000 0000000 00000001701 14744245500 0017704 0 ustar 00root root 0000000 0000000 package git
import (
"fmt"
"strings"
)
// preReceiveHook returns the bytes of a pre-receive hook script
// that prints m before exiting successfully
func preReceiveHook(m string) []byte {
return []byte(fmt.Sprintf("#!/bin/rc\necho -n %s\n", quote(m)))
}
const quoteChar = '\''
func needsQuote(s string) bool {
for i := 0; i < len(s); i++ {
c := s[i]
if c == quoteChar || c <= ' ' { // quote, blanks, or control characters
return true
}
}
return false
}
// Quote adds single quotes to s in the style of rc(1) if they are needed.
// The behaviour should be identical to Plan 9's quote(3).
func quote(s string) string {
if s == "" {
return "''"
}
if !needsQuote(s) {
return s
}
var b strings.Builder
b.Grow(10 + len(s)) // Enough room for few quotes
b.WriteByte(quoteChar)
for i := 0; i < len(s); i++ {
c := s[i]
if c == quoteChar {
b.WriteByte(quoteChar)
}
b.WriteByte(c)
}
b.WriteByte(quoteChar)
return b.String()
}
go-git-5.13.2/repository_test.go 0000664 0000000 0000000 00000256730 14744245500 0016617 0 ustar 00root root 0000000 0000000 package git
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"os"
"os/exec"
"os/user"
"path"
"path/filepath"
"regexp"
"strings"
"testing"
"time"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/ProtonMail/go-crypto/openpgp"
"github.com/ProtonMail/go-crypto/openpgp/armor"
openpgperr "github.com/ProtonMail/go-crypto/openpgp/errors"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/plumbing/transport"
"github.com/go-git/go-git/v5/storage"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-git/v5/storage/memory"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-billy/v5/util"
. "gopkg.in/check.v1"
)
type RepositorySuite struct {
BaseSuite
}
var _ = Suite(&RepositorySuite{})
func (s *RepositorySuite) TestInit(c *C) {
r, err := Init(memory.NewStorage(), memfs.New())
c.Assert(err, IsNil)
c.Assert(r, NotNil)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Core.IsBare, Equals, false)
// check the HEAD to see what the default branch is
createCommit(c, r)
ref, err := r.Head()
c.Assert(err, IsNil)
c.Assert(ref.Name().String(), Equals, plumbing.Master.String())
}
func (s *RepositorySuite) TestInitWithOptions(c *C) {
r, err := InitWithOptions(memory.NewStorage(), memfs.New(), InitOptions{
DefaultBranch: "refs/heads/foo",
})
c.Assert(err, IsNil)
c.Assert(r, NotNil)
createCommit(c, r)
ref, err := r.Head()
c.Assert(err, IsNil)
c.Assert(ref.Name().String(), Equals, "refs/heads/foo")
}
func (s *RepositorySuite) TestInitWithInvalidDefaultBranch(c *C) {
_, err := InitWithOptions(memory.NewStorage(), memfs.New(), InitOptions{
DefaultBranch: "foo",
})
c.Assert(err, NotNil)
}
func createCommit(c *C, r *Repository) plumbing.Hash {
// Create a commit so there is a HEAD to check
wt, err := r.Worktree()
c.Assert(err, IsNil)
rm, err := wt.Filesystem.Create("foo.txt")
c.Assert(err, IsNil)
_, err = rm.Write([]byte("foo text"))
c.Assert(err, IsNil)
_, err = wt.Add("foo.txt")
c.Assert(err, IsNil)
author := object.Signature{
Name: "go-git",
Email: "go-git@fake.local",
When: time.Now(),
}
h, err := wt.Commit("test commit message", &CommitOptions{
All: true,
Author: &author,
Committer: &author,
AllowEmptyCommits: true,
})
c.Assert(err, IsNil)
return h
}
func (s *RepositorySuite) TestInitNonStandardDotGit(c *C) {
dir := c.MkDir()
fs := osfs.New(dir)
dot, _ := fs.Chroot("storage")
st := filesystem.NewStorage(dot, cache.NewObjectLRUDefault())
wt, _ := fs.Chroot("worktree")
r, err := Init(st, wt)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
f, err := fs.Open(fs.Join("worktree", ".git"))
c.Assert(err, IsNil)
defer func() { _ = f.Close() }()
all, err := io.ReadAll(f)
c.Assert(err, IsNil)
c.Assert(string(all), Equals, fmt.Sprintf("gitdir: %s\n", filepath.Join("..", "storage")))
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Core.Worktree, Equals, filepath.Join("..", "worktree"))
}
func (s *RepositorySuite) TestInitStandardDotGit(c *C) {
dir := c.MkDir()
fs := osfs.New(dir)
dot, _ := fs.Chroot(".git")
st := filesystem.NewStorage(dot, cache.NewObjectLRUDefault())
r, err := Init(st, fs)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
l, err := fs.ReadDir(".git")
c.Assert(err, IsNil)
c.Assert(len(l) > 0, Equals, true)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Core.Worktree, Equals, "")
}
func (s *RepositorySuite) TestInitBare(c *C) {
r, err := Init(memory.NewStorage(), nil)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Core.IsBare, Equals, true)
}
func (s *RepositorySuite) TestInitAlreadyExists(c *C) {
st := memory.NewStorage()
r, err := Init(st, nil)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
r, err = Init(st, nil)
c.Assert(err, Equals, ErrRepositoryAlreadyExists)
c.Assert(r, IsNil)
}
func (s *RepositorySuite) TestOpen(c *C) {
st := memory.NewStorage()
r, err := Init(st, memfs.New())
c.Assert(err, IsNil)
c.Assert(r, NotNil)
r, err = Open(st, memfs.New())
c.Assert(err, IsNil)
c.Assert(r, NotNil)
}
func (s *RepositorySuite) TestOpenBare(c *C) {
st := memory.NewStorage()
r, err := Init(st, nil)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
r, err = Open(st, nil)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
}
func (s *RepositorySuite) TestOpenBareMissingWorktree(c *C) {
st := memory.NewStorage()
r, err := Init(st, memfs.New())
c.Assert(err, IsNil)
c.Assert(r, NotNil)
r, err = Open(st, nil)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
}
func (s *RepositorySuite) TestOpenNotExists(c *C) {
r, err := Open(memory.NewStorage(), nil)
c.Assert(err, Equals, ErrRepositoryNotExists)
c.Assert(r, IsNil)
}
func (s *RepositorySuite) TestClone(c *C) {
r, err := Clone(memory.NewStorage(), nil, &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
remotes, err := r.Remotes()
c.Assert(err, IsNil)
c.Assert(remotes, HasLen, 1)
}
func (s *RepositorySuite) TestCloneContext(c *C) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
r, err := CloneContext(ctx, memory.NewStorage(), nil, &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(r, NotNil)
c.Assert(err, Equals, context.Canceled)
}
func (s *RepositorySuite) TestCloneMirror(c *C) {
r, err := Clone(memory.NewStorage(), nil, &CloneOptions{
URL: fixtures.Basic().One().URL,
Mirror: true,
})
c.Assert(err, IsNil)
refs, err := r.References()
var count int
refs.ForEach(func(r *plumbing.Reference) error { c.Log(r); count++; return nil })
c.Assert(err, IsNil)
// 6 refs total from github.com/git-fixtures/basic.git:
// - HEAD
// - refs/heads/master
// - refs/heads/branch
// - refs/pull/1/head
// - refs/pull/2/head
// - refs/pull/2/merge
c.Assert(count, Equals, 6)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Core.IsBare, Equals, true)
c.Assert(cfg.Remotes[DefaultRemoteName].Validate(), IsNil)
c.Assert(cfg.Remotes[DefaultRemoteName].Mirror, Equals, true)
}
func (s *RepositorySuite) TestCloneWithTags(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, err := Clone(memory.NewStorage(), nil, &CloneOptions{URL: url, Tags: NoTags})
c.Assert(err, IsNil)
remotes, err := r.Remotes()
c.Assert(err, IsNil)
c.Assert(remotes, HasLen, 1)
i, err := r.References()
c.Assert(err, IsNil)
var count int
i.ForEach(func(r *plumbing.Reference) error { count++; return nil })
c.Assert(count, Equals, 3)
}
func (s *RepositorySuite) TestCloneSparse(c *C) {
fs := memfs.New()
r, err := Clone(memory.NewStorage(), fs, &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
NoCheckout: true,
})
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
sparseCheckoutDirectories := []string{"go", "json", "php"}
c.Assert(w.Checkout(&CheckoutOptions{
Branch: "refs/heads/master",
SparseCheckoutDirectories: sparseCheckoutDirectories,
}), IsNil)
fis, err := fs.ReadDir(".")
c.Assert(err, IsNil)
for _, fi := range fis {
c.Assert(fi.IsDir(), Equals, true)
var oneOfSparseCheckoutDirs bool
for _, sparseCheckoutDirectory := range sparseCheckoutDirectories {
if strings.HasPrefix(fi.Name(), sparseCheckoutDirectory) {
oneOfSparseCheckoutDirs = true
}
}
c.Assert(oneOfSparseCheckoutDirs, Equals, true)
}
}
func (s *RepositorySuite) TestCreateRemoteAndRemote(c *C) {
r, _ := Init(memory.NewStorage(), nil)
remote, err := r.CreateRemote(&config.RemoteConfig{
Name: "foo",
URLs: []string{"http://foo/foo.git"},
})
c.Assert(err, IsNil)
c.Assert(remote.Config().Name, Equals, "foo")
alt, err := r.Remote("foo")
c.Assert(err, IsNil)
c.Assert(alt, Not(Equals), remote)
c.Assert(alt.Config().Name, Equals, "foo")
}
func (s *RepositorySuite) TestCreateRemoteInvalid(c *C) {
r, _ := Init(memory.NewStorage(), nil)
remote, err := r.CreateRemote(&config.RemoteConfig{})
c.Assert(err, Equals, config.ErrRemoteConfigEmptyName)
c.Assert(remote, IsNil)
}
func (s *RepositorySuite) TestCreateRemoteAnonymous(c *C) {
r, _ := Init(memory.NewStorage(), nil)
remote, err := r.CreateRemoteAnonymous(&config.RemoteConfig{
Name: "anonymous",
URLs: []string{"http://foo/foo.git"},
})
c.Assert(err, IsNil)
c.Assert(remote.Config().Name, Equals, "anonymous")
}
func (s *RepositorySuite) TestCreateRemoteAnonymousInvalidName(c *C) {
r, _ := Init(memory.NewStorage(), nil)
remote, err := r.CreateRemoteAnonymous(&config.RemoteConfig{
Name: "not_anonymous",
URLs: []string{"http://foo/foo.git"},
})
c.Assert(err, Equals, ErrAnonymousRemoteName)
c.Assert(remote, IsNil)
}
func (s *RepositorySuite) TestCreateRemoteAnonymousInvalid(c *C) {
r, _ := Init(memory.NewStorage(), nil)
remote, err := r.CreateRemoteAnonymous(&config.RemoteConfig{})
c.Assert(err, Equals, config.ErrRemoteConfigEmptyName)
c.Assert(remote, IsNil)
}
func (s *RepositorySuite) TestDeleteRemote(c *C) {
r, _ := Init(memory.NewStorage(), nil)
_, err := r.CreateRemote(&config.RemoteConfig{
Name: "foo",
URLs: []string{"http://foo/foo.git"},
})
c.Assert(err, IsNil)
err = r.DeleteRemote("foo")
c.Assert(err, IsNil)
alt, err := r.Remote("foo")
c.Assert(err, Equals, ErrRemoteNotFound)
c.Assert(alt, IsNil)
}
func (s *RepositorySuite) TestEmptyCreateBranch(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.CreateBranch(&config.Branch{})
c.Assert(err, NotNil)
}
func (s *RepositorySuite) TestInvalidCreateBranch(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.CreateBranch(&config.Branch{
Name: "-foo",
})
c.Assert(err, NotNil)
}
func (s *RepositorySuite) TestCreateBranchAndBranch(c *C) {
r, _ := Init(memory.NewStorage(), nil)
testBranch := &config.Branch{
Name: "foo",
Remote: "origin",
Merge: "refs/heads/foo",
}
err := r.CreateBranch(testBranch)
c.Assert(err, IsNil)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(len(cfg.Branches), Equals, 1)
branch := cfg.Branches["foo"]
c.Assert(branch.Name, Equals, testBranch.Name)
c.Assert(branch.Remote, Equals, testBranch.Remote)
c.Assert(branch.Merge, Equals, testBranch.Merge)
branch, err = r.Branch("foo")
c.Assert(err, IsNil)
c.Assert(branch.Name, Equals, testBranch.Name)
c.Assert(branch.Remote, Equals, testBranch.Remote)
c.Assert(branch.Merge, Equals, testBranch.Merge)
}
func (s *RepositorySuite) TestMergeFF(c *C) {
r, err := Init(memory.NewStorage(), memfs.New())
c.Assert(err, IsNil)
c.Assert(r, NotNil)
createCommit(c, r)
createCommit(c, r)
createCommit(c, r)
lastCommit := createCommit(c, r)
wt, err := r.Worktree()
c.Assert(err, IsNil)
targetBranch := plumbing.NewBranchReferenceName("foo")
err = wt.Checkout(&CheckoutOptions{
Hash: lastCommit,
Create: true,
Branch: targetBranch,
})
c.Assert(err, IsNil)
createCommit(c, r)
fooHash := createCommit(c, r)
// Checkout the master branch so that we can try to merge foo into it.
err = wt.Checkout(&CheckoutOptions{
Branch: plumbing.Master,
})
c.Assert(err, IsNil)
head, err := r.Head()
c.Assert(err, IsNil)
c.Assert(head.Hash(), Equals, lastCommit)
targetRef := plumbing.NewHashReference(targetBranch, fooHash)
c.Assert(targetRef, NotNil)
err = r.Merge(*targetRef, MergeOptions{
Strategy: FastForwardMerge,
})
c.Assert(err, IsNil)
head, err = r.Head()
c.Assert(err, IsNil)
c.Assert(head.Hash(), Equals, fooHash)
}
func (s *RepositorySuite) TestMergeFF_Invalid(c *C) {
r, err := Init(memory.NewStorage(), memfs.New())
c.Assert(err, IsNil)
c.Assert(r, NotNil)
// Keep track of the first commit, which will be the
// reference to create the target branch so that we
// can simulate a non-ff merge.
firstCommit := createCommit(c, r)
createCommit(c, r)
createCommit(c, r)
lastCommit := createCommit(c, r)
wt, err := r.Worktree()
c.Assert(err, IsNil)
targetBranch := plumbing.NewBranchReferenceName("foo")
err = wt.Checkout(&CheckoutOptions{
Hash: firstCommit,
Create: true,
Branch: targetBranch,
})
c.Assert(err, IsNil)
createCommit(c, r)
h := createCommit(c, r)
// Checkout the master branch so that we can try to merge foo into it.
err = wt.Checkout(&CheckoutOptions{
Branch: plumbing.Master,
})
c.Assert(err, IsNil)
head, err := r.Head()
c.Assert(err, IsNil)
c.Assert(head.Hash(), Equals, lastCommit)
targetRef := plumbing.NewHashReference(targetBranch, h)
c.Assert(targetRef, NotNil)
err = r.Merge(*targetRef, MergeOptions{
Strategy: MergeStrategy(10),
})
c.Assert(err, Equals, ErrUnsupportedMergeStrategy)
// Failed merge operations must not change HEAD.
head, err = r.Head()
c.Assert(err, IsNil)
c.Assert(head.Hash(), Equals, lastCommit)
err = r.Merge(*targetRef, MergeOptions{})
c.Assert(err, Equals, ErrFastForwardMergeNotPossible)
head, err = r.Head()
c.Assert(err, IsNil)
c.Assert(head.Hash(), Equals, lastCommit)
}
func (s *RepositorySuite) TestCreateBranchUnmarshal(c *C) {
r, _ := Init(memory.NewStorage(), nil)
expected := []byte(`[core]
bare = true
[remote "foo"]
url = http://foo/foo.git
fetch = +refs/heads/*:refs/remotes/foo/*
[branch "foo"]
remote = origin
merge = refs/heads/foo
[branch "master"]
remote = origin
merge = refs/heads/master
`)
_, err := r.CreateRemote(&config.RemoteConfig{
Name: "foo",
URLs: []string{"http://foo/foo.git"},
})
c.Assert(err, IsNil)
testBranch1 := &config.Branch{
Name: "master",
Remote: "origin",
Merge: "refs/heads/master",
}
testBranch2 := &config.Branch{
Name: "foo",
Remote: "origin",
Merge: "refs/heads/foo",
}
err = r.CreateBranch(testBranch1)
c.Assert(err, IsNil)
err = r.CreateBranch(testBranch2)
c.Assert(err, IsNil)
cfg, err := r.Config()
c.Assert(err, IsNil)
marshaled, err := cfg.Marshal()
c.Assert(err, IsNil)
c.Assert(string(expected), Equals, string(marshaled))
}
func (s *RepositorySuite) TestBranchInvalid(c *C) {
r, _ := Init(memory.NewStorage(), nil)
branch, err := r.Branch("foo")
c.Assert(err, NotNil)
c.Assert(branch, IsNil)
}
func (s *RepositorySuite) TestCreateBranchInvalid(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.CreateBranch(&config.Branch{})
c.Assert(err, NotNil)
testBranch := &config.Branch{
Name: "foo",
Remote: "origin",
Merge: "refs/heads/foo",
}
err = r.CreateBranch(testBranch)
c.Assert(err, IsNil)
err = r.CreateBranch(testBranch)
c.Assert(err, NotNil)
}
func (s *RepositorySuite) TestDeleteBranch(c *C) {
r, _ := Init(memory.NewStorage(), nil)
testBranch := &config.Branch{
Name: "foo",
Remote: "origin",
Merge: "refs/heads/foo",
}
err := r.CreateBranch(testBranch)
c.Assert(err, IsNil)
err = r.DeleteBranch("foo")
c.Assert(err, IsNil)
b, err := r.Branch("foo")
c.Assert(err, Equals, ErrBranchNotFound)
c.Assert(b, IsNil)
err = r.DeleteBranch("foo")
c.Assert(err, Equals, ErrBranchNotFound)
}
func (s *RepositorySuite) TestPlainInit(c *C) {
dir := c.MkDir()
r, err := PlainInit(dir, true)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Core.IsBare, Equals, true)
}
func (s *RepositorySuite) TestPlainInitWithOptions(c *C) {
dir := c.MkDir()
r, err := PlainInitWithOptions(dir, &PlainInitOptions{
InitOptions: InitOptions{
DefaultBranch: "refs/heads/foo",
},
Bare: false,
})
c.Assert(err, IsNil)
c.Assert(r, NotNil)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Core.IsBare, Equals, false)
createCommit(c, r)
ref, err := r.Head()
c.Assert(err, IsNil)
c.Assert(ref.Name().String(), Equals, "refs/heads/foo")
}
func (s *RepositorySuite) TestPlainInitAlreadyExists(c *C) {
dir := c.MkDir()
r, err := PlainInit(dir, true)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
r, err = PlainInit(dir, true)
c.Assert(err, Equals, ErrRepositoryAlreadyExists)
c.Assert(r, IsNil)
}
func (s *RepositorySuite) TestPlainOpen(c *C) {
dir := c.MkDir()
r, err := PlainInit(dir, false)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
r, err = PlainOpen(dir)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
}
func (s *RepositorySuite) TestPlainOpenTildePath(c *C) {
dir, clean := s.TemporalHomeDir()
defer clean()
r, err := PlainInit(dir, false)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
currentUser, err := user.Current()
c.Assert(err, IsNil)
// remove domain for windows
username := currentUser.Username[strings.Index(currentUser.Username, "\\")+1:]
homes := []string{"~/", "~" + username + "/"}
for _, home := range homes {
path := strings.Replace(dir, strings.Split(dir, ".tmp")[0], home, 1)
r, err = PlainOpen(path)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
}
}
func (s *RepositorySuite) TestPlainOpenBare(c *C) {
dir := c.MkDir()
r, err := PlainInit(dir, true)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
r, err = PlainOpen(dir)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
}
func (s *RepositorySuite) TestPlainOpenNotBare(c *C) {
dir := c.MkDir()
r, err := PlainInit(dir, false)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
r, err = PlainOpen(filepath.Join(dir, ".git"))
c.Assert(err, IsNil)
c.Assert(r, NotNil)
}
func (s *RepositorySuite) testPlainOpenGitFile(c *C, f func(string, string) string) {
fs := s.TemporalFilesystem(c)
dir, err := util.TempDir(fs, "", "plain-open")
c.Assert(err, IsNil)
r, err := PlainInit(fs.Join(fs.Root(), dir), true)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
altDir, err := util.TempDir(fs, "", "plain-open")
c.Assert(err, IsNil)
err = util.WriteFile(fs, fs.Join(altDir, ".git"),
[]byte(f(fs.Join(fs.Root(), dir), fs.Join(fs.Root(), altDir))),
0644,
)
c.Assert(err, IsNil)
r, err = PlainOpen(fs.Join(fs.Root(), altDir))
c.Assert(err, IsNil)
c.Assert(r, NotNil)
}
func (s *RepositorySuite) TestPlainOpenBareAbsoluteGitDirFile(c *C) {
s.testPlainOpenGitFile(c, func(dir, altDir string) string {
return fmt.Sprintf("gitdir: %s\n", dir)
})
}
func (s *RepositorySuite) TestPlainOpenBareAbsoluteGitDirFileNoEOL(c *C) {
s.testPlainOpenGitFile(c, func(dir, altDir string) string {
return fmt.Sprintf("gitdir: %s", dir)
})
}
func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFile(c *C) {
s.testPlainOpenGitFile(c, func(dir, altDir string) string {
dir, err := filepath.Rel(altDir, dir)
c.Assert(err, IsNil)
return fmt.Sprintf("gitdir: %s\n", dir)
})
}
func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFileNoEOL(c *C) {
s.testPlainOpenGitFile(c, func(dir, altDir string) string {
dir, err := filepath.Rel(altDir, dir)
c.Assert(err, IsNil)
return fmt.Sprintf("gitdir: %s\n", dir)
})
}
func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFileTrailingGarbage(c *C) {
fs := s.TemporalFilesystem(c)
dir, err := util.TempDir(fs, "", "")
c.Assert(err, IsNil)
r, err := PlainInit(dir, true)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
altDir, err := util.TempDir(fs, "", "")
c.Assert(err, IsNil)
err = util.WriteFile(fs, fs.Join(altDir, ".git"),
[]byte(fmt.Sprintf("gitdir: %s\nTRAILING", fs.Join(fs.Root(), altDir))),
0644,
)
c.Assert(err, IsNil)
r, err = PlainOpen(altDir)
c.Assert(err, Equals, ErrRepositoryNotExists)
c.Assert(r, IsNil)
}
func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFileBadPrefix(c *C) {
fs := s.TemporalFilesystem(c)
dir, err := util.TempDir(fs, "", "")
c.Assert(err, IsNil)
r, err := PlainInit(fs.Join(fs.Root(), dir), true)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
altDir, err := util.TempDir(fs, "", "")
c.Assert(err, IsNil)
err = util.WriteFile(fs, fs.Join(altDir, ".git"), []byte(
fmt.Sprintf("xgitdir: %s\n", fs.Join(fs.Root(), dir)),
), 0644)
c.Assert(err, IsNil)
r, err = PlainOpen(fs.Join(fs.Root(), altDir))
c.Assert(err, ErrorMatches, ".*gitdir.*")
c.Assert(r, IsNil)
}
func (s *RepositorySuite) TestPlainOpenNotExists(c *C) {
r, err := PlainOpen("/not-exists/")
c.Assert(err, Equals, ErrRepositoryNotExists)
c.Assert(r, IsNil)
}
func (s *RepositorySuite) TestPlainOpenDetectDotGit(c *C) {
fs := s.TemporalFilesystem(c)
dir, err := util.TempDir(fs, "", "")
c.Assert(err, IsNil)
subdir := filepath.Join(dir, "a", "b")
err = fs.MkdirAll(subdir, 0755)
c.Assert(err, IsNil)
file := fs.Join(subdir, "file.txt")
f, err := fs.Create(file)
c.Assert(err, IsNil)
f.Close()
r, err := PlainInit(fs.Join(fs.Root(), dir), false)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
opt := &PlainOpenOptions{DetectDotGit: true}
r, err = PlainOpenWithOptions(fs.Join(fs.Root(), subdir), opt)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
r, err = PlainOpenWithOptions(fs.Join(fs.Root(), file), opt)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
optnodetect := &PlainOpenOptions{DetectDotGit: false}
r, err = PlainOpenWithOptions(fs.Join(fs.Root(), file), optnodetect)
c.Assert(err, NotNil)
c.Assert(r, IsNil)
}
func (s *RepositorySuite) TestPlainOpenNotExistsDetectDotGit(c *C) {
dir := c.MkDir()
opt := &PlainOpenOptions{DetectDotGit: true}
r, err := PlainOpenWithOptions(dir, opt)
c.Assert(err, Equals, ErrRepositoryNotExists)
c.Assert(r, IsNil)
}
func (s *RepositorySuite) TestPlainClone(c *C) {
dir := c.MkDir()
r, err := PlainClone(dir, false, &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
remotes, err := r.Remotes()
c.Assert(err, IsNil)
c.Assert(remotes, HasLen, 1)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Branches, HasLen, 1)
c.Assert(cfg.Branches["master"].Name, Equals, "master")
}
func (s *RepositorySuite) TestPlainCloneBareAndShared(c *C) {
dir := c.MkDir()
remote := s.GetBasicLocalRepositoryURL()
r, err := PlainClone(dir, true, &CloneOptions{
URL: remote,
Shared: true,
})
c.Assert(err, IsNil)
altpath := path.Join(dir, "objects", "info", "alternates")
_, err = os.Stat(altpath)
c.Assert(err, IsNil)
data, err := os.ReadFile(altpath)
c.Assert(err, IsNil)
line := path.Join(remote, GitDirName, "objects") + "\n"
c.Assert(string(data), Equals, line)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Branches, HasLen, 1)
c.Assert(cfg.Branches["master"].Name, Equals, "master")
}
func (s *RepositorySuite) TestPlainCloneShared(c *C) {
dir := c.MkDir()
remote := s.GetBasicLocalRepositoryURL()
r, err := PlainClone(dir, false, &CloneOptions{
URL: remote,
Shared: true,
})
c.Assert(err, IsNil)
altpath := path.Join(dir, GitDirName, "objects", "info", "alternates")
_, err = os.Stat(altpath)
c.Assert(err, IsNil)
data, err := os.ReadFile(altpath)
c.Assert(err, IsNil)
line := path.Join(remote, GitDirName, "objects") + "\n"
c.Assert(string(data), Equals, line)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Branches, HasLen, 1)
c.Assert(cfg.Branches["master"].Name, Equals, "master")
}
func (s *RepositorySuite) TestPlainCloneSharedHttpShouldReturnError(c *C) {
dir := c.MkDir()
remote := "http://somerepo"
_, err := PlainClone(dir, false, &CloneOptions{
URL: remote,
Shared: true,
})
c.Assert(err, Equals, ErrAlternatePathNotSupported)
}
func (s *RepositorySuite) TestPlainCloneSharedHttpsShouldReturnError(c *C) {
dir := c.MkDir()
remote := "https://somerepo"
_, err := PlainClone(dir, false, &CloneOptions{
URL: remote,
Shared: true,
})
c.Assert(err, Equals, ErrAlternatePathNotSupported)
}
func (s *RepositorySuite) TestPlainCloneSharedSSHShouldReturnError(c *C) {
dir := c.MkDir()
remote := "ssh://somerepo"
_, err := PlainClone(dir, false, &CloneOptions{
URL: remote,
Shared: true,
})
c.Assert(err, Equals, ErrAlternatePathNotSupported)
}
func (s *RepositorySuite) TestPlainCloneWithRemoteName(c *C) {
dir := c.MkDir()
r, err := PlainClone(dir, false, &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
RemoteName: "test",
})
c.Assert(err, IsNil)
remote, err := r.Remote("test")
c.Assert(err, IsNil)
c.Assert(remote, NotNil)
}
func (s *RepositorySuite) TestPlainCloneOverExistingGitDirectory(c *C) {
dir := c.MkDir()
r, err := PlainInit(dir, false)
c.Assert(r, NotNil)
c.Assert(err, IsNil)
r, err = PlainClone(dir, false, &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(r, IsNil)
c.Assert(err, Equals, ErrRepositoryAlreadyExists)
}
func (s *RepositorySuite) TestPlainCloneContextCancel(c *C) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
dir := c.MkDir()
r, err := PlainCloneContext(ctx, dir, false, &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(r, NotNil)
c.Assert(err, Equals, context.Canceled)
}
func (s *RepositorySuite) TestPlainCloneContextNonExistentWithExistentDir(c *C) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
fs := s.TemporalFilesystem(c)
dir, err := util.TempDir(fs, "", "")
c.Assert(err, IsNil)
r, err := PlainCloneContext(ctx, dir, false, &CloneOptions{
URL: "incorrectOnPurpose",
})
c.Assert(r, NotNil)
c.Assert(err, Equals, transport.ErrRepositoryNotFound)
_, err = fs.Stat(dir)
c.Assert(os.IsNotExist(err), Equals, false)
names, err := fs.ReadDir(dir)
c.Assert(err, IsNil)
c.Assert(names, HasLen, 0)
}
func (s *RepositorySuite) TestPlainCloneContextNonExistentWithNonExistentDir(c *C) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
fs := s.TemporalFilesystem(c)
tmpDir, err := util.TempDir(fs, "", "")
c.Assert(err, IsNil)
repoDir := filepath.Join(tmpDir, "repoDir")
r, err := PlainCloneContext(ctx, repoDir, false, &CloneOptions{
URL: "incorrectOnPurpose",
})
c.Assert(r, NotNil)
c.Assert(err, Equals, transport.ErrRepositoryNotFound)
_, err = fs.Stat(repoDir)
c.Assert(os.IsNotExist(err), Equals, true)
}
func (s *RepositorySuite) TestPlainCloneContextNonExistentWithNotDir(c *C) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
fs := s.TemporalFilesystem(c)
tmpDir, err := util.TempDir(fs, "", "")
c.Assert(err, IsNil)
repoDir := fs.Join(tmpDir, "repoDir")
f, err := fs.Create(repoDir)
c.Assert(err, IsNil)
c.Assert(f.Close(), IsNil)
r, err := PlainCloneContext(ctx, fs.Join(fs.Root(), repoDir), false, &CloneOptions{
URL: "incorrectOnPurpose",
})
c.Assert(r, IsNil)
c.Assert(err, ErrorMatches, ".*not a directory.*")
fi, err := fs.Stat(repoDir)
c.Assert(err, IsNil)
c.Assert(fi.IsDir(), Equals, false)
}
func (s *RepositorySuite) TestPlainCloneContextNonExistentWithNotEmptyDir(c *C) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
fs := s.TemporalFilesystem(c)
tmpDir, err := util.TempDir(fs, "", "")
c.Assert(err, IsNil)
repoDir := filepath.Join(tmpDir, "repoDir")
err = fs.MkdirAll(repoDir, 0777)
c.Assert(err, IsNil)
dummyFile := filepath.Join(repoDir, "dummyFile")
err = util.WriteFile(fs, dummyFile, []byte("dummyContent"), 0644)
c.Assert(err, IsNil)
r, err := PlainCloneContext(ctx, fs.Join(fs.Root(), repoDir), false, &CloneOptions{
URL: "incorrectOnPurpose",
})
c.Assert(r, NotNil)
c.Assert(err, Equals, transport.ErrRepositoryNotFound)
_, err = fs.Stat(dummyFile)
c.Assert(err, IsNil)
}
func (s *RepositorySuite) TestPlainCloneContextNonExistingOverExistingGitDirectory(c *C) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
dir := c.MkDir()
r, err := PlainInit(dir, false)
c.Assert(r, NotNil)
c.Assert(err, IsNil)
r, err = PlainCloneContext(ctx, dir, false, &CloneOptions{
URL: "incorrectOnPurpose",
})
c.Assert(r, IsNil)
c.Assert(err, Equals, ErrRepositoryAlreadyExists)
}
func (s *RepositorySuite) TestPlainCloneWithRecurseSubmodules(c *C) {
if testing.Short() {
c.Skip("skipping test in short mode.")
}
dir := c.MkDir()
path := fixtures.ByTag("submodule").One().Worktree().Root()
r, err := PlainClone(dir, false, &CloneOptions{
URL: path,
RecurseSubmodules: DefaultSubmoduleRecursionDepth,
})
c.Assert(err, IsNil)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Remotes, HasLen, 1)
c.Assert(cfg.Branches, HasLen, 1)
c.Assert(cfg.Submodules, HasLen, 2)
}
func (s *RepositorySuite) TestPlainCloneWithShallowSubmodules(c *C) {
if testing.Short() {
c.Skip("skipping test in short mode.")
}
dir := c.MkDir()
path := fixtures.ByTag("submodule").One().Worktree().Root()
mainRepo, err := PlainClone(dir, false, &CloneOptions{
URL: path,
RecurseSubmodules: 1,
ShallowSubmodules: true,
})
c.Assert(err, IsNil)
mainWorktree, err := mainRepo.Worktree()
c.Assert(err, IsNil)
submodule, err := mainWorktree.Submodule("basic")
c.Assert(err, IsNil)
subRepo, err := submodule.Repository()
c.Assert(err, IsNil)
lr, err := subRepo.Log(&LogOptions{})
c.Assert(err, IsNil)
commitCount := 0
for _, err := lr.Next(); err == nil; _, err = lr.Next() {
commitCount++
}
c.Assert(err, IsNil)
c.Assert(commitCount, Equals, 1)
}
func (s *RepositorySuite) TestPlainCloneNoCheckout(c *C) {
dir := c.MkDir()
path := fixtures.ByTag("submodule").One().Worktree().Root()
r, err := PlainClone(dir, false, &CloneOptions{
URL: path,
NoCheckout: true,
RecurseSubmodules: DefaultSubmoduleRecursionDepth,
})
c.Assert(err, IsNil)
h, err := r.Head()
c.Assert(err, IsNil)
c.Assert(h.Hash().String(), Equals, "b685400c1f9316f350965a5993d350bc746b0bf4")
fi, err := osfs.New(dir).ReadDir("")
c.Assert(err, IsNil)
c.Assert(fi, HasLen, 1) // .git
}
func (s *RepositorySuite) TestFetch(c *C) {
r, _ := Init(memory.NewStorage(), nil)
_, err := r.CreateRemote(&config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{s.GetBasicLocalRepositoryURL()},
})
c.Assert(err, IsNil)
c.Assert(r.Fetch(&FetchOptions{}), IsNil)
remotes, err := r.Remotes()
c.Assert(err, IsNil)
c.Assert(remotes, HasLen, 1)
_, err = r.Head()
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
branch, err := r.Reference("refs/remotes/origin/master", false)
c.Assert(err, IsNil)
c.Assert(branch, NotNil)
c.Assert(branch.Type(), Equals, plumbing.HashReference)
c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
}
func (s *RepositorySuite) TestFetchContext(c *C) {
r, _ := Init(memory.NewStorage(), nil)
_, err := r.CreateRemote(&config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{s.GetBasicLocalRepositoryURL()},
})
c.Assert(err, IsNil)
ctx, cancel := context.WithCancel(context.Background())
cancel()
c.Assert(r.FetchContext(ctx, &FetchOptions{}), NotNil)
}
func (s *RepositorySuite) TestCloneWithProgress(c *C) {
fs := memfs.New()
buf := bytes.NewBuffer(nil)
_, err := Clone(memory.NewStorage(), fs, &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
Progress: buf,
})
c.Assert(err, IsNil)
c.Assert(buf.Len(), Not(Equals), 0)
}
func (s *RepositorySuite) TestCloneDeep(c *C) {
fs := memfs.New()
r, _ := Init(memory.NewStorage(), fs)
head, err := r.Head()
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
c.Assert(head, IsNil)
err = r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
remotes, err := r.Remotes()
c.Assert(err, IsNil)
c.Assert(remotes, HasLen, 1)
head, err = r.Reference(plumbing.HEAD, false)
c.Assert(err, IsNil)
c.Assert(head, NotNil)
c.Assert(head.Type(), Equals, plumbing.SymbolicReference)
c.Assert(head.Target().String(), Equals, "refs/heads/master")
branch, err := r.Reference(head.Target(), false)
c.Assert(err, IsNil)
c.Assert(branch, NotNil)
c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
branch, err = r.Reference("refs/remotes/origin/master", false)
c.Assert(err, IsNil)
c.Assert(branch, NotNil)
c.Assert(branch.Type(), Equals, plumbing.HashReference)
c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
fi, err := fs.ReadDir("")
c.Assert(err, IsNil)
c.Assert(fi, HasLen, 8)
}
func (s *RepositorySuite) TestCloneConfig(c *C) {
r, _ := Init(memory.NewStorage(), nil)
head, err := r.Head()
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
c.Assert(head, IsNil)
err = r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Core.IsBare, Equals, true)
c.Assert(cfg.Remotes, HasLen, 1)
c.Assert(cfg.Remotes["origin"].Name, Equals, "origin")
c.Assert(cfg.Remotes["origin"].URLs, HasLen, 1)
c.Assert(cfg.Branches, HasLen, 1)
c.Assert(cfg.Branches["master"].Name, Equals, "master")
}
func (s *RepositorySuite) TestCloneSingleBranchAndNonHEAD(c *C) {
s.testCloneSingleBranchAndNonHEADReference(c, "refs/heads/branch")
}
func (s *RepositorySuite) TestCloneSingleBranchAndNonHEADAndNonFull(c *C) {
s.testCloneSingleBranchAndNonHEADReference(c, "branch")
}
func (s *RepositorySuite) testCloneSingleBranchAndNonHEADReference(c *C, ref string) {
r, _ := Init(memory.NewStorage(), nil)
head, err := r.Head()
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
c.Assert(head, IsNil)
err = r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
ReferenceName: plumbing.ReferenceName(ref),
SingleBranch: true,
})
c.Assert(err, IsNil)
remotes, err := r.Remotes()
c.Assert(err, IsNil)
c.Assert(remotes, HasLen, 1)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Branches, HasLen, 1)
c.Assert(cfg.Branches["branch"].Name, Equals, "branch")
c.Assert(cfg.Branches["branch"].Remote, Equals, "origin")
c.Assert(cfg.Branches["branch"].Merge, Equals, plumbing.ReferenceName("refs/heads/branch"))
head, err = r.Reference(plumbing.HEAD, false)
c.Assert(err, IsNil)
c.Assert(head, NotNil)
c.Assert(head.Type(), Equals, plumbing.SymbolicReference)
c.Assert(head.Target().String(), Equals, "refs/heads/branch")
branch, err := r.Reference(head.Target(), false)
c.Assert(err, IsNil)
c.Assert(branch, NotNil)
c.Assert(branch.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
branch, err = r.Reference("refs/remotes/origin/branch", false)
c.Assert(err, IsNil)
c.Assert(branch, NotNil)
c.Assert(branch.Type(), Equals, plumbing.HashReference)
c.Assert(branch.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
}
func (s *RepositorySuite) TestCloneSingleBranchHEADMain(c *C) {
r, _ := Init(memory.NewStorage(), nil)
head, err := r.Head()
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
c.Assert(head, IsNil)
err = r.clone(context.Background(), &CloneOptions{
URL: s.GetLocalRepositoryURL(fixtures.ByTag("no-master-head").One()),
SingleBranch: true,
})
c.Assert(err, IsNil)
remotes, err := r.Remotes()
c.Assert(err, IsNil)
c.Assert(remotes, HasLen, 1)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Branches, HasLen, 1)
c.Assert(cfg.Branches["main"].Name, Equals, "main")
c.Assert(cfg.Branches["main"].Remote, Equals, "origin")
c.Assert(cfg.Branches["main"].Merge, Equals, plumbing.ReferenceName("refs/heads/main"))
head, err = r.Reference(plumbing.HEAD, false)
c.Assert(err, IsNil)
c.Assert(head, NotNil)
c.Assert(head.Type(), Equals, plumbing.SymbolicReference)
c.Assert(head.Target().String(), Equals, "refs/heads/main")
branch, err := r.Reference(head.Target(), false)
c.Assert(err, IsNil)
c.Assert(branch, NotNil)
c.Assert(branch.Hash().String(), Equals, "786dafbd351e587da1ae97e5fb9fbdf868b4a28f")
branch, err = r.Reference("refs/remotes/origin/HEAD", false)
c.Assert(err, IsNil)
c.Assert(branch, NotNil)
c.Assert(branch.Type(), Equals, plumbing.HashReference)
c.Assert(branch.Hash().String(), Equals, "786dafbd351e587da1ae97e5fb9fbdf868b4a28f")
}
func (s *RepositorySuite) TestCloneSingleBranch(c *C) {
r, _ := Init(memory.NewStorage(), nil)
head, err := r.Head()
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
c.Assert(head, IsNil)
err = r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
SingleBranch: true,
})
c.Assert(err, IsNil)
remotes, err := r.Remotes()
c.Assert(err, IsNil)
c.Assert(remotes, HasLen, 1)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Branches, HasLen, 1)
c.Assert(cfg.Branches["master"].Name, Equals, "master")
c.Assert(cfg.Branches["master"].Remote, Equals, "origin")
c.Assert(cfg.Branches["master"].Merge, Equals, plumbing.ReferenceName("refs/heads/master"))
head, err = r.Reference(plumbing.HEAD, false)
c.Assert(err, IsNil)
c.Assert(head, NotNil)
c.Assert(head.Type(), Equals, plumbing.SymbolicReference)
c.Assert(head.Target().String(), Equals, "refs/heads/master")
branch, err := r.Reference(head.Target(), false)
c.Assert(err, IsNil)
c.Assert(branch, NotNil)
c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
}
func (s *RepositorySuite) TestCloneSingleTag(c *C) {
r, _ := Init(memory.NewStorage(), nil)
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
err := r.clone(context.Background(), &CloneOptions{
URL: url,
SingleBranch: true,
ReferenceName: plumbing.ReferenceName("refs/tags/commit-tag"),
})
c.Assert(err, IsNil)
branch, err := r.Reference("refs/tags/commit-tag", false)
c.Assert(err, IsNil)
c.Assert(branch, NotNil)
conf, err := r.Config()
c.Assert(err, IsNil)
originRemote := conf.Remotes["origin"]
c.Assert(originRemote, NotNil)
c.Assert(originRemote.Fetch, HasLen, 1)
c.Assert(originRemote.Fetch[0].String(), Equals, "+refs/tags/commit-tag:refs/tags/commit-tag")
}
func (s *RepositorySuite) TestCloneDetachedHEAD(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
ReferenceName: plumbing.ReferenceName("refs/tags/v1.0.0"),
})
c.Assert(err, IsNil)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Branches, HasLen, 0)
head, err := r.Reference(plumbing.HEAD, false)
c.Assert(err, IsNil)
c.Assert(head, NotNil)
c.Assert(head.Type(), Equals, plumbing.HashReference)
c.Assert(head.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
count := 0
objects, err := r.Objects()
c.Assert(err, IsNil)
objects.ForEach(func(object.Object) error { count++; return nil })
c.Assert(count, Equals, 28)
}
func (s *RepositorySuite) TestCloneDetachedHEADAndSingle(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
ReferenceName: plumbing.ReferenceName("refs/tags/v1.0.0"),
SingleBranch: true,
})
c.Assert(err, IsNil)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Branches, HasLen, 0)
head, err := r.Reference(plumbing.HEAD, false)
c.Assert(err, IsNil)
c.Assert(head, NotNil)
c.Assert(head.Type(), Equals, plumbing.HashReference)
c.Assert(head.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
count := 0
objects, err := r.Objects()
c.Assert(err, IsNil)
objects.ForEach(func(object.Object) error { count++; return nil })
c.Assert(count, Equals, 28)
}
func (s *RepositorySuite) TestCloneDetachedHEADAndShallow(c *C) {
r, _ := Init(memory.NewStorage(), memfs.New())
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
ReferenceName: plumbing.ReferenceName("refs/tags/v1.0.0"),
Depth: 1,
})
c.Assert(err, IsNil)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Branches, HasLen, 0)
head, err := r.Reference(plumbing.HEAD, false)
c.Assert(err, IsNil)
c.Assert(head, NotNil)
c.Assert(head.Type(), Equals, plumbing.HashReference)
c.Assert(head.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
count := 0
objects, err := r.Objects()
c.Assert(err, IsNil)
objects.ForEach(func(object.Object) error { count++; return nil })
c.Assert(count, Equals, 15)
}
func (s *RepositorySuite) TestCloneDetachedHEADAnnotatedTag(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetLocalRepositoryURL(fixtures.ByTag("tags").One()),
ReferenceName: plumbing.ReferenceName("refs/tags/annotated-tag"),
})
c.Assert(err, IsNil)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Branches, HasLen, 0)
head, err := r.Reference(plumbing.HEAD, false)
c.Assert(err, IsNil)
c.Assert(head, NotNil)
c.Assert(head.Type(), Equals, plumbing.HashReference)
c.Assert(head.Hash().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f")
count := 0
objects, err := r.Objects()
c.Assert(err, IsNil)
objects.ForEach(func(object.Object) error { count++; return nil })
c.Assert(count, Equals, 7)
}
func (s *RepositorySuite) TestPush(c *C) {
url := c.MkDir()
server, err := PlainInit(url, true)
c.Assert(err, IsNil)
_, err = s.Repository.CreateRemote(&config.RemoteConfig{
Name: "test",
URLs: []string{url},
})
c.Assert(err, IsNil)
err = s.Repository.Push(&PushOptions{
RemoteName: "test",
})
c.Assert(err, IsNil)
AssertReferences(c, server, map[string]string{
"refs/heads/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"refs/heads/branch": "e8d3ffab552895c19b9fcf7aa264d277cde33881",
})
AssertReferences(c, s.Repository, map[string]string{
"refs/remotes/test/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"refs/remotes/test/branch": "e8d3ffab552895c19b9fcf7aa264d277cde33881",
})
}
func (s *RepositorySuite) TestPushContext(c *C) {
url := c.MkDir()
_, err := PlainInit(url, true)
c.Assert(err, IsNil)
_, err = s.Repository.CreateRemote(&config.RemoteConfig{
Name: "foo",
URLs: []string{url},
})
c.Assert(err, IsNil)
ctx, cancel := context.WithCancel(context.Background())
cancel()
err = s.Repository.PushContext(ctx, &PushOptions{
RemoteName: "foo",
})
c.Assert(err, NotNil)
}
// installPreReceiveHook installs a pre-receive hook in the .git
// directory at path which prints message m before exiting
// successfully.
func installPreReceiveHook(c *C, fs billy.Filesystem, path, m string) {
hooks := fs.Join(path, "hooks")
err := fs.MkdirAll(hooks, 0777)
c.Assert(err, IsNil)
err = util.WriteFile(fs, fs.Join(hooks, "pre-receive"), preReceiveHook(m), 0777)
c.Assert(err, IsNil)
}
func (s *RepositorySuite) TestPushWithProgress(c *C) {
fs := s.TemporalFilesystem(c)
path, err := util.TempDir(fs, "", "")
c.Assert(err, IsNil)
url := fs.Join(fs.Root(), path)
server, err := PlainInit(url, true)
c.Assert(err, IsNil)
m := "Receiving..."
installPreReceiveHook(c, fs, path, m)
_, err = s.Repository.CreateRemote(&config.RemoteConfig{
Name: "bar",
URLs: []string{url},
})
c.Assert(err, IsNil)
var p bytes.Buffer
err = s.Repository.Push(&PushOptions{
RemoteName: "bar",
Progress: &p,
})
c.Assert(err, IsNil)
AssertReferences(c, server, map[string]string{
"refs/heads/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"refs/heads/branch": "e8d3ffab552895c19b9fcf7aa264d277cde33881",
})
c.Assert((&p).Bytes(), DeepEquals, []byte(m))
}
func (s *RepositorySuite) TestPushDepth(c *C) {
url := c.MkDir()
server, err := PlainClone(url, true, &CloneOptions{
URL: fixtures.Basic().One().DotGit().Root(),
})
c.Assert(err, IsNil)
r, err := Clone(memory.NewStorage(), memfs.New(), &CloneOptions{
URL: url,
Depth: 1,
})
c.Assert(err, IsNil)
err = util.WriteFile(r.wt, "foo", nil, 0755)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
_, err = w.Add("foo")
c.Assert(err, IsNil)
hash, err := w.Commit("foo", &CommitOptions{
Author: defaultSignature(),
Committer: defaultSignature(),
})
c.Assert(err, IsNil)
err = r.Push(&PushOptions{})
c.Assert(err, IsNil)
AssertReferences(c, server, map[string]string{
"refs/heads/master": hash.String(),
})
AssertReferences(c, r, map[string]string{
"refs/remotes/origin/master": hash.String(),
})
}
func (s *RepositorySuite) TestPushNonExistentRemote(c *C) {
srcFs := fixtures.Basic().One().DotGit()
sto := filesystem.NewStorage(srcFs, cache.NewObjectLRUDefault())
r, err := Open(sto, srcFs)
c.Assert(err, IsNil)
err = r.Push(&PushOptions{RemoteName: "myremote"})
c.Assert(err, ErrorMatches, ".*remote not found.*")
}
func (s *RepositorySuite) TestLog(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
cIter, err := r.Log(&LogOptions{
From: plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"),
})
c.Assert(err, IsNil)
commitOrder := []plumbing.Hash{
plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"),
plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
}
for _, o := range commitOrder {
commit, err := cIter.Next()
c.Assert(err, IsNil)
c.Assert(commit.Hash, Equals, o)
}
_, err = cIter.Next()
c.Assert(err, Equals, io.EOF)
}
func (s *RepositorySuite) TestLogAll(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
rIter, err := r.Storer.IterReferences()
c.Assert(err, IsNil)
refCount := 0
err = rIter.ForEach(func(ref *plumbing.Reference) error {
refCount++
return nil
})
c.Assert(err, IsNil)
c.Assert(refCount, Equals, 5)
cIter, err := r.Log(&LogOptions{
All: true,
})
c.Assert(err, IsNil)
commitOrder := []plumbing.Hash{
plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"),
plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"),
plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"),
plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"),
plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"),
plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"),
plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"),
}
for _, o := range commitOrder {
commit, err := cIter.Next()
c.Assert(err, IsNil)
c.Assert(commit.Hash, Equals, o)
}
_, err = cIter.Next()
c.Assert(err, Equals, io.EOF)
cIter.Close()
}
func (s *RepositorySuite) TestLogAllMissingReferences(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
err = r.Storer.RemoveReference(plumbing.HEAD)
c.Assert(err, IsNil)
rIter, err := r.Storer.IterReferences()
c.Assert(err, IsNil)
refCount := 0
err = rIter.ForEach(func(ref *plumbing.Reference) error {
refCount++
return nil
})
c.Assert(err, IsNil)
c.Assert(refCount, Equals, 4)
err = r.Storer.SetReference(plumbing.NewHashReference(plumbing.ReferenceName("DUMMY"), plumbing.NewHash("DUMMY")))
c.Assert(err, IsNil)
rIter, err = r.Storer.IterReferences()
c.Assert(err, IsNil)
refCount = 0
err = rIter.ForEach(func(ref *plumbing.Reference) error {
refCount++
return nil
})
c.Assert(err, IsNil)
c.Assert(refCount, Equals, 5)
cIter, err := r.Log(&LogOptions{
All: true,
})
c.Assert(cIter, NotNil)
c.Assert(err, IsNil)
cCount := 0
cIter.ForEach(func(c *object.Commit) error {
cCount++
return nil
})
c.Assert(cCount, Equals, 9)
_, err = cIter.Next()
c.Assert(err, Equals, io.EOF)
cIter.Close()
}
func (s *RepositorySuite) TestLogAllOrderByTime(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
cIter, err := r.Log(&LogOptions{
Order: LogOrderCommitterTime,
All: true,
})
c.Assert(err, IsNil)
commitOrder := []plumbing.Hash{
plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"),
plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"),
plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"),
plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"),
plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"),
plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"),
plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"),
plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
}
for _, o := range commitOrder {
commit, err := cIter.Next()
c.Assert(err, IsNil)
c.Assert(commit.Hash, Equals, o)
}
_, err = cIter.Next()
c.Assert(err, Equals, io.EOF)
cIter.Close()
}
func (s *RepositorySuite) TestLogHead(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
cIter, err := r.Log(&LogOptions{})
c.Assert(err, IsNil)
commitOrder := []plumbing.Hash{
plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"),
plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"),
plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"),
plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"),
plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"),
plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"),
}
for _, o := range commitOrder {
commit, err := cIter.Next()
c.Assert(err, IsNil)
c.Assert(commit.Hash, Equals, o)
}
_, err = cIter.Next()
c.Assert(err, Equals, io.EOF)
}
func (s *RepositorySuite) TestLogError(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
_, err = r.Log(&LogOptions{
From: plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
})
c.Assert(err, NotNil)
}
func (s *RepositorySuite) TestLogFileNext(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
fileName := "vendor/foo.go"
cIter, err := r.Log(&LogOptions{FileName: &fileName})
c.Assert(err, IsNil)
commitOrder := []plumbing.Hash{
plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
}
for _, o := range commitOrder {
commit, err := cIter.Next()
c.Assert(err, IsNil)
c.Assert(commit.Hash, Equals, o)
}
_, err = cIter.Next()
c.Assert(err, Equals, io.EOF)
}
func (s *RepositorySuite) TestLogFileForEach(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
fileName := "php/crappy.php"
cIter, err := r.Log(&LogOptions{FileName: &fileName})
c.Assert(err, IsNil)
defer cIter.Close()
commitOrder := []plumbing.Hash{
plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"),
}
expectedIndex := 0
err = cIter.ForEach(func(commit *object.Commit) error {
expectedCommitHash := commitOrder[expectedIndex]
c.Assert(commit.Hash.String(), Equals, expectedCommitHash.String())
expectedIndex++
return nil
})
c.Assert(err, IsNil)
c.Assert(expectedIndex, Equals, 1)
}
func (s *RepositorySuite) TestLogNonHeadFile(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
fileName := "README"
cIter, err := r.Log(&LogOptions{FileName: &fileName})
c.Assert(err, IsNil)
defer cIter.Close()
_, err = cIter.Next()
c.Assert(err, Equals, io.EOF)
}
func (s *RepositorySuite) TestLogAllFileForEach(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
fileName := "README"
cIter, err := r.Log(&LogOptions{FileName: &fileName, All: true})
c.Assert(err, IsNil)
defer cIter.Close()
commitOrder := []plumbing.Hash{
plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"),
}
expectedIndex := 0
err = cIter.ForEach(func(commit *object.Commit) error {
expectedCommitHash := commitOrder[expectedIndex]
c.Assert(commit.Hash.String(), Equals, expectedCommitHash.String())
expectedIndex++
return nil
})
c.Assert(err, IsNil)
c.Assert(expectedIndex, Equals, 1)
}
func (s *RepositorySuite) TestLogInvalidFile(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
// Throwing in a file that does not exist
fileName := "vendor/foo12.go"
cIter, err := r.Log(&LogOptions{FileName: &fileName})
// Not raising an error since `git log -- vendor/foo12.go` responds silently
c.Assert(err, IsNil)
defer cIter.Close()
_, err = cIter.Next()
c.Assert(err, Equals, io.EOF)
}
func (s *RepositorySuite) TestLogFileInitialCommit(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
fileName := "LICENSE"
cIter, err := r.Log(&LogOptions{
Order: LogOrderCommitterTime,
FileName: &fileName,
})
c.Assert(err, IsNil)
defer cIter.Close()
commitOrder := []plumbing.Hash{
plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
}
expectedIndex := 0
err = cIter.ForEach(func(commit *object.Commit) error {
expectedCommitHash := commitOrder[expectedIndex]
c.Assert(commit.Hash.String(), Equals, expectedCommitHash.String())
expectedIndex++
return nil
})
c.Assert(err, IsNil)
c.Assert(expectedIndex, Equals, 1)
}
func (s *RepositorySuite) TestLogFileWithOtherParamsFail(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
fileName := "vendor/foo.go"
cIter, err := r.Log(&LogOptions{
Order: LogOrderCommitterTime,
FileName: &fileName,
From: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"),
})
c.Assert(err, IsNil)
defer cIter.Close()
_, iterErr := cIter.Next()
c.Assert(iterErr, Equals, io.EOF)
}
func (s *RepositorySuite) TestLogFileWithOtherParamsPass(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
fileName := "LICENSE"
cIter, err := r.Log(&LogOptions{
Order: LogOrderCommitterTime,
FileName: &fileName,
From: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"),
})
c.Assert(err, IsNil)
commitVal, iterErr := cIter.Next()
c.Assert(iterErr, Equals, nil)
c.Assert(commitVal.Hash.String(), Equals, "b029517f6300c2da0f4b651b8642506cd6aaf45d")
_, iterErr = cIter.Next()
c.Assert(iterErr, Equals, io.EOF)
}
type mockErrCommitIter struct{}
func (m *mockErrCommitIter) Next() (*object.Commit, error) {
return nil, errors.New("mock next error")
}
func (m *mockErrCommitIter) ForEach(func(*object.Commit) error) error {
return errors.New("mock foreach error")
}
func (m *mockErrCommitIter) Close() {}
func (s *RepositorySuite) TestLogFileWithError(c *C) {
fileName := "README"
cIter := object.NewCommitFileIterFromIter(fileName, &mockErrCommitIter{}, false)
defer cIter.Close()
err := cIter.ForEach(func(commit *object.Commit) error {
return nil
})
c.Assert(err, NotNil)
}
func (s *RepositorySuite) TestLogPathWithError(c *C) {
fileName := "README"
pathIter := func(path string) bool {
return path == fileName
}
cIter := object.NewCommitPathIterFromIter(pathIter, &mockErrCommitIter{}, false)
defer cIter.Close()
err := cIter.ForEach(func(commit *object.Commit) error {
return nil
})
c.Assert(err, NotNil)
}
func (s *RepositorySuite) TestLogPathRegexpWithError(c *C) {
pathRE := regexp.MustCompile("R.*E")
pathIter := func(path string) bool {
return pathRE.MatchString(path)
}
cIter := object.NewCommitPathIterFromIter(pathIter, &mockErrCommitIter{}, false)
defer cIter.Close()
err := cIter.ForEach(func(commit *object.Commit) error {
return nil
})
c.Assert(err, NotNil)
}
func (s *RepositorySuite) TestLogPathFilterRegexp(c *C) {
pathRE := regexp.MustCompile(`.*\.go`)
pathIter := func(path string) bool {
return pathRE.MatchString(path)
}
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
expectedCommitIDs := []string{
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"918c48b83bd081e863dbe1b80f8998f058cd8294",
}
commitIDs := []string{}
cIter, err := r.Log(&LogOptions{
PathFilter: pathIter,
From: plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
})
c.Assert(err, IsNil)
defer cIter.Close()
cIter.ForEach(func(commit *object.Commit) error {
commitIDs = append(commitIDs, commit.ID().String())
return nil
})
c.Assert(
strings.Join(commitIDs, ", "),
Equals,
strings.Join(expectedCommitIDs, ", "),
)
}
func (s *RepositorySuite) TestLogLimitNext(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
since := time.Date(2015, 4, 1, 0, 0, 0, 0, time.UTC)
cIter, err := r.Log(&LogOptions{Since: &since})
c.Assert(err, IsNil)
commitOrder := []plumbing.Hash{
plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
}
for _, o := range commitOrder {
commit, err := cIter.Next()
c.Assert(err, IsNil)
c.Assert(commit.Hash, Equals, o)
}
_, err = cIter.Next()
c.Assert(err, Equals, io.EOF)
}
func (s *RepositorySuite) TestLogLimitForEach(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
since := time.Date(2015, 3, 31, 11, 54, 0, 0, time.UTC)
until := time.Date(2015, 4, 1, 0, 0, 0, 0, time.UTC)
cIter, err := r.Log(&LogOptions{Since: &since, Until: &until})
c.Assert(err, IsNil)
defer cIter.Close()
commitOrder := []plumbing.Hash{
plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"),
}
expectedIndex := 0
err = cIter.ForEach(func(commit *object.Commit) error {
expectedCommitHash := commitOrder[expectedIndex]
c.Assert(commit.Hash.String(), Equals, expectedCommitHash.String())
expectedIndex++
return nil
})
c.Assert(err, IsNil)
c.Assert(expectedIndex, Equals, 1)
}
func (s *RepositorySuite) TestLogAllLimitForEach(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
since := time.Date(2015, 3, 31, 11, 54, 0, 0, time.UTC)
until := time.Date(2015, 4, 1, 0, 0, 0, 0, time.UTC)
cIter, err := r.Log(&LogOptions{Since: &since, Until: &until, All: true})
c.Assert(err, IsNil)
defer cIter.Close()
commitOrder := []plumbing.Hash{
plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"),
plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"),
}
expectedIndex := 0
err = cIter.ForEach(func(commit *object.Commit) error {
expectedCommitHash := commitOrder[expectedIndex]
c.Assert(commit.Hash.String(), Equals, expectedCommitHash.String())
expectedIndex++
return nil
})
c.Assert(err, IsNil)
c.Assert(expectedIndex, Equals, 2)
}
func (s *RepositorySuite) TestLogLimitWithOtherParamsFail(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
since := time.Date(2015, 3, 31, 11, 54, 0, 0, time.UTC)
cIter, err := r.Log(&LogOptions{
Order: LogOrderCommitterTime,
Since: &since,
From: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"),
})
c.Assert(err, IsNil)
defer cIter.Close()
_, iterErr := cIter.Next()
c.Assert(iterErr, Equals, io.EOF)
}
func (s *RepositorySuite) TestLogLimitWithOtherParamsPass(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
until := time.Date(2015, 3, 31, 11, 43, 0, 0, time.UTC)
cIter, err := r.Log(&LogOptions{
Order: LogOrderCommitterTime,
Until: &until,
From: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"),
})
c.Assert(err, IsNil)
defer cIter.Close()
commitVal, iterErr := cIter.Next()
c.Assert(iterErr, Equals, nil)
c.Assert(commitVal.Hash.String(), Equals, "b029517f6300c2da0f4b651b8642506cd6aaf45d")
_, iterErr = cIter.Next()
c.Assert(iterErr, Equals, io.EOF)
}
func (s *RepositorySuite) TestConfigScoped(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
cfg, err := r.ConfigScoped(config.LocalScope)
c.Assert(err, IsNil)
c.Assert(cfg.User.Email, Equals, "")
cfg, err = r.ConfigScoped(config.SystemScope)
c.Assert(err, IsNil)
c.Assert(cfg.User.Email, Not(Equals), "")
}
func (s *RepositorySuite) TestCommit(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
hash := plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47")
commit, err := r.CommitObject(hash)
c.Assert(err, IsNil)
c.Assert(commit.Hash.IsZero(), Equals, false)
c.Assert(commit.Hash, Equals, commit.ID())
c.Assert(commit.Hash, Equals, hash)
c.Assert(commit.Type(), Equals, plumbing.CommitObject)
tree, err := commit.Tree()
c.Assert(err, IsNil)
c.Assert(tree.Hash.IsZero(), Equals, false)
c.Assert(commit.Author.Email, Equals, "daniel@lordran.local")
}
func (s *RepositorySuite) TestCommits(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
c.Assert(err, IsNil)
count := 0
commits, err := r.CommitObjects()
c.Assert(err, IsNil)
for {
commit, err := commits.Next()
if err != nil {
break
}
count++
c.Assert(commit.Hash.IsZero(), Equals, false)
c.Assert(commit.Hash, Equals, commit.ID())
c.Assert(commit.Type(), Equals, plumbing.CommitObject)
}
c.Assert(count, Equals, 9)
}
func (s *RepositorySuite) TestBlob(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
blob, err := r.BlobObject(plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"))
c.Assert(err, NotNil)
c.Assert(blob, IsNil)
blobHash := plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492")
blob, err = r.BlobObject(blobHash)
c.Assert(err, IsNil)
c.Assert(blob.Hash.IsZero(), Equals, false)
c.Assert(blob.Hash, Equals, blob.ID())
c.Assert(blob.Hash, Equals, blobHash)
c.Assert(blob.Type(), Equals, plumbing.BlobObject)
}
func (s *RepositorySuite) TestBlobs(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
c.Assert(err, IsNil)
count := 0
blobs, err := r.BlobObjects()
c.Assert(err, IsNil)
for {
blob, err := blobs.Next()
if err != nil {
break
}
count++
c.Assert(blob.Hash.IsZero(), Equals, false)
c.Assert(blob.Hash, Equals, blob.ID())
c.Assert(blob.Type(), Equals, plumbing.BlobObject)
}
c.Assert(count, Equals, 10)
}
func (s *RepositorySuite) TestTagObject(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
hash := plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc")
tag, err := r.TagObject(hash)
c.Assert(err, IsNil)
c.Assert(tag.Hash.IsZero(), Equals, false)
c.Assert(tag.Hash, Equals, hash)
c.Assert(tag.Type(), Equals, plumbing.TagObject)
}
func (s *RepositorySuite) TestTags(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
count := 0
tags, err := r.Tags()
c.Assert(err, IsNil)
tags.ForEach(func(tag *plumbing.Reference) error {
count++
c.Assert(tag.Hash().IsZero(), Equals, false)
c.Assert(tag.Name().IsTag(), Equals, true)
return nil
})
c.Assert(count, Equals, 5)
}
func (s *RepositorySuite) TestCreateTagLightweight(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
expected, err := r.Head()
c.Assert(err, IsNil)
ref, err := r.CreateTag("foobar", expected.Hash(), nil)
c.Assert(err, IsNil)
c.Assert(ref, NotNil)
actual, err := r.Tag("foobar")
c.Assert(err, IsNil)
c.Assert(expected.Hash(), Equals, actual.Hash())
}
func (s *RepositorySuite) TestCreateTagLightweightExists(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
expected, err := r.Head()
c.Assert(err, IsNil)
ref, err := r.CreateTag("lightweight-tag", expected.Hash(), nil)
c.Assert(ref, IsNil)
c.Assert(err, Equals, ErrTagExists)
}
func (s *RepositorySuite) TestCreateTagAnnotated(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
h, err := r.Head()
c.Assert(err, IsNil)
expectedHash := h.Hash()
ref, err := r.CreateTag("foobar", expectedHash, &CreateTagOptions{
Tagger: defaultSignature(),
Message: "foo bar baz qux",
})
c.Assert(err, IsNil)
tag, err := r.Tag("foobar")
c.Assert(err, IsNil)
obj, err := r.TagObject(tag.Hash())
c.Assert(err, IsNil)
c.Assert(ref, DeepEquals, tag)
c.Assert(obj.Hash, Equals, ref.Hash())
c.Assert(obj.Type(), Equals, plumbing.TagObject)
c.Assert(obj.Target, Equals, expectedHash)
}
func (s *RepositorySuite) TestCreateTagAnnotatedBadOpts(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
h, err := r.Head()
c.Assert(err, IsNil)
expectedHash := h.Hash()
ref, err := r.CreateTag("foobar", expectedHash, &CreateTagOptions{})
c.Assert(ref, IsNil)
c.Assert(err, Equals, ErrMissingMessage)
}
func (s *RepositorySuite) TestCreateTagAnnotatedBadHash(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
ref, err := r.CreateTag("foobar", plumbing.ZeroHash, &CreateTagOptions{
Tagger: defaultSignature(),
Message: "foo bar baz qux",
})
c.Assert(ref, IsNil)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
}
func (s *RepositorySuite) TestCreateTagSigned(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
h, err := r.Head()
c.Assert(err, IsNil)
key := commitSignKey(c, true)
_, err = r.CreateTag("foobar", h.Hash(), &CreateTagOptions{
Tagger: defaultSignature(),
Message: "foo bar baz qux",
SignKey: key,
})
c.Assert(err, IsNil)
tag, err := r.Tag("foobar")
c.Assert(err, IsNil)
obj, err := r.TagObject(tag.Hash())
c.Assert(err, IsNil)
// Verify the tag.
pks := new(bytes.Buffer)
pkw, err := armor.Encode(pks, openpgp.PublicKeyType, nil)
c.Assert(err, IsNil)
err = key.Serialize(pkw)
c.Assert(err, IsNil)
err = pkw.Close()
c.Assert(err, IsNil)
actual, err := obj.Verify(pks.String())
c.Assert(err, IsNil)
c.Assert(actual.PrimaryKey, DeepEquals, key.PrimaryKey)
}
func (s *RepositorySuite) TestCreateTagSignedBadKey(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
h, err := r.Head()
c.Assert(err, IsNil)
key := commitSignKey(c, false)
_, err = r.CreateTag("foobar", h.Hash(), &CreateTagOptions{
Tagger: defaultSignature(),
Message: "foo bar baz qux",
SignKey: key,
})
c.Assert(err, Equals, openpgperr.InvalidArgumentError("signing key is encrypted"))
}
func (s *RepositorySuite) TestCreateTagCanonicalize(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
h, err := r.Head()
c.Assert(err, IsNil)
key := commitSignKey(c, true)
_, err = r.CreateTag("foobar", h.Hash(), &CreateTagOptions{
Tagger: defaultSignature(),
Message: "\n\nfoo bar baz qux\n\nsome message here",
SignKey: key,
})
c.Assert(err, IsNil)
tag, err := r.Tag("foobar")
c.Assert(err, IsNil)
obj, err := r.TagObject(tag.Hash())
c.Assert(err, IsNil)
// Assert the new canonicalized message.
c.Assert(obj.Message, Equals, "foo bar baz qux\n\nsome message here\n")
// Verify the tag.
pks := new(bytes.Buffer)
pkw, err := armor.Encode(pks, openpgp.PublicKeyType, nil)
c.Assert(err, IsNil)
err = key.Serialize(pkw)
c.Assert(err, IsNil)
err = pkw.Close()
c.Assert(err, IsNil)
actual, err := obj.Verify(pks.String())
c.Assert(err, IsNil)
c.Assert(actual.PrimaryKey, DeepEquals, key.PrimaryKey)
}
func (s *RepositorySuite) TestTagLightweight(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
expected := plumbing.NewHash("f7b877701fbf855b44c0a9e86f3fdce2c298b07f")
tag, err := r.Tag("lightweight-tag")
c.Assert(err, IsNil)
actual := tag.Hash()
c.Assert(expected, Equals, actual)
}
func (s *RepositorySuite) TestTagLightweightMissingTag(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
tag, err := r.Tag("lightweight-tag-tag")
c.Assert(tag, IsNil)
c.Assert(err, Equals, ErrTagNotFound)
}
func (s *RepositorySuite) TestDeleteTag(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
err = r.DeleteTag("lightweight-tag")
c.Assert(err, IsNil)
_, err = r.Tag("lightweight-tag")
c.Assert(err, Equals, ErrTagNotFound)
}
func (s *RepositorySuite) TestDeleteTagMissingTag(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
err = r.DeleteTag("lightweight-tag-tag")
c.Assert(err, Equals, ErrTagNotFound)
}
func (s *RepositorySuite) TestDeleteTagAnnotated(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
fs := s.TemporalFilesystem(c)
fss := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
r, _ := Init(fss, nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
ref, err := r.Tag("annotated-tag")
c.Assert(ref, NotNil)
c.Assert(err, IsNil)
obj, err := r.TagObject(ref.Hash())
c.Assert(obj, NotNil)
c.Assert(err, IsNil)
err = r.DeleteTag("annotated-tag")
c.Assert(err, IsNil)
_, err = r.Tag("annotated-tag")
c.Assert(err, Equals, ErrTagNotFound)
// Run a prune (and repack, to ensure that we are GCing everything regardless
// of the fixture in use) and try to get the tag object again.
//
// The repo needs to be re-opened after the repack.
err = r.Prune(PruneOptions{Handler: r.DeleteObject})
c.Assert(err, IsNil)
err = r.RepackObjects(&RepackConfig{})
c.Assert(err, IsNil)
r, err = PlainOpen(fs.Root())
c.Assert(r, NotNil)
c.Assert(err, IsNil)
// Now check to see if the GC was effective in removing the tag object.
obj, err = r.TagObject(ref.Hash())
c.Assert(obj, IsNil)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
}
func (s *RepositorySuite) TestDeleteTagAnnotatedUnpacked(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
fs := s.TemporalFilesystem(c)
fss := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
r, _ := Init(fss, nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
// Create a tag for the deletion test. This ensures that the ultimate loose
// object will be unpacked (as we aren't doing anything that should pack it),
// so that we can effectively test that a prune deletes it, without having to
// resort to a repack.
h, err := r.Head()
c.Assert(err, IsNil)
expectedHash := h.Hash()
ref, err := r.CreateTag("foobar", expectedHash, &CreateTagOptions{
Tagger: defaultSignature(),
Message: "foo bar baz qux",
})
c.Assert(err, IsNil)
tag, err := r.Tag("foobar")
c.Assert(err, IsNil)
obj, err := r.TagObject(tag.Hash())
c.Assert(obj, NotNil)
c.Assert(err, IsNil)
err = r.DeleteTag("foobar")
c.Assert(err, IsNil)
_, err = r.Tag("foobar")
c.Assert(err, Equals, ErrTagNotFound)
// As mentioned, only run a prune. We are not testing for packed objects
// here.
err = r.Prune(PruneOptions{Handler: r.DeleteObject})
c.Assert(err, IsNil)
// Now check to see if the GC was effective in removing the tag object.
obj, err = r.TagObject(ref.Hash())
c.Assert(obj, IsNil)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
}
func (s *RepositorySuite) TestInvalidTagName(c *C) {
r, err := Init(memory.NewStorage(), nil)
c.Assert(err, IsNil)
for i, name := range []string{
"",
"foo bar",
"foo\tbar",
"foo\nbar",
} {
_, err = r.CreateTag(name, plumbing.ZeroHash, nil)
c.Assert(err, NotNil, Commentf("case %d %q", i, name))
}
}
func (s *RepositorySuite) TestBranches(c *C) {
f := fixtures.ByURL("https://github.com/git-fixtures/root-references.git").One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
r, err := Open(sto, f.DotGit())
c.Assert(err, IsNil)
count := 0
branches, err := r.Branches()
c.Assert(err, IsNil)
branches.ForEach(func(branch *plumbing.Reference) error {
count++
c.Assert(branch.Hash().IsZero(), Equals, false)
c.Assert(branch.Name().IsBranch(), Equals, true)
return nil
})
c.Assert(count, Equals, 8)
}
func (s *RepositorySuite) TestNotes(c *C) {
// TODO add fixture with Notes
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
count := 0
notes, err := r.Notes()
c.Assert(err, IsNil)
notes.ForEach(func(note *plumbing.Reference) error {
count++
c.Assert(note.Hash().IsZero(), Equals, false)
c.Assert(note.Name().IsNote(), Equals, true)
return nil
})
c.Assert(count, Equals, 0)
}
func (s *RepositorySuite) TestTree(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
})
c.Assert(err, IsNil)
invalidHash := plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
tree, err := r.TreeObject(invalidHash)
c.Assert(tree, IsNil)
c.Assert(err, NotNil)
hash := plumbing.NewHash("dbd3641b371024f44d0e469a9c8f5457b0660de1")
tree, err = r.TreeObject(hash)
c.Assert(err, IsNil)
c.Assert(tree.Hash.IsZero(), Equals, false)
c.Assert(tree.Hash, Equals, tree.ID())
c.Assert(tree.Hash, Equals, hash)
c.Assert(tree.Type(), Equals, plumbing.TreeObject)
c.Assert(len(tree.Entries), Not(Equals), 0)
}
func (s *RepositorySuite) TestTrees(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
c.Assert(err, IsNil)
count := 0
trees, err := r.TreeObjects()
c.Assert(err, IsNil)
for {
tree, err := trees.Next()
if err != nil {
break
}
count++
c.Assert(tree.Hash.IsZero(), Equals, false)
c.Assert(tree.Hash, Equals, tree.ID())
c.Assert(tree.Type(), Equals, plumbing.TreeObject)
c.Assert(len(tree.Entries), Not(Equals), 0)
}
c.Assert(count, Equals, 12)
}
func (s *RepositorySuite) TestTagObjects(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
count := 0
tags, err := r.TagObjects()
c.Assert(err, IsNil)
tags.ForEach(func(tag *object.Tag) error {
count++
c.Assert(tag.Hash.IsZero(), Equals, false)
c.Assert(tag.Type(), Equals, plumbing.TagObject)
return nil
})
refs, _ := r.References()
refs.ForEach(func(ref *plumbing.Reference) error {
return nil
})
c.Assert(count, Equals, 4)
}
func (s *RepositorySuite) TestCommitIterClosePanic(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
c.Assert(err, IsNil)
commits, err := r.CommitObjects()
c.Assert(err, IsNil)
commits.Close()
}
func (s *RepositorySuite) TestRef(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
c.Assert(err, IsNil)
ref, err := r.Reference(plumbing.HEAD, false)
c.Assert(err, IsNil)
c.Assert(ref.Name(), Equals, plumbing.HEAD)
ref, err = r.Reference(plumbing.HEAD, true)
c.Assert(err, IsNil)
c.Assert(ref.Name(), Equals, plumbing.ReferenceName("refs/heads/master"))
}
func (s *RepositorySuite) TestRefs(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
c.Assert(err, IsNil)
c.Assert(err, IsNil)
iter, err := r.References()
c.Assert(err, IsNil)
c.Assert(iter, NotNil)
}
func (s *RepositorySuite) TestObject(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
c.Assert(err, IsNil)
hash := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
o, err := r.Object(plumbing.CommitObject, hash)
c.Assert(err, IsNil)
c.Assert(o.ID().IsZero(), Equals, false)
c.Assert(o.Type(), Equals, plumbing.CommitObject)
}
func (s *RepositorySuite) TestObjects(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
c.Assert(err, IsNil)
count := 0
objects, err := r.Objects()
c.Assert(err, IsNil)
for {
o, err := objects.Next()
if err != nil {
break
}
count++
c.Assert(o.ID().IsZero(), Equals, false)
c.Assert(o.Type(), Not(Equals), plumbing.AnyObject)
}
c.Assert(count, Equals, 31)
}
func (s *RepositorySuite) TestObjectNotFound(c *C) {
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
c.Assert(err, IsNil)
hash := plumbing.NewHash("0a3fb06ff80156fb153bcdcc58b5e16c2d27625c")
tag, err := r.Object(plumbing.TagObject, hash)
c.Assert(err, DeepEquals, plumbing.ErrObjectNotFound)
c.Assert(tag, IsNil)
}
func (s *RepositorySuite) TestWorktree(c *C) {
def := memfs.New()
r, _ := Init(memory.NewStorage(), def)
w, err := r.Worktree()
c.Assert(err, IsNil)
c.Assert(w.Filesystem, Equals, def)
}
func (s *RepositorySuite) TestWorktreeBare(c *C) {
r, _ := Init(memory.NewStorage(), nil)
w, err := r.Worktree()
c.Assert(err, Equals, ErrIsBareRepository)
c.Assert(w, IsNil)
}
func (s *RepositorySuite) TestResolveRevision(c *C) {
f := fixtures.ByURL("https://github.com/git-fixtures/basic.git").One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
r, err := Open(sto, f.DotGit())
c.Assert(err, IsNil)
datas := map[string]string{
"HEAD": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"heads/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"heads/master~1": "918c48b83bd081e863dbe1b80f8998f058cd8294",
"refs/heads/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"refs/heads/master~2^^~": "b029517f6300c2da0f4b651b8642506cd6aaf45d",
"refs/tags/v1.0.0": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"refs/remotes/origin/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"refs/remotes/origin/HEAD": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"HEAD~2^^~": "b029517f6300c2da0f4b651b8642506cd6aaf45d",
"HEAD~3^2": "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
"HEAD~3^2^0": "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
"HEAD~2^{/binary file}": "35e85108805c84807bc66a02d91535e1e24b38b9",
"HEAD~^{/!-some}": "1669dce138d9b841a518c64b10914d88f5e488ea",
"master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"branch": "e8d3ffab552895c19b9fcf7aa264d277cde33881",
"v1.0.0": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"branch~1": "918c48b83bd081e863dbe1b80f8998f058cd8294",
"v1.0.0~1": "918c48b83bd081e863dbe1b80f8998f058cd8294",
"master~1": "918c48b83bd081e863dbe1b80f8998f058cd8294",
"918c48b83bd081e863dbe1b80f8998f058cd8294": "918c48b83bd081e863dbe1b80f8998f058cd8294",
"918c48b": "918c48b83bd081e863dbe1b80f8998f058cd8294", // odd number of hex digits
}
for rev, hash := range datas {
h, err := r.ResolveRevision(plumbing.Revision(rev))
c.Assert(err, IsNil, Commentf("while checking %s", rev))
c.Check(h.String(), Equals, hash, Commentf("while checking %s", rev))
}
}
func (s *RepositorySuite) TestResolveRevisionAnnotated(c *C) {
f := fixtures.ByURL("https://github.com/git-fixtures/tags.git").One()
sto := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
r, err := Open(sto, f.DotGit())
c.Assert(err, IsNil)
datas := map[string]string{
"refs/tags/annotated-tag": "f7b877701fbf855b44c0a9e86f3fdce2c298b07f",
"b742a2a9fa0afcfa9a6fad080980fbc26b007c69": "f7b877701fbf855b44c0a9e86f3fdce2c298b07f",
}
for rev, hash := range datas {
h, err := r.ResolveRevision(plumbing.Revision(rev))
c.Assert(err, IsNil, Commentf("while checking %s", rev))
c.Check(h.String(), Equals, hash, Commentf("while checking %s", rev))
}
}
func (s *RepositorySuite) TestResolveRevisionWithErrors(c *C) {
url := s.GetLocalRepositoryURL(
fixtures.ByURL("https://github.com/git-fixtures/basic.git").One(),
)
r, _ := Init(memory.NewStorage(), nil)
err := r.clone(context.Background(), &CloneOptions{URL: url})
c.Assert(err, IsNil)
headRef, err := r.Head()
c.Assert(err, IsNil)
ref := plumbing.NewHashReference("refs/heads/918c48b83bd081e863dbe1b80f8998f058cd8294", headRef.Hash())
err = r.Storer.SetReference(ref)
c.Assert(err, IsNil)
datas := map[string]string{
"efs/heads/master~": "reference not found",
"HEAD^3": `Revision invalid : "3" found must be 0, 1 or 2 after "^"`,
"HEAD^{/whatever}": `no commit message match regexp: "whatever"`,
"4e1243bd22c66e76c2ba9eddc1f91394e57f9f83": "reference not found",
}
for rev, rerr := range datas {
_, err := r.ResolveRevision(plumbing.Revision(rev))
c.Assert(err, NotNil)
c.Assert(err.Error(), Equals, rerr)
}
}
func (s *RepositorySuite) testRepackObjects(
c *C, deleteTime time.Time, expectedPacks int) {
srcFs := fixtures.ByTag("unpacked").One().DotGit()
var sto storage.Storer
var err error
sto = filesystem.NewStorage(srcFs, cache.NewObjectLRUDefault())
los := sto.(storer.LooseObjectStorer)
c.Assert(los, NotNil)
numLooseStart := 0
err = los.ForEachObjectHash(func(_ plumbing.Hash) error {
numLooseStart++
return nil
})
c.Assert(err, IsNil)
c.Assert(numLooseStart > 0, Equals, true)
pos := sto.(storer.PackedObjectStorer)
c.Assert(los, NotNil)
packs, err := pos.ObjectPacks()
c.Assert(err, IsNil)
numPacksStart := len(packs)
c.Assert(numPacksStart > 1, Equals, true)
r, err := Open(sto, srcFs)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
err = r.RepackObjects(&RepackConfig{
OnlyDeletePacksOlderThan: deleteTime,
})
c.Assert(err, IsNil)
numLooseEnd := 0
err = los.ForEachObjectHash(func(_ plumbing.Hash) error {
numLooseEnd++
return nil
})
c.Assert(err, IsNil)
c.Assert(numLooseEnd, Equals, 0)
packs, err = pos.ObjectPacks()
c.Assert(err, IsNil)
numPacksEnd := len(packs)
c.Assert(numPacksEnd, Equals, expectedPacks)
}
func (s *RepositorySuite) TestRepackObjects(c *C) {
if testing.Short() {
c.Skip("skipping test in short mode.")
}
s.testRepackObjects(c, time.Time{}, 1)
}
func (s *RepositorySuite) TestRepackObjectsWithNoDelete(c *C) {
if testing.Short() {
c.Skip("skipping test in short mode.")
}
s.testRepackObjects(c, time.Unix(0, 1), 3)
}
func ExecuteOnPath(c *C, path string, cmds ...string) error {
for _, cmd := range cmds {
err := executeOnPath(path, cmd)
c.Assert(err, IsNil)
}
return nil
}
func executeOnPath(path, cmd string) error {
args := strings.Split(cmd, " ")
c := exec.Command(args[0], args[1:]...)
c.Dir = path
c.Env = os.Environ()
buf := bytes.NewBuffer(nil)
c.Stderr = buf
c.Stdout = buf
return c.Run()
}
func (s *RepositorySuite) TestBrokenMultipleShallowFetch(c *C) {
r, _ := Init(memory.NewStorage(), nil)
_, err := r.CreateRemote(&config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{s.GetBasicLocalRepositoryURL()},
})
c.Assert(err, IsNil)
c.Assert(r.Fetch(&FetchOptions{
Depth: 2,
RefSpecs: []config.RefSpec{config.RefSpec("refs/heads/master:refs/heads/master")},
}), IsNil)
shallows, err := r.Storer.Shallow()
c.Assert(err, IsNil)
c.Assert(len(shallows), Equals, 1)
ref, err := r.Reference("refs/heads/master", true)
c.Assert(err, IsNil)
cobj, err := r.CommitObject(ref.Hash())
c.Assert(err, IsNil)
c.Assert(cobj, NotNil)
err = object.NewCommitPreorderIter(cobj, nil, nil).ForEach(func(c *object.Commit) error {
for _, ph := range c.ParentHashes {
for _, h := range shallows {
if ph == h {
return storer.ErrStop
}
}
}
return nil
})
c.Assert(err, IsNil)
c.Assert(r.Fetch(&FetchOptions{
Depth: 5,
RefSpecs: []config.RefSpec{config.RefSpec("refs/heads/*:refs/heads/*")},
}), IsNil)
shallows, err = r.Storer.Shallow()
c.Assert(err, IsNil)
c.Assert(len(shallows), Equals, 3)
ref, err = r.Reference("refs/heads/master", true)
c.Assert(err, IsNil)
cobj, err = r.CommitObject(ref.Hash())
c.Assert(err, IsNil)
c.Assert(cobj, NotNil)
err = object.NewCommitPreorderIter(cobj, nil, nil).ForEach(func(c *object.Commit) error {
for _, ph := range c.ParentHashes {
for _, h := range shallows {
if ph == h {
return storer.ErrStop
}
}
}
return nil
})
c.Assert(err, IsNil)
}
func (s *RepositorySuite) TestDotGitToOSFilesystemsInvalidPath(c *C) {
_, _, err := dotGitToOSFilesystems("\000", false)
c.Assert(err, NotNil)
}
func (s *RepositorySuite) TestIssue674(c *C) {
r, _ := Init(memory.NewStorage(), nil)
h, err := r.ResolveRevision(plumbing.Revision(""))
c.Assert(err, NotNil)
c.Assert(h, NotNil)
c.Check(h.IsZero(), Equals, true)
}
func BenchmarkObjects(b *testing.B) {
defer fixtures.Clean()
for _, f := range fixtures.ByTag("packfile") {
if f.DotGitHash == "" {
continue
}
b.Run(f.URL, func(b *testing.B) {
fs := f.DotGit()
st := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
worktree, err := fs.Chroot(filepath.Dir(fs.Root()))
if err != nil {
b.Fatal(err)
}
repo, err := Open(st, worktree)
if err != nil {
b.Fatal(err)
}
for i := 0; i < b.N; i++ {
iter, err := repo.Objects()
if err != nil {
b.Fatal(err)
}
for {
_, err := iter.Next()
if err == io.EOF {
break
}
if err != nil {
b.Fatal(err)
}
}
iter.Close()
}
})
}
}
func BenchmarkPlainClone(b *testing.B) {
b.StopTimer()
clone := func(b *testing.B) {
_, err := PlainClone(b.TempDir(), true, &CloneOptions{
URL: "https://github.com/go-git/go-git.git",
Depth: 1,
Tags: NoTags,
SingleBranch: true,
})
if err != nil {
b.Error(err)
}
}
// Warm-up as the initial clone could have a higher cost which
// may skew results.
clone(b)
b.StartTimer()
for i := 0; i < b.N; i++ {
clone(b)
}
}
go-git-5.13.2/repository_unix_test.go 0000664 0000000 0000000 00000000410 14744245500 0017640 0 ustar 00root root 0000000 0000000 // +build !plan9,!windows
package git
import "fmt"
// preReceiveHook returns the bytes of a pre-receive hook script
// that prints m before exiting successfully
func preReceiveHook(m string) []byte {
return []byte(fmt.Sprintf("#!/bin/sh\nprintf '%s'\n", m))
}
go-git-5.13.2/repository_windows_test.go 0000664 0000000 0000000 00000002000 14744245500 0020344 0 ustar 00root root 0000000 0000000 package git
import (
"fmt"
"strings"
"github.com/go-git/go-billy/v5/util"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
// preReceiveHook returns the bytes of a pre-receive hook script
// that prints m before exiting successfully
func preReceiveHook(m string) []byte {
return []byte(fmt.Sprintf("#!C:/Program\\ Files/Git/usr/bin/sh.exe\nprintf '%s'\n", m))
}
func (s *RepositorySuite) TestCloneFileUrlWindows(c *C) {
dir := c.MkDir()
r, err := PlainInit(dir, false)
c.Assert(err, IsNil)
err = util.WriteFile(r.wt, "foo", nil, 0755)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
_, err = w.Add("foo")
c.Assert(err, IsNil)
_, err = w.Commit("foo", &CommitOptions{
Author: defaultSignature(),
Committer: defaultSignature(),
})
c.Assert(err, IsNil)
url := "file:///" + strings.ReplaceAll(dir, "\\", "/")
c.Assert(url, Matches, "file:///[A-Za-z]:/.*")
_, err = Clone(memory.NewStorage(), nil, &CloneOptions{
URL: url,
})
c.Assert(err, IsNil)
}
go-git-5.13.2/signer.go 0000664 0000000 0000000 00000001474 14744245500 0014621 0 ustar 00root root 0000000 0000000 package git
import (
"io"
"github.com/go-git/go-git/v5/plumbing"
)
// signableObject is an object which can be signed.
type signableObject interface {
EncodeWithoutSignature(o plumbing.EncodedObject) error
}
// Signer is an interface for signing git objects.
// message is a reader containing the encoded object to be signed.
// Implementors should return the encoded signature and an error if any.
// See https://git-scm.com/docs/gitformat-signature for more information.
type Signer interface {
Sign(message io.Reader) ([]byte, error)
}
func signObject(signer Signer, obj signableObject) ([]byte, error) {
encoded := &plumbing.MemoryObject{}
if err := obj.EncodeWithoutSignature(encoded); err != nil {
return nil, err
}
r, err := encoded.Reader()
if err != nil {
return nil, err
}
return signer.Sign(r)
}
go-git-5.13.2/signer_test.go 0000664 0000000 0000000 00000002506 14744245500 0015655 0 ustar 00root root 0000000 0000000 package git
import (
"encoding/base64"
"fmt"
"io"
"time"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/storage/memory"
)
type b64signer struct{}
// This is not secure, and is only used as an example for testing purposes.
// Please don't do this.
func (b64signer) Sign(message io.Reader) ([]byte, error) {
b, err := io.ReadAll(message)
if err != nil {
return nil, err
}
out := make([]byte, base64.StdEncoding.EncodedLen(len(b)))
base64.StdEncoding.Encode(out, b)
return out, nil
}
func ExampleSigner() {
repo, err := Init(memory.NewStorage(), memfs.New())
if err != nil {
panic(err)
}
w, err := repo.Worktree()
if err != nil {
panic(err)
}
commit, err := w.Commit("example commit", &CommitOptions{
Author: &object.Signature{
Name: "John Doe",
Email: "john@example.com",
When: time.UnixMicro(1234567890).UTC(),
},
Signer: b64signer{},
AllowEmptyCommits: true,
})
if err != nil {
panic(err)
}
obj, err := repo.CommitObject(commit)
if err != nil {
panic(err)
}
fmt.Println(obj.PGPSignature)
// Output: dHJlZSA0YjgyNWRjNjQyY2I2ZWI5YTA2MGU1NGJmOGQ2OTI4OGZiZWU0OTA0CmF1dGhvciBKb2huIERvZSA8am9obkBleGFtcGxlLmNvbT4gMTIzNCArMDAwMApjb21taXR0ZXIgSm9obiBEb2UgPGpvaG5AZXhhbXBsZS5jb20+IDEyMzQgKzAwMDAKCmV4YW1wbGUgY29tbWl0
}
go-git-5.13.2/status.go 0000664 0000000 0000000 00000010013 14744245500 0014642 0 ustar 00root root 0000000 0000000 package git
import (
"bytes"
"fmt"
"path/filepath"
mindex "github.com/go-git/go-git/v5/utils/merkletrie/index"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
// Status represents the current status of a Worktree.
// The key of the map is the path of the file.
type Status map[string]*FileStatus
// File returns the FileStatus for a given path, if the FileStatus doesn't
// exists a new FileStatus is added to the map using the path as key.
func (s Status) File(path string) *FileStatus {
if _, ok := (s)[path]; !ok {
s[path] = &FileStatus{Worktree: Untracked, Staging: Untracked}
}
return s[path]
}
// IsUntracked checks if file for given path is 'Untracked'
func (s Status) IsUntracked(path string) bool {
stat, ok := (s)[filepath.ToSlash(path)]
return ok && stat.Worktree == Untracked
}
// IsClean returns true if all the files are in Unmodified status.
func (s Status) IsClean() bool {
for _, status := range s {
if status.Worktree != Unmodified || status.Staging != Unmodified {
return false
}
}
return true
}
func (s Status) String() string {
buf := bytes.NewBuffer(nil)
for path, status := range s {
if status.Staging == Unmodified && status.Worktree == Unmodified {
continue
}
if status.Staging == Renamed {
path = fmt.Sprintf("%s -> %s", path, status.Extra)
}
fmt.Fprintf(buf, "%c%c %s\n", status.Staging, status.Worktree, path)
}
return buf.String()
}
// FileStatus contains the status of a file in the worktree
type FileStatus struct {
// Staging is the status of a file in the staging area
Staging StatusCode
// Worktree is the status of a file in the worktree
Worktree StatusCode
// Extra contains extra information, such as the previous name in a rename
Extra string
}
// StatusCode status code of a file in the Worktree
type StatusCode byte
const (
Unmodified StatusCode = ' '
Untracked StatusCode = '?'
Modified StatusCode = 'M'
Added StatusCode = 'A'
Deleted StatusCode = 'D'
Renamed StatusCode = 'R'
Copied StatusCode = 'C'
UpdatedButUnmerged StatusCode = 'U'
)
// StatusStrategy defines the different types of strategies when processing
// the worktree status.
type StatusStrategy int
const (
// TODO: (V6) Review the default status strategy.
// TODO: (V6) Review the type used to represent Status, to enable lazy
// processing of statuses going direct to the backing filesystem.
defaultStatusStrategy = Empty
// Empty starts its status map from empty. Missing entries for a given
// path means that the file is untracked. This causes a known issue (#119)
// whereby unmodified files can be incorrectly reported as untracked.
//
// This can be used when returning the changed state within a modified Worktree.
// For example, to check whether the current worktree is clean.
Empty StatusStrategy = 0
// Preload goes through all existing nodes from the index and add them to the
// status map as unmodified. This is currently the most reliable strategy
// although it comes at a performance cost in large repositories.
//
// This method is recommended when fetching the status of unmodified files.
// For example, to confirm the status of a specific file that is either
// untracked or unmodified.
Preload StatusStrategy = 1
)
func (s StatusStrategy) new(w *Worktree) (Status, error) {
switch s {
case Preload:
return preloadStatus(w)
case Empty:
return make(Status), nil
}
return nil, fmt.Errorf("%w: %+v", ErrUnsupportedStatusStrategy, s)
}
func preloadStatus(w *Worktree) (Status, error) {
idx, err := w.r.Storer.Index()
if err != nil {
return nil, err
}
idxRoot := mindex.NewRootNode(idx)
nodes := []noder.Noder{idxRoot}
status := make(Status)
for len(nodes) > 0 {
var node noder.Noder
node, nodes = nodes[0], nodes[1:]
if node.IsDir() {
children, err := node.Children()
if err != nil {
return nil, err
}
nodes = append(nodes, children...)
continue
}
fs := status.File(node.Name())
fs.Worktree = Unmodified
fs.Staging = Unmodified
}
return status, nil
}
go-git-5.13.2/storage/ 0000775 0000000 0000000 00000000000 14744245500 0014441 5 ustar 00root root 0000000 0000000 go-git-5.13.2/storage/filesystem/ 0000775 0000000 0000000 00000000000 14744245500 0016625 5 ustar 00root root 0000000 0000000 go-git-5.13.2/storage/filesystem/config.go 0000664 0000000 0000000 00000001454 14744245500 0020425 0 ustar 00root root 0000000 0000000 package filesystem
import (
"os"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/storage/filesystem/dotgit"
"github.com/go-git/go-git/v5/utils/ioutil"
)
type ConfigStorage struct {
dir *dotgit.DotGit
}
func (c *ConfigStorage) Config() (conf *config.Config, err error) {
f, err := c.dir.Config()
if err != nil {
if os.IsNotExist(err) {
return config.NewConfig(), nil
}
return nil, err
}
defer ioutil.CheckClose(f, &err)
return config.ReadConfig(f)
}
func (c *ConfigStorage) SetConfig(cfg *config.Config) (err error) {
if err = cfg.Validate(); err != nil {
return err
}
f, err := c.dir.ConfigWriter()
if err != nil {
return err
}
defer ioutil.CheckClose(f, &err)
b, err := cfg.Marshal()
if err != nil {
return err
}
_, err = f.Write(b)
return err
}
go-git-5.13.2/storage/filesystem/config_test.go 0000664 0000000 0000000 00000002220 14744245500 0021454 0 ustar 00root root 0000000 0000000 package filesystem
import (
"os"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-billy/v5/util"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/storage/filesystem/dotgit"
. "gopkg.in/check.v1"
)
type ConfigSuite struct {
fixtures.Suite
dir *dotgit.DotGit
path string
}
var _ = Suite(&ConfigSuite{})
func (s *ConfigSuite) SetUpTest(c *C) {
tmp, err := util.TempDir(osfs.Default, "", "go-git-filestystem-config")
c.Assert(err, IsNil)
s.dir = dotgit.New(osfs.New(tmp))
s.path = tmp
}
func (s *ConfigSuite) TestRemotes(c *C) {
dir := dotgit.New(fixtures.Basic().ByTag(".git").One().DotGit())
storer := &ConfigStorage{dir}
cfg, err := storer.Config()
c.Assert(err, IsNil)
remotes := cfg.Remotes
c.Assert(remotes, HasLen, 1)
remote := remotes["origin"]
c.Assert(remote.Name, Equals, "origin")
c.Assert(remote.URLs, DeepEquals, []string{"https://github.com/git-fixtures/basic"})
c.Assert(remote.Fetch, DeepEquals, []config.RefSpec{config.RefSpec("+refs/heads/*:refs/remotes/origin/*")})
}
func (s *ConfigSuite) TearDownTest(c *C) {
defer os.RemoveAll(s.path)
}
go-git-5.13.2/storage/filesystem/deltaobject.go 0000664 0000000 0000000 00000001154 14744245500 0021435 0 ustar 00root root 0000000 0000000 package filesystem
import (
"github.com/go-git/go-git/v5/plumbing"
)
type deltaObject struct {
plumbing.EncodedObject
base plumbing.Hash
hash plumbing.Hash
size int64
}
func newDeltaObject(
obj plumbing.EncodedObject,
hash plumbing.Hash,
base plumbing.Hash,
size int64) plumbing.DeltaObject {
return &deltaObject{
EncodedObject: obj,
hash: hash,
base: base,
size: size,
}
}
func (o *deltaObject) BaseHash() plumbing.Hash {
return o.base
}
func (o *deltaObject) ActualSize() int64 {
return o.size
}
func (o *deltaObject) ActualHash() plumbing.Hash {
return o.hash
}
go-git-5.13.2/storage/filesystem/dotgit/ 0000775 0000000 0000000 00000000000 14744245500 0020117 5 ustar 00root root 0000000 0000000 go-git-5.13.2/storage/filesystem/dotgit/dotgit.go 0000664 0000000 0000000 00000074731 14744245500 0021754 0 ustar 00root root 0000000 0000000 // https://github.com/git/git/blob/master/Documentation/gitrepository-layout.txt
package dotgit
import (
"bufio"
"bytes"
"errors"
"fmt"
"io"
"os"
"path"
"path/filepath"
"reflect"
"runtime"
"sort"
"strings"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-git/v5/storage"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/helper/chroot"
)
const (
suffix = ".git"
packedRefsPath = "packed-refs"
configPath = "config"
indexPath = "index"
shallowPath = "shallow"
modulePath = "modules"
objectsPath = "objects"
packPath = "pack"
refsPath = "refs"
branchesPath = "branches"
hooksPath = "hooks"
infoPath = "info"
remotesPath = "remotes"
logsPath = "logs"
worktreesPath = "worktrees"
alternatesPath = "alternates"
tmpPackedRefsPrefix = "._packed-refs"
packPrefix = "pack-"
packExt = ".pack"
idxExt = ".idx"
)
var (
// ErrNotFound is returned by New when the path is not found.
ErrNotFound = errors.New("path not found")
// ErrIdxNotFound is returned by Idxfile when the idx file is not found
ErrIdxNotFound = errors.New("idx file not found")
// ErrPackfileNotFound is returned by Packfile when the packfile is not found
ErrPackfileNotFound = errors.New("packfile not found")
// ErrConfigNotFound is returned by Config when the config is not found
ErrConfigNotFound = errors.New("config file not found")
// ErrPackedRefsDuplicatedRef is returned when a duplicated reference is
// found in the packed-ref file. This is usually the case for corrupted git
// repositories.
ErrPackedRefsDuplicatedRef = errors.New("duplicated ref found in packed-ref file")
// ErrPackedRefsBadFormat is returned when the packed-ref file corrupt.
ErrPackedRefsBadFormat = errors.New("malformed packed-ref")
// ErrSymRefTargetNotFound is returned when a symbolic reference is
// targeting a non-existing object. This usually means the repository
// is corrupt.
ErrSymRefTargetNotFound = errors.New("symbolic reference target not found")
// ErrIsDir is returned when a reference file is attempting to be read,
// but the path specified is a directory.
ErrIsDir = errors.New("reference path is a directory")
// ErrEmptyRefFile is returned when a reference file is attempted to be read,
// but the file is empty
ErrEmptyRefFile = errors.New("ref file is empty")
)
// Options holds configuration for the storage.
type Options struct {
// ExclusiveAccess means that the filesystem is not modified externally
// while the repo is open.
ExclusiveAccess bool
// KeepDescriptors makes the file descriptors to be reused but they will
// need to be manually closed calling Close().
KeepDescriptors bool
// AlternatesFS provides the billy filesystem to be used for Git Alternates.
// If none is provided, it falls back to using the underlying instance used for
// DotGit.
AlternatesFS billy.Filesystem
}
// The DotGit type represents a local git repository on disk. This
// type is not zero-value-safe, use the New function to initialize it.
type DotGit struct {
options Options
fs billy.Filesystem
// incoming object directory information
incomingChecked bool
incomingDirName string
objectList []plumbing.Hash // sorted
objectMap map[plumbing.Hash]struct{}
packList []plumbing.Hash
packMap map[plumbing.Hash]struct{}
files map[plumbing.Hash]billy.File
}
// New returns a DotGit value ready to be used. The path argument must
// be the absolute path of a git repository directory (e.g.
// "/foo/bar/.git").
func New(fs billy.Filesystem) *DotGit {
return NewWithOptions(fs, Options{})
}
// NewWithOptions sets non default configuration options.
// See New for complete help.
func NewWithOptions(fs billy.Filesystem, o Options) *DotGit {
return &DotGit{
options: o,
fs: fs,
}
}
// Initialize creates all the folder scaffolding.
func (d *DotGit) Initialize() error {
mustExists := []string{
d.fs.Join("objects", "info"),
d.fs.Join("objects", "pack"),
d.fs.Join("refs", "heads"),
d.fs.Join("refs", "tags"),
}
for _, path := range mustExists {
_, err := d.fs.Stat(path)
if err == nil {
continue
}
if !os.IsNotExist(err) {
return err
}
if err := d.fs.MkdirAll(path, os.ModeDir|os.ModePerm); err != nil {
return err
}
}
return nil
}
// Close closes all opened files.
func (d *DotGit) Close() error {
var firstError error
if d.files != nil {
for _, f := range d.files {
err := f.Close()
if err != nil && firstError == nil {
firstError = err
continue
}
}
d.files = nil
}
if firstError != nil {
return firstError
}
return nil
}
// ConfigWriter returns a file pointer for write to the config file
func (d *DotGit) ConfigWriter() (billy.File, error) {
return d.fs.Create(configPath)
}
// Config returns a file pointer for read to the config file
func (d *DotGit) Config() (billy.File, error) {
return d.fs.Open(configPath)
}
// IndexWriter returns a file pointer for write to the index file
func (d *DotGit) IndexWriter() (billy.File, error) {
return d.fs.Create(indexPath)
}
// Index returns a file pointer for read to the index file
func (d *DotGit) Index() (billy.File, error) {
return d.fs.Open(indexPath)
}
// ShallowWriter returns a file pointer for write to the shallow file
func (d *DotGit) ShallowWriter() (billy.File, error) {
return d.fs.Create(shallowPath)
}
// Shallow returns a file pointer for read to the shallow file
func (d *DotGit) Shallow() (billy.File, error) {
f, err := d.fs.Open(shallowPath)
if err != nil {
if os.IsNotExist(err) {
return nil, nil
}
return nil, err
}
return f, nil
}
// NewObjectPack return a writer for a new packfile, it saves the packfile to
// disk and also generates and save the index for the given packfile.
func (d *DotGit) NewObjectPack() (*PackWriter, error) {
d.cleanPackList()
return newPackWrite(d.fs)
}
// ObjectPacks returns the list of availables packfiles
func (d *DotGit) ObjectPacks() ([]plumbing.Hash, error) {
if !d.options.ExclusiveAccess {
return d.objectPacks()
}
err := d.genPackList()
if err != nil {
return nil, err
}
return d.packList, nil
}
func (d *DotGit) objectPacks() ([]plumbing.Hash, error) {
packDir := d.fs.Join(objectsPath, packPath)
files, err := d.fs.ReadDir(packDir)
if err != nil {
if os.IsNotExist(err) {
return nil, nil
}
return nil, err
}
var packs []plumbing.Hash
for _, f := range files {
n := f.Name()
if !strings.HasSuffix(n, packExt) || !strings.HasPrefix(n, packPrefix) {
continue
}
h := plumbing.NewHash(n[5 : len(n)-5]) // pack-(hash).pack
if h.IsZero() {
// Ignore files with badly-formatted names.
continue
}
packs = append(packs, h)
}
return packs, nil
}
func (d *DotGit) objectPackPath(hash plumbing.Hash, extension string) string {
return d.fs.Join(objectsPath, packPath, fmt.Sprintf("pack-%s.%s", hash.String(), extension))
}
func (d *DotGit) objectPackOpen(hash plumbing.Hash, extension string) (billy.File, error) {
if d.options.KeepDescriptors && extension == "pack" {
if d.files == nil {
d.files = make(map[plumbing.Hash]billy.File)
}
f, ok := d.files[hash]
if ok {
return f, nil
}
}
err := d.hasPack(hash)
if err != nil {
return nil, err
}
path := d.objectPackPath(hash, extension)
pack, err := d.fs.Open(path)
if err != nil {
if os.IsNotExist(err) {
return nil, ErrPackfileNotFound
}
return nil, err
}
if d.options.KeepDescriptors && extension == "pack" {
d.files[hash] = pack
}
return pack, nil
}
// ObjectPack returns a fs.File of the given packfile
func (d *DotGit) ObjectPack(hash plumbing.Hash) (billy.File, error) {
err := d.hasPack(hash)
if err != nil {
return nil, err
}
return d.objectPackOpen(hash, `pack`)
}
// ObjectPackIdx returns a fs.File of the index file for a given packfile
func (d *DotGit) ObjectPackIdx(hash plumbing.Hash) (billy.File, error) {
err := d.hasPack(hash)
if err != nil {
return nil, err
}
return d.objectPackOpen(hash, `idx`)
}
func (d *DotGit) DeleteOldObjectPackAndIndex(hash plumbing.Hash, t time.Time) error {
d.cleanPackList()
path := d.objectPackPath(hash, `pack`)
if !t.IsZero() {
fi, err := d.fs.Stat(path)
if err != nil {
return err
}
// too new, skip deletion.
if !fi.ModTime().Before(t) {
return nil
}
}
err := d.fs.Remove(path)
if err != nil {
return err
}
return d.fs.Remove(d.objectPackPath(hash, `idx`))
}
// NewObject return a writer for a new object file.
func (d *DotGit) NewObject() (*ObjectWriter, error) {
d.cleanObjectList()
return newObjectWriter(d.fs)
}
// ObjectsWithPrefix returns the hashes of objects that have the given prefix.
func (d *DotGit) ObjectsWithPrefix(prefix []byte) ([]plumbing.Hash, error) {
// Handle edge cases.
if len(prefix) < 1 {
return d.Objects()
} else if len(prefix) > len(plumbing.ZeroHash) {
return nil, nil
}
if d.options.ExclusiveAccess {
err := d.genObjectList()
if err != nil {
return nil, err
}
// Rely on d.objectList being sorted.
// Figure out the half-open interval defined by the prefix.
first := sort.Search(len(d.objectList), func(i int) bool {
// Same as plumbing.HashSlice.Less.
return bytes.Compare(d.objectList[i][:], prefix) >= 0
})
lim := len(d.objectList)
if limPrefix, overflow := incBytes(prefix); !overflow {
lim = sort.Search(len(d.objectList), func(i int) bool {
// Same as plumbing.HashSlice.Less.
return bytes.Compare(d.objectList[i][:], limPrefix) >= 0
})
}
return d.objectList[first:lim], nil
}
// This is the slow path.
var objects []plumbing.Hash
var n int
err := d.ForEachObjectHash(func(hash plumbing.Hash) error {
n++
if bytes.HasPrefix(hash[:], prefix) {
objects = append(objects, hash)
}
return nil
})
if err != nil {
return nil, err
}
return objects, nil
}
// Objects returns a slice with the hashes of objects found under the
// .git/objects/ directory.
func (d *DotGit) Objects() ([]plumbing.Hash, error) {
if d.options.ExclusiveAccess {
err := d.genObjectList()
if err != nil {
return nil, err
}
return d.objectList, nil
}
var objects []plumbing.Hash
err := d.ForEachObjectHash(func(hash plumbing.Hash) error {
objects = append(objects, hash)
return nil
})
if err != nil {
return nil, err
}
return objects, nil
}
// ForEachObjectHash iterates over the hashes of objects found under the
// .git/objects/ directory and executes the provided function.
func (d *DotGit) ForEachObjectHash(fun func(plumbing.Hash) error) error {
if !d.options.ExclusiveAccess {
return d.forEachObjectHash(fun)
}
err := d.genObjectList()
if err != nil {
return err
}
for _, h := range d.objectList {
err := fun(h)
if err != nil {
return err
}
}
return nil
}
func (d *DotGit) forEachObjectHash(fun func(plumbing.Hash) error) error {
files, err := d.fs.ReadDir(objectsPath)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
for _, f := range files {
if f.IsDir() && len(f.Name()) == 2 && isHex(f.Name()) {
base := f.Name()
d, err := d.fs.ReadDir(d.fs.Join(objectsPath, base))
if err != nil {
return err
}
for _, o := range d {
h := plumbing.NewHash(base + o.Name())
if h.IsZero() {
// Ignore files with badly-formatted names.
continue
}
err = fun(h)
if err != nil {
return err
}
}
}
}
return nil
}
func (d *DotGit) cleanObjectList() {
d.objectMap = nil
d.objectList = nil
}
func (d *DotGit) genObjectList() error {
if d.objectMap != nil {
return nil
}
d.objectMap = make(map[plumbing.Hash]struct{})
populate := func(h plumbing.Hash) error {
d.objectList = append(d.objectList, h)
d.objectMap[h] = struct{}{}
return nil
}
if err := d.forEachObjectHash(populate); err != nil {
return err
}
plumbing.HashesSort(d.objectList)
return nil
}
func (d *DotGit) hasObject(h plumbing.Hash) error {
if !d.options.ExclusiveAccess {
return nil
}
err := d.genObjectList()
if err != nil {
return err
}
_, ok := d.objectMap[h]
if !ok {
return plumbing.ErrObjectNotFound
}
return nil
}
func (d *DotGit) cleanPackList() {
d.packMap = nil
d.packList = nil
}
func (d *DotGit) genPackList() error {
if d.packMap != nil {
return nil
}
op, err := d.objectPacks()
if err != nil {
return err
}
d.packMap = make(map[plumbing.Hash]struct{})
d.packList = nil
for _, h := range op {
d.packList = append(d.packList, h)
d.packMap[h] = struct{}{}
}
return nil
}
func (d *DotGit) hasPack(h plumbing.Hash) error {
if !d.options.ExclusiveAccess {
return nil
}
err := d.genPackList()
if err != nil {
return err
}
_, ok := d.packMap[h]
if !ok {
return ErrPackfileNotFound
}
return nil
}
func (d *DotGit) objectPath(h plumbing.Hash) string {
hex := h.String()
return d.fs.Join(objectsPath, hex[0:2], hex[2:hash.HexSize])
}
// incomingObjectPath is intended to add support for a git pre-receive hook
// to be written it adds support for go-git to find objects in an "incoming"
// directory, so that the library can be used to write a pre-receive hook
// that deals with the incoming objects.
//
// More on git hooks found here : https://git-scm.com/docs/githooks
// More on 'quarantine'/incoming directory here:
//
// https://git-scm.com/docs/git-receive-pack
func (d *DotGit) incomingObjectPath(h plumbing.Hash) string {
hString := h.String()
if d.incomingDirName == "" {
return d.fs.Join(objectsPath, hString[0:2], hString[2:hash.HexSize])
}
return d.fs.Join(objectsPath, d.incomingDirName, hString[0:2], hString[2:hash.HexSize])
}
// hasIncomingObjects searches for an incoming directory and keeps its name
// so it doesn't have to be found each time an object is accessed.
func (d *DotGit) hasIncomingObjects() bool {
if !d.incomingChecked {
directoryContents, err := d.fs.ReadDir(objectsPath)
if err == nil {
for _, file := range directoryContents {
if file.IsDir() && (strings.HasPrefix(file.Name(), "tmp_objdir-incoming-") ||
// Before Git 2.35 incoming commits directory had another prefix
strings.HasPrefix(file.Name(), "incoming-")) {
d.incomingDirName = file.Name()
}
}
}
d.incomingChecked = true
}
return d.incomingDirName != ""
}
// Object returns a fs.File pointing the object file, if exists
func (d *DotGit) Object(h plumbing.Hash) (billy.File, error) {
err := d.hasObject(h)
if err != nil {
return nil, err
}
obj1, err1 := d.fs.Open(d.objectPath(h))
if os.IsNotExist(err1) && d.hasIncomingObjects() {
obj2, err2 := d.fs.Open(d.incomingObjectPath(h))
if err2 != nil {
return obj1, err1
}
return obj2, err2
}
return obj1, err1
}
// ObjectStat returns a os.FileInfo pointing the object file, if exists
func (d *DotGit) ObjectStat(h plumbing.Hash) (os.FileInfo, error) {
err := d.hasObject(h)
if err != nil {
return nil, err
}
obj1, err1 := d.fs.Stat(d.objectPath(h))
if os.IsNotExist(err1) && d.hasIncomingObjects() {
obj2, err2 := d.fs.Stat(d.incomingObjectPath(h))
if err2 != nil {
return obj1, err1
}
return obj2, err2
}
return obj1, err1
}
// ObjectDelete removes the object file, if exists
func (d *DotGit) ObjectDelete(h plumbing.Hash) error {
d.cleanObjectList()
err1 := d.fs.Remove(d.objectPath(h))
if os.IsNotExist(err1) && d.hasIncomingObjects() {
err2 := d.fs.Remove(d.incomingObjectPath(h))
if err2 != nil {
return err1
}
return err2
}
return err1
}
func (d *DotGit) readReferenceFrom(rd io.Reader, name string) (ref *plumbing.Reference, err error) {
b, err := io.ReadAll(rd)
if err != nil {
return nil, err
}
if len(b) == 0 {
return nil, ErrEmptyRefFile
}
line := strings.TrimSpace(string(b))
return plumbing.NewReferenceFromStrings(name, line), nil
}
// checkReferenceAndTruncate reads the reference from the given file, or the `pack-refs` file if
// the file was empty. Then it checks that the old reference matches the stored reference and
// truncates the file.
func (d *DotGit) checkReferenceAndTruncate(f billy.File, old *plumbing.Reference) error {
if old == nil {
return nil
}
ref, err := d.readReferenceFrom(f, old.Name().String())
if errors.Is(err, ErrEmptyRefFile) {
// This may happen if the reference is being read from a newly created file.
// In that case, try getting the reference from the packed refs file.
ref, err = d.packedRef(old.Name())
}
if err != nil {
return err
}
if ref.Hash() != old.Hash() {
return storage.ErrReferenceHasChanged
}
_, err = f.Seek(0, io.SeekStart)
if err != nil {
return err
}
return f.Truncate(0)
}
func (d *DotGit) SetRef(r, old *plumbing.Reference) error {
var content string
switch r.Type() {
case plumbing.SymbolicReference:
content = fmt.Sprintf("ref: %s\n", r.Target())
case plumbing.HashReference:
content = fmt.Sprintln(r.Hash().String())
}
fileName := r.Name().String()
return d.setRef(fileName, content, old)
}
// Refs scans the git directory collecting references, which it returns.
// Symbolic references are resolved and included in the output.
func (d *DotGit) Refs() ([]*plumbing.Reference, error) {
var refs []*plumbing.Reference
seen := make(map[plumbing.ReferenceName]bool)
if err := d.addRefFromHEAD(&refs); err != nil {
return nil, err
}
if err := d.addRefsFromRefDir(&refs, seen); err != nil {
return nil, err
}
if err := d.addRefsFromPackedRefs(&refs, seen); err != nil {
return nil, err
}
return refs, nil
}
// Ref returns the reference for a given reference name.
func (d *DotGit) Ref(name plumbing.ReferenceName) (*plumbing.Reference, error) {
ref, err := d.readReferenceFile(".", name.String())
if err == nil {
return ref, nil
}
return d.packedRef(name)
}
func (d *DotGit) findPackedRefsInFile(f billy.File, recv refsRecv) error {
s := bufio.NewScanner(f)
for s.Scan() {
ref, err := d.processLine(s.Text())
if err != nil {
return err
}
if !recv(ref) {
// skip parse
return nil
}
}
if err := s.Err(); err != nil {
return err
}
return nil
}
// refsRecv: returning true means that the reference continues to be resolved, otherwise it is stopped, which will speed up the lookup of a single reference.
type refsRecv func(*plumbing.Reference) bool
func (d *DotGit) findPackedRefs(recv refsRecv) error {
f, err := d.fs.Open(packedRefsPath)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
defer ioutil.CheckClose(f, &err)
return d.findPackedRefsInFile(f, recv)
}
func (d *DotGit) packedRef(name plumbing.ReferenceName) (*plumbing.Reference, error) {
var ref *plumbing.Reference
if err := d.findPackedRefs(func(r *plumbing.Reference) bool {
if r != nil && r.Name() == name {
ref = r
// ref found
return false
}
return true
}); err != nil {
return nil, err
}
if ref != nil {
return ref, nil
}
return nil, plumbing.ErrReferenceNotFound
}
// RemoveRef removes a reference by name.
func (d *DotGit) RemoveRef(name plumbing.ReferenceName) error {
path := d.fs.Join(".", name.String())
_, err := d.fs.Stat(path)
if err == nil {
err = d.fs.Remove(path)
// Drop down to remove it from the packed refs file, too.
}
if err != nil && !os.IsNotExist(err) {
return err
}
return d.rewritePackedRefsWithoutRef(name)
}
func refsRecvFunc(refs *[]*plumbing.Reference, seen map[plumbing.ReferenceName]bool) refsRecv {
return func(r *plumbing.Reference) bool {
if r != nil && !seen[r.Name()] {
*refs = append(*refs, r)
seen[r.Name()] = true
}
return true
}
}
func (d *DotGit) addRefsFromPackedRefs(refs *[]*plumbing.Reference, seen map[plumbing.ReferenceName]bool) (err error) {
return d.findPackedRefs(refsRecvFunc(refs, seen))
}
func (d *DotGit) addRefsFromPackedRefsFile(refs *[]*plumbing.Reference, f billy.File, seen map[plumbing.ReferenceName]bool) (err error) {
return d.findPackedRefsInFile(f, refsRecvFunc(refs, seen))
}
func (d *DotGit) openAndLockPackedRefs(doCreate bool) (
pr billy.File, err error,
) {
var f billy.File
defer func() {
if err != nil && f != nil {
ioutil.CheckClose(f, &err)
}
}()
// File mode is retrieved from a constant defined in the target specific
// files (dotgit_rewrite_packed_refs_*). Some modes are not available
// in all filesystems.
openFlags := d.openAndLockPackedRefsMode()
if doCreate {
openFlags |= os.O_CREATE
}
// Keep trying to open and lock the file until we're sure the file
// didn't change between the open and the lock.
for {
f, err = d.fs.OpenFile(packedRefsPath, openFlags, 0600)
if err != nil {
if os.IsNotExist(err) && !doCreate {
return nil, nil
}
return nil, err
}
fi, err := d.fs.Stat(packedRefsPath)
if err != nil {
return nil, err
}
mtime := fi.ModTime()
err = f.Lock()
if err != nil {
return nil, err
}
fi, err = d.fs.Stat(packedRefsPath)
if err != nil {
return nil, err
}
if mtime.Equal(fi.ModTime()) {
break
}
// The file has changed since we opened it. Close and retry.
err = f.Close()
if err != nil {
return nil, err
}
}
return f, nil
}
func (d *DotGit) rewritePackedRefsWithoutRef(name plumbing.ReferenceName) (err error) {
pr, err := d.openAndLockPackedRefs(false)
if err != nil {
return err
}
if pr == nil {
return nil
}
defer ioutil.CheckClose(pr, &err)
// Creating the temp file in the same directory as the target file
// improves our chances for rename operation to be atomic.
tmp, err := d.fs.TempFile("", tmpPackedRefsPrefix)
if err != nil {
return err
}
tmpName := tmp.Name()
defer func() {
ioutil.CheckClose(tmp, &err)
_ = d.fs.Remove(tmpName) // don't check err, we might have renamed it
}()
s := bufio.NewScanner(pr)
found := false
for s.Scan() {
line := s.Text()
ref, err := d.processLine(line)
if err != nil {
return err
}
if ref != nil && ref.Name() == name {
found = true
continue
}
if _, err := fmt.Fprintln(tmp, line); err != nil {
return err
}
}
if err := s.Err(); err != nil {
return err
}
if !found {
return nil
}
return d.rewritePackedRefsWhileLocked(tmp, pr)
}
// process lines from a packed-refs file
func (d *DotGit) processLine(line string) (*plumbing.Reference, error) {
if len(line) == 0 {
return nil, nil
}
switch line[0] {
case '#': // comment - ignore
return nil, nil
case '^': // annotated tag commit of the previous line - ignore
return nil, nil
default:
ws := strings.Split(line, " ") // hash then ref
if len(ws) != 2 {
return nil, ErrPackedRefsBadFormat
}
return plumbing.NewReferenceFromStrings(ws[1], ws[0]), nil
}
}
func (d *DotGit) addRefsFromRefDir(refs *[]*plumbing.Reference, seen map[plumbing.ReferenceName]bool) error {
return d.walkReferencesTree(refs, []string{refsPath}, seen)
}
func (d *DotGit) walkReferencesTree(refs *[]*plumbing.Reference, relPath []string, seen map[plumbing.ReferenceName]bool) error {
files, err := d.fs.ReadDir(d.fs.Join(relPath...))
if err != nil {
if os.IsNotExist(err) {
// a race happened, and our directory is gone now
return nil
}
return err
}
for _, f := range files {
newRelPath := append(append([]string(nil), relPath...), f.Name())
if f.IsDir() {
if err = d.walkReferencesTree(refs, newRelPath, seen); err != nil {
return err
}
continue
}
ref, err := d.readReferenceFile(".", strings.Join(newRelPath, "/"))
if os.IsNotExist(err) {
// a race happened, and our file is gone now
continue
}
if err != nil {
return err
}
if ref != nil && !seen[ref.Name()] {
*refs = append(*refs, ref)
seen[ref.Name()] = true
}
}
return nil
}
func (d *DotGit) addRefFromHEAD(refs *[]*plumbing.Reference) error {
ref, err := d.readReferenceFile(".", "HEAD")
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
*refs = append(*refs, ref)
return nil
}
func (d *DotGit) readReferenceFile(path, name string) (ref *plumbing.Reference, err error) {
path = d.fs.Join(path, d.fs.Join(strings.Split(name, "/")...))
st, err := d.fs.Stat(path)
if err != nil {
return nil, err
}
if st.IsDir() {
return nil, ErrIsDir
}
f, err := d.fs.Open(path)
if err != nil {
return nil, err
}
defer ioutil.CheckClose(f, &err)
return d.readReferenceFrom(f, name)
}
func (d *DotGit) CountLooseRefs() (int, error) {
var refs []*plumbing.Reference
seen := make(map[plumbing.ReferenceName]bool)
if err := d.addRefsFromRefDir(&refs, seen); err != nil {
return 0, err
}
return len(refs), nil
}
// PackRefs packs all loose refs into the packed-refs file.
//
// This implementation only works under the assumption that the view
// of the file system won't be updated during this operation. This
// strategy would not work on a general file system though, without
// locking each loose reference and checking it again before deleting
// the file, because otherwise an updated reference could sneak in and
// then be deleted by the packed-refs process. Alternatively, every
// ref update could also lock packed-refs, so only one lock is
// required during ref-packing. But that would worsen performance in
// the common case.
//
// TODO: add an "all" boolean like the `git pack-refs --all` flag.
// When `all` is false, it would only pack refs that have already been
// packed, plus all tags.
func (d *DotGit) PackRefs() (err error) {
// Lock packed-refs, and create it if it doesn't exist yet.
f, err := d.openAndLockPackedRefs(true)
if err != nil {
return err
}
defer ioutil.CheckClose(f, &err)
// Gather all refs using addRefsFromRefDir and addRefsFromPackedRefs.
var refs []*plumbing.Reference
seen := make(map[plumbing.ReferenceName]bool)
if err = d.addRefsFromRefDir(&refs, seen); err != nil {
return err
}
if len(refs) == 0 {
// Nothing to do!
return nil
}
numLooseRefs := len(refs)
if err = d.addRefsFromPackedRefsFile(&refs, f, seen); err != nil {
return err
}
// Write them all to a new temp packed-refs file.
tmp, err := d.fs.TempFile("", tmpPackedRefsPrefix)
if err != nil {
return err
}
tmpName := tmp.Name()
defer func() {
ioutil.CheckClose(tmp, &err)
_ = d.fs.Remove(tmpName) // don't check err, we might have renamed it
}()
w := bufio.NewWriter(tmp)
for _, ref := range refs {
_, err = w.WriteString(ref.String() + "\n")
if err != nil {
return err
}
}
err = w.Flush()
if err != nil {
return err
}
// Rename the temp packed-refs file.
err = d.rewritePackedRefsWhileLocked(tmp, f)
if err != nil {
return err
}
// Delete all the loose refs, while still holding the packed-refs
// lock.
for _, ref := range refs[:numLooseRefs] {
path := d.fs.Join(".", ref.Name().String())
err = d.fs.Remove(path)
if err != nil && !os.IsNotExist(err) {
return err
}
}
return nil
}
// Module return a billy.Filesystem pointing to the module folder
func (d *DotGit) Module(name string) (billy.Filesystem, error) {
return d.fs.Chroot(d.fs.Join(modulePath, name))
}
func (d *DotGit) AddAlternate(remote string) error {
altpath := d.fs.Join(objectsPath, infoPath, alternatesPath)
f, err := d.fs.OpenFile(altpath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0640)
if err != nil {
return fmt.Errorf("cannot open file: %w", err)
}
defer f.Close()
// locking in windows throws an error, based on comments
// https://github.com/go-git/go-git/pull/860#issuecomment-1751823044
// do not lock on windows platform.
if runtime.GOOS != "windows" {
if err = f.Lock(); err != nil {
return fmt.Errorf("cannot lock file: %w", err)
}
defer f.Unlock()
}
line := path.Join(remote, objectsPath) + "\n"
_, err = io.WriteString(f, line)
if err != nil {
return fmt.Errorf("error writing 'alternates' file: %w", err)
}
return nil
}
// Alternates returns DotGit(s) based off paths in objects/info/alternates if
// available. This can be used to checks if it's a shared repository.
func (d *DotGit) Alternates() ([]*DotGit, error) {
altpath := d.fs.Join(objectsPath, infoPath, alternatesPath)
f, err := d.fs.Open(altpath)
if err != nil {
return nil, err
}
defer f.Close()
fs := d.options.AlternatesFS
if fs == nil {
fs = d.fs
}
var alternates []*DotGit
seen := make(map[string]struct{})
// Read alternate paths line-by-line and create DotGit objects.
scanner := bufio.NewScanner(f)
for scanner.Scan() {
path := scanner.Text()
// Avoid creating multiple dotgits for the same alternative path.
if _, ok := seen[path]; ok {
continue
}
seen[path] = struct{}{}
if filepath.IsAbs(path) {
// Handling absolute paths should be straight-forward. However, the default osfs (Chroot)
// tries to concatenate an abs path with the root path in some operations (e.g. Stat),
// which leads to unexpected errors. Therefore, make the path relative to the current FS instead.
if reflect.TypeOf(fs) == reflect.TypeOf(&chroot.ChrootHelper{}) {
path, err = filepath.Rel(fs.Root(), path)
if err != nil {
return nil, fmt.Errorf("cannot make path %q relative: %w", path, err)
}
}
} else {
// By Git conventions, relative paths should be based on the object database (.git/objects/info)
// location as per: https://www.kernel.org/pub/software/scm/git/docs/gitrepository-layout.html
// However, due to the nature of go-git and its filesystem handling via Billy, paths cannot
// cross its "chroot boundaries". Therefore, ignore any "../" and treat the path from the
// fs root. If this is not correct based on the dotgit fs, set a different one via AlternatesFS.
abs := filepath.Join(string(filepath.Separator), filepath.ToSlash(path))
path = filepath.FromSlash(abs)
}
// Aligns with upstream behavior: exit if target path is not a valid directory.
if fi, err := fs.Stat(path); err != nil || !fi.IsDir() {
return nil, fmt.Errorf("invalid object directory %q: %w", path, err)
}
afs, err := fs.Chroot(filepath.Dir(path))
if err != nil {
return nil, fmt.Errorf("cannot chroot %q: %w", path, err)
}
alternates = append(alternates, New(afs))
}
if err = scanner.Err(); err != nil {
return nil, err
}
return alternates, nil
}
// Fs returns the underlying filesystem of the DotGit folder.
func (d *DotGit) Fs() billy.Filesystem {
return d.fs
}
func isHex(s string) bool {
for _, b := range []byte(s) {
if isNum(b) {
continue
}
if isHexAlpha(b) {
continue
}
return false
}
return true
}
func isNum(b byte) bool {
return b >= '0' && b <= '9'
}
func isHexAlpha(b byte) bool {
return b >= 'a' && b <= 'f' || b >= 'A' && b <= 'F'
}
// incBytes increments a byte slice, which involves incrementing the
// right-most byte, and following carry leftward.
// It makes a copy so that the provided slice's underlying array is not modified.
// If the overall operation overflows (e.g. incBytes(0xff, 0xff)), the second return parameter indicates that.
func incBytes(in []byte) (out []byte, overflow bool) {
out = make([]byte, len(in))
copy(out, in)
for i := len(out) - 1; i >= 0; i-- {
out[i]++
if out[i] != 0 {
return // Didn't overflow.
}
}
overflow = true
return
}
go-git-5.13.2/storage/filesystem/dotgit/dotgit_rewrite_packed_refs.go 0000664 0000000 0000000 00000003245 14744245500 0026033 0 ustar 00root root 0000000 0000000 package dotgit
import (
"io"
"os"
"runtime"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-git/v5/utils/ioutil"
)
func (d *DotGit) openAndLockPackedRefsMode() int {
if billy.CapabilityCheck(d.fs, billy.ReadAndWriteCapability) {
return os.O_RDWR
}
return os.O_RDONLY
}
func (d *DotGit) rewritePackedRefsWhileLocked(
tmp billy.File, pr billy.File) error {
// Try plain rename. If we aren't using the bare Windows filesystem as the
// storage layer, we might be able to get away with a rename over a locked
// file.
err := d.fs.Rename(tmp.Name(), pr.Name())
if err == nil {
return nil
}
// If we are in a filesystem that does not support rename (e.g. sivafs)
// a full copy is done.
if err == billy.ErrNotSupported {
return d.copyNewFile(tmp, pr)
}
if runtime.GOOS != "windows" {
return err
}
// Otherwise, Windows doesn't let us rename over a locked file, so
// we have to do a straight copy. Unfortunately this could result
// in a partially-written file if the process fails before the
// copy completes.
return d.copyToExistingFile(tmp, pr)
}
func (d *DotGit) copyToExistingFile(tmp, pr billy.File) error {
_, err := pr.Seek(0, io.SeekStart)
if err != nil {
return err
}
err = pr.Truncate(0)
if err != nil {
return err
}
_, err = tmp.Seek(0, io.SeekStart)
if err != nil {
return err
}
_, err = io.Copy(pr, tmp)
return err
}
func (d *DotGit) copyNewFile(tmp billy.File, pr billy.File) (err error) {
prWrite, err := d.fs.Create(pr.Name())
if err != nil {
return err
}
defer ioutil.CheckClose(prWrite, &err)
_, err = tmp.Seek(0, io.SeekStart)
if err != nil {
return err
}
_, err = io.Copy(prWrite, tmp)
return err
}
go-git-5.13.2/storage/filesystem/dotgit/dotgit_setref.go 0000664 0000000 0000000 00000004364 14744245500 0023317 0 ustar 00root root 0000000 0000000 package dotgit
import (
"fmt"
"os"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-billy/v5"
)
func (d *DotGit) setRef(fileName, content string, old *plumbing.Reference) (err error) {
if billy.CapabilityCheck(d.fs, billy.ReadAndWriteCapability) {
return d.setRefRwfs(fileName, content, old)
}
return d.setRefNorwfs(fileName, content, old)
}
func (d *DotGit) setRefRwfs(fileName, content string, old *plumbing.Reference) (err error) {
// If we are not checking an old ref, just truncate the file.
mode := os.O_RDWR | os.O_CREATE
if old == nil {
mode |= os.O_TRUNC
}
f, err := d.fs.OpenFile(fileName, mode, 0666)
if err != nil {
return err
}
defer ioutil.CheckClose(f, &err)
// Lock is unlocked by the deferred Close above. This is because Unlock
// does not imply a fsync and thus there would be a race between
// Unlock+Close and other concurrent writers. Adding Sync to go-billy
// could work, but this is better (and avoids superfluous syncs).
err = f.Lock()
if err != nil {
return err
}
// this is a no-op to call even when old is nil.
err = d.checkReferenceAndTruncate(f, old)
if err != nil {
return err
}
_, err = f.Write([]byte(content))
return err
}
// There are some filesystems that don't support opening files in RDWD mode.
// In these filesystems the standard SetRef function can not be used as it
// reads the reference file to check that it's not modified before updating it.
//
// This version of the function writes the reference without extra checks
// making it compatible with these simple filesystems. This is usually not
// a problem as they should be accessed by only one process at a time.
func (d *DotGit) setRefNorwfs(fileName, content string, old *plumbing.Reference) error {
_, err := d.fs.Stat(fileName)
if err == nil && old != nil {
fRead, err := d.fs.Open(fileName)
if err != nil {
return err
}
ref, err := d.readReferenceFrom(fRead, old.Name().String())
fRead.Close()
if err != nil {
return err
}
if ref.Hash() != old.Hash() {
return fmt.Errorf("reference has changed concurrently")
}
}
f, err := d.fs.Create(fileName)
if err != nil {
return err
}
defer f.Close()
_, err = f.Write([]byte(content))
return err
}
go-git-5.13.2/storage/filesystem/dotgit/dotgit_test.go 0000664 0000000 0000000 00000067265 14744245500 0023017 0 ustar 00root root 0000000 0000000 package dotgit
import (
"bufio"
"encoding/hex"
"io"
"os"
"path/filepath"
"regexp"
"runtime"
"strings"
"testing"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-billy/v5/util"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/storage"
"github.com/stretchr/testify/assert"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type SuiteDotGit struct {
fixtures.Suite
}
var _ = Suite(&SuiteDotGit{})
func (s *SuiteDotGit) TemporalFilesystem(c *C) (fs billy.Filesystem) {
fs = osfs.New(c.MkDir())
path, err := util.TempDir(fs, "", "")
if err != nil {
panic(err)
}
fs, err = fs.Chroot(path)
if err != nil {
panic(err)
}
return fs
}
func (s *SuiteDotGit) TestInitialize(c *C) {
fs := s.TemporalFilesystem(c)
dir := New(fs)
err := dir.Initialize()
c.Assert(err, IsNil)
_, err = fs.Stat(fs.Join("objects", "info"))
c.Assert(err, IsNil)
_, err = fs.Stat(fs.Join("objects", "pack"))
c.Assert(err, IsNil)
_, err = fs.Stat(fs.Join("refs", "heads"))
c.Assert(err, IsNil)
_, err = fs.Stat(fs.Join("refs", "tags"))
c.Assert(err, IsNil)
}
func (s *SuiteDotGit) TestSetRefs(c *C) {
fs := s.TemporalFilesystem(c)
dir := New(fs)
testSetRefs(c, dir)
}
func (s *SuiteDotGit) TestSetRefsNorwfs(c *C) {
fs := s.TemporalFilesystem(c)
dir := New(&norwfs{fs})
testSetRefs(c, dir)
}
func (s *SuiteDotGit) TestRefsHeadFirst(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
refs, err := dir.Refs()
c.Assert(err, IsNil)
c.Assert(len(refs), Not(Equals), 0)
c.Assert(refs[0].Name().String(), Equals, "HEAD")
}
func testSetRefs(c *C, dir *DotGit) {
firstFoo := plumbing.NewReferenceFromStrings(
"refs/heads/foo",
"e8d3ffab552895c19b9fcf7aa264d277cde33881",
)
err := dir.SetRef(firstFoo, nil)
c.Assert(err, IsNil)
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/symbolic",
"ref: refs/heads/foo",
), nil)
c.Assert(err, IsNil)
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"bar",
"e8d3ffab552895c19b9fcf7aa264d277cde33881",
), nil)
c.Assert(err, IsNil)
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/feature/baz",
"e8d3ffab552895c19b9fcf7aa264d277cde33881",
), nil)
c.Assert(err, IsNil)
refs, err := dir.Refs()
c.Assert(err, IsNil)
c.Assert(refs, HasLen, 3)
ref := findReference(refs, "refs/heads/foo")
c.Assert(ref, NotNil)
c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
ref = findReference(refs, "refs/heads/symbolic")
c.Assert(ref, NotNil)
c.Assert(ref.Target().String(), Equals, "refs/heads/foo")
ref = findReference(refs, "bar")
c.Assert(ref, IsNil)
_, err = dir.readReferenceFile(".", "refs/heads/feature/baz")
c.Assert(err, IsNil)
_, err = dir.readReferenceFile(".", "refs/heads/feature")
c.Assert(err, Equals, ErrIsDir)
ref, err = dir.Ref("refs/heads/foo")
c.Assert(err, IsNil)
c.Assert(ref, NotNil)
c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
ref, err = dir.Ref("refs/heads/symbolic")
c.Assert(err, IsNil)
c.Assert(ref, NotNil)
c.Assert(ref.Target().String(), Equals, "refs/heads/foo")
ref, err = dir.Ref("bar")
c.Assert(err, IsNil)
c.Assert(ref, NotNil)
c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
// Check that SetRef with a non-nil `old` works.
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/foo",
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
), firstFoo)
c.Assert(err, IsNil)
// `firstFoo` is no longer the right `old` reference, so this
// should fail.
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/foo",
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
), firstFoo)
c.Assert(err, NotNil)
}
func (s *SuiteDotGit) TestRefsFromPackedRefs(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
refs, err := dir.Refs()
c.Assert(err, IsNil)
ref := findReference(refs, "refs/remotes/origin/branch")
c.Assert(ref, NotNil)
c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
}
func (s *SuiteDotGit) TestRefsFromReferenceFile(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
refs, err := dir.Refs()
c.Assert(err, IsNil)
ref := findReference(refs, "refs/remotes/origin/HEAD")
c.Assert(ref, NotNil)
c.Assert(ref.Type(), Equals, plumbing.SymbolicReference)
c.Assert(string(ref.Target()), Equals, "refs/remotes/origin/master")
}
func BenchmarkRefMultipleTimes(b *testing.B) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
refname := plumbing.ReferenceName("refs/remotes/origin/branch")
dir := New(fs)
_, err := dir.Ref(refname)
if err != nil {
b.Fatalf("unexpected error: %s", err)
}
for i := 0; i < b.N; i++ {
_, err := dir.Ref(refname)
if err != nil {
b.Fatalf("unexpected error: %s", err)
}
}
}
func (s *SuiteDotGit) TestRemoveRefFromReferenceFile(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
name := plumbing.ReferenceName("refs/remotes/origin/HEAD")
err := dir.RemoveRef(name)
c.Assert(err, IsNil)
refs, err := dir.Refs()
c.Assert(err, IsNil)
ref := findReference(refs, string(name))
c.Assert(ref, IsNil)
}
func (s *SuiteDotGit) TestRemoveRefFromPackedRefs(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
name := plumbing.ReferenceName("refs/remotes/origin/master")
err := dir.RemoveRef(name)
c.Assert(err, IsNil)
b, err := util.ReadFile(fs, packedRefsPath)
c.Assert(err, IsNil)
c.Assert(string(b), Equals, ""+
"# pack-refs with: peeled fully-peeled \n"+
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/heads/master\n"+
"e8d3ffab552895c19b9fcf7aa264d277cde33881 refs/remotes/origin/branch\n")
}
func (s *SuiteDotGit) TestRemoveRefFromReferenceFileAndPackedRefs(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
// Make a ref file for a ref that's already in `packed-refs`.
err := dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/remotes/origin/branch",
"e8d3ffab552895c19b9fcf7aa264d277cde33881",
), nil)
c.Assert(err, IsNil)
// Make sure it only appears once in the refs list.
refs, err := dir.Refs()
c.Assert(err, IsNil)
found := false
for _, ref := range refs {
if ref.Name() == "refs/remotes/origin/branch" {
c.Assert(found, Equals, false)
found = true
}
}
name := plumbing.ReferenceName("refs/remotes/origin/branch")
err = dir.RemoveRef(name)
c.Assert(err, IsNil)
b, err := util.ReadFile(fs, packedRefsPath)
c.Assert(err, IsNil)
c.Assert(string(b), Equals, ""+
"# pack-refs with: peeled fully-peeled \n"+
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/heads/master\n"+
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/remotes/origin/master\n")
refs, err = dir.Refs()
c.Assert(err, IsNil)
ref := findReference(refs, string(name))
c.Assert(ref, IsNil)
}
func (s *SuiteDotGit) TestRemoveRefNonExistent(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
before, err := util.ReadFile(fs, packedRefsPath)
c.Assert(err, IsNil)
name := plumbing.ReferenceName("refs/heads/nonexistent")
err = dir.RemoveRef(name)
c.Assert(err, IsNil)
after, err := util.ReadFile(fs, packedRefsPath)
c.Assert(err, IsNil)
c.Assert(string(before), Equals, string(after))
}
func (s *SuiteDotGit) TestRemoveRefInvalidPackedRefs(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
brokenContent := "BROKEN STUFF REALLY BROKEN"
err := util.WriteFile(fs, packedRefsPath, []byte(brokenContent), os.FileMode(0755))
c.Assert(err, IsNil)
name := plumbing.ReferenceName("refs/heads/nonexistent")
err = dir.RemoveRef(name)
c.Assert(err, NotNil)
after, err := util.ReadFile(fs, packedRefsPath)
c.Assert(err, IsNil)
c.Assert(brokenContent, Equals, string(after))
}
func (s *SuiteDotGit) TestRemoveRefInvalidPackedRefs2(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
brokenContent := strings.Repeat("a", bufio.MaxScanTokenSize*2)
err := util.WriteFile(fs, packedRefsPath, []byte(brokenContent), os.FileMode(0755))
c.Assert(err, IsNil)
name := plumbing.ReferenceName("refs/heads/nonexistent")
err = dir.RemoveRef(name)
c.Assert(err, NotNil)
after, err := util.ReadFile(fs, packedRefsPath)
c.Assert(err, IsNil)
c.Assert(brokenContent, Equals, string(after))
}
func (s *SuiteDotGit) TestRefsFromHEADFile(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
refs, err := dir.Refs()
c.Assert(err, IsNil)
ref := findReference(refs, "HEAD")
c.Assert(ref, NotNil)
c.Assert(ref.Type(), Equals, plumbing.SymbolicReference)
c.Assert(string(ref.Target()), Equals, "refs/heads/master")
}
func (s *SuiteDotGit) TestConfig(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
file, err := dir.Config()
c.Assert(err, IsNil)
c.Assert(filepath.Base(file.Name()), Equals, "config")
}
func (s *SuiteDotGit) TestConfigWriteAndConfig(c *C) {
fs := s.TemporalFilesystem(c)
dir := New(fs)
f, err := dir.ConfigWriter()
c.Assert(err, IsNil)
_, err = f.Write([]byte("foo"))
c.Assert(err, IsNil)
f, err = dir.Config()
c.Assert(err, IsNil)
cnt, err := io.ReadAll(f)
c.Assert(err, IsNil)
c.Assert(string(cnt), Equals, "foo")
}
func (s *SuiteDotGit) TestIndex(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
idx, err := dir.Index()
c.Assert(err, IsNil)
c.Assert(idx, NotNil)
}
func (s *SuiteDotGit) TestIndexWriteAndIndex(c *C) {
fs := s.TemporalFilesystem(c)
dir := New(fs)
f, err := dir.IndexWriter()
c.Assert(err, IsNil)
_, err = f.Write([]byte("foo"))
c.Assert(err, IsNil)
f, err = dir.Index()
c.Assert(err, IsNil)
cnt, err := io.ReadAll(f)
c.Assert(err, IsNil)
c.Assert(string(cnt), Equals, "foo")
}
func (s *SuiteDotGit) TestShallow(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
file, err := dir.Shallow()
c.Assert(err, IsNil)
c.Assert(file, IsNil)
}
func (s *SuiteDotGit) TestShallowWriteAndShallow(c *C) {
fs := s.TemporalFilesystem(c)
dir := New(fs)
f, err := dir.ShallowWriter()
c.Assert(err, IsNil)
_, err = f.Write([]byte("foo"))
c.Assert(err, IsNil)
f, err = dir.Shallow()
c.Assert(err, IsNil)
cnt, err := io.ReadAll(f)
c.Assert(err, IsNil)
c.Assert(string(cnt), Equals, "foo")
}
func findReference(refs []*plumbing.Reference, name string) *plumbing.Reference {
n := plumbing.ReferenceName(name)
for _, ref := range refs {
if ref.Name() == n {
return ref
}
}
return nil
}
func (s *SuiteDotGit) TestObjectPacks(c *C) {
f := fixtures.Basic().ByTag(".git").One()
fs := f.DotGit()
dir := New(fs)
testObjectPacks(c, fs, dir, f)
}
func (s *SuiteDotGit) TestObjectPacksExclusive(c *C) {
f := fixtures.Basic().ByTag(".git").One()
fs := f.DotGit()
dir := NewWithOptions(fs, Options{ExclusiveAccess: true})
testObjectPacks(c, fs, dir, f)
}
func testObjectPacks(c *C, fs billy.Filesystem, dir *DotGit, f *fixtures.Fixture) {
hashes, err := dir.ObjectPacks()
c.Assert(err, IsNil)
c.Assert(hashes, HasLen, 1)
c.Assert(hashes[0], Equals, plumbing.NewHash(f.PackfileHash))
// Make sure that a random file in the pack directory doesn't
// break everything.
badFile, err := fs.Create("objects/pack/OOPS_THIS_IS_NOT_RIGHT.pack")
c.Assert(err, IsNil)
err = badFile.Close()
c.Assert(err, IsNil)
// temporary file generated by git gc
tmpFile, err := fs.Create("objects/pack/.tmp-11111-pack-58rf8y4wm1b1k52bpe0kdlx6lpreg6ahso8n3ylc.pack")
c.Assert(err, IsNil)
err = tmpFile.Close()
c.Assert(err, IsNil)
hashes2, err := dir.ObjectPacks()
c.Assert(err, IsNil)
c.Assert(hashes2, HasLen, 1)
c.Assert(hashes[0], Equals, hashes2[0])
}
func (s *SuiteDotGit) TestObjectPack(c *C) {
f := fixtures.Basic().ByTag(".git").One()
fs := f.DotGit()
dir := New(fs)
pack, err := dir.ObjectPack(plumbing.NewHash(f.PackfileHash))
c.Assert(err, IsNil)
c.Assert(filepath.Ext(pack.Name()), Equals, ".pack")
}
func (s *SuiteDotGit) TestObjectPackWithKeepDescriptors(c *C) {
f := fixtures.Basic().ByTag(".git").One()
fs := f.DotGit()
dir := NewWithOptions(fs, Options{KeepDescriptors: true})
pack, err := dir.ObjectPack(plumbing.NewHash(f.PackfileHash))
c.Assert(err, IsNil)
c.Assert(filepath.Ext(pack.Name()), Equals, ".pack")
// Move to an specific offset
pack.Seek(42, io.SeekStart)
pack2, err := dir.ObjectPack(plumbing.NewHash(f.PackfileHash))
c.Assert(err, IsNil)
// If the file is the same the offset should be the same
offset, err := pack2.Seek(0, io.SeekCurrent)
c.Assert(err, IsNil)
c.Assert(offset, Equals, int64(42))
err = dir.Close()
c.Assert(err, IsNil)
pack2, err = dir.ObjectPack(plumbing.NewHash(f.PackfileHash))
c.Assert(err, IsNil)
// If the file is opened again its offset should be 0
offset, err = pack2.Seek(0, io.SeekCurrent)
c.Assert(err, IsNil)
c.Assert(offset, Equals, int64(0))
err = pack2.Close()
c.Assert(err, IsNil)
err = dir.Close()
c.Assert(err, NotNil)
}
func (s *SuiteDotGit) TestObjectPackIdx(c *C) {
f := fixtures.Basic().ByTag(".git").One()
fs := f.DotGit()
dir := New(fs)
idx, err := dir.ObjectPackIdx(plumbing.NewHash(f.PackfileHash))
c.Assert(err, IsNil)
c.Assert(filepath.Ext(idx.Name()), Equals, ".idx")
c.Assert(idx.Close(), IsNil)
}
func (s *SuiteDotGit) TestObjectPackNotFound(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
pack, err := dir.ObjectPack(plumbing.ZeroHash)
c.Assert(err, Equals, ErrPackfileNotFound)
c.Assert(pack, IsNil)
idx, err := dir.ObjectPackIdx(plumbing.ZeroHash)
c.Assert(err, Equals, ErrPackfileNotFound)
c.Assert(idx, IsNil)
}
func (s *SuiteDotGit) TestNewObject(c *C) {
fs := s.TemporalFilesystem(c)
dir := New(fs)
w, err := dir.NewObject()
c.Assert(err, IsNil)
err = w.WriteHeader(plumbing.BlobObject, 14)
c.Assert(err, IsNil)
n, err := w.Write([]byte("this is a test"))
c.Assert(err, IsNil)
c.Assert(n, Equals, 14)
c.Assert(w.Hash().String(), Equals, "a8a940627d132695a9769df883f85992f0ff4a43")
err = w.Close()
c.Assert(err, IsNil)
i, err := fs.Stat("objects/a8/a940627d132695a9769df883f85992f0ff4a43")
c.Assert(err, IsNil)
c.Assert(i.Size(), Equals, int64(34))
}
func (s *SuiteDotGit) TestObjects(c *C) {
fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit()
dir := New(fs)
testObjects(c, fs, dir)
testObjectsWithPrefix(c, fs, dir)
}
func (s *SuiteDotGit) TestObjectsExclusive(c *C) {
fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit()
dir := NewWithOptions(fs, Options{ExclusiveAccess: true})
testObjects(c, fs, dir)
testObjectsWithPrefix(c, fs, dir)
}
func testObjects(c *C, _ billy.Filesystem, dir *DotGit) {
hashes, err := dir.Objects()
c.Assert(err, IsNil)
c.Assert(hashes, HasLen, 187)
c.Assert(hashes[0].String(), Equals, "0097821d427a3c3385898eb13b50dcbc8702b8a3")
c.Assert(hashes[1].String(), Equals, "01d5fa556c33743006de7e76e67a2dfcd994ca04")
c.Assert(hashes[2].String(), Equals, "03db8e1fbe133a480f2867aac478fd866686d69e")
}
func testObjectsWithPrefix(c *C, _ billy.Filesystem, dir *DotGit) {
prefix, _ := hex.DecodeString("01d5")
hashes, err := dir.ObjectsWithPrefix(prefix)
c.Assert(err, IsNil)
c.Assert(hashes, HasLen, 1)
c.Assert(hashes[0].String(), Equals, "01d5fa556c33743006de7e76e67a2dfcd994ca04")
// Empty prefix should yield all objects.
// (subset of testObjects)
hashes, err = dir.ObjectsWithPrefix(nil)
c.Assert(err, IsNil)
c.Assert(hashes, HasLen, 187)
}
func (s *SuiteDotGit) TestObjectsNoFolder(c *C) {
fs := s.TemporalFilesystem(c)
dir := New(fs)
hash, err := dir.Objects()
c.Assert(err, IsNil)
c.Assert(hash, HasLen, 0)
}
func (s *SuiteDotGit) TestObject(c *C) {
fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit()
dir := New(fs)
hash := plumbing.NewHash("03db8e1fbe133a480f2867aac478fd866686d69e")
file, err := dir.Object(hash)
c.Assert(err, IsNil)
c.Assert(strings.HasSuffix(
file.Name(), fs.Join("objects", "03", "db8e1fbe133a480f2867aac478fd866686d69e")),
Equals, true,
)
incomingHash := "9d25e0f9bde9f82882b49fe29117b9411cb157b7" // made up hash
incomingDirPath := fs.Join("objects", "tmp_objdir-incoming-123456")
incomingFilePath := fs.Join(incomingDirPath, incomingHash[0:2], incomingHash[2:40])
fs.MkdirAll(incomingDirPath, os.FileMode(0755))
fs.Create(incomingFilePath)
_, err = dir.Object(plumbing.NewHash(incomingHash))
c.Assert(err, IsNil)
}
func (s *SuiteDotGit) TestPreGit235Object(c *C) {
fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit()
dir := New(fs)
hash := plumbing.NewHash("03db8e1fbe133a480f2867aac478fd866686d69e")
file, err := dir.Object(hash)
c.Assert(err, IsNil)
c.Assert(strings.HasSuffix(
file.Name(), fs.Join("objects", "03", "db8e1fbe133a480f2867aac478fd866686d69e")),
Equals, true,
)
incomingHash := "9d25e0f9bde9f82882b49fe29117b9411cb157b7" // made up hash
incomingDirPath := fs.Join("objects", "incoming-123456")
incomingFilePath := fs.Join(incomingDirPath, incomingHash[0:2], incomingHash[2:40])
fs.MkdirAll(incomingDirPath, os.FileMode(0755))
fs.Create(incomingFilePath)
_, err = dir.Object(plumbing.NewHash(incomingHash))
c.Assert(err, IsNil)
}
func (s *SuiteDotGit) TestObjectStat(c *C) {
fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit()
dir := New(fs)
hash := plumbing.NewHash("03db8e1fbe133a480f2867aac478fd866686d69e")
_, err := dir.ObjectStat(hash)
c.Assert(err, IsNil)
incomingHash := "9d25e0f9bde9f82882b49fe29117b9411cb157b7" // made up hash
incomingDirPath := fs.Join("objects", "tmp_objdir-incoming-123456")
incomingFilePath := fs.Join(incomingDirPath, incomingHash[0:2], incomingHash[2:40])
fs.MkdirAll(incomingDirPath, os.FileMode(0755))
fs.Create(incomingFilePath)
_, err = dir.ObjectStat(plumbing.NewHash(incomingHash))
c.Assert(err, IsNil)
}
func (s *SuiteDotGit) TestObjectDelete(c *C) {
fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit()
dir := New(fs)
hash := plumbing.NewHash("03db8e1fbe133a480f2867aac478fd866686d69e")
err := dir.ObjectDelete(hash)
c.Assert(err, IsNil)
incomingHash := "9d25e0f9bde9f82882b49fe29117b9411cb157b7" // made up hash
incomingDirPath := fs.Join("objects", "tmp_objdir-incoming-123456")
incomingSubDirPath := fs.Join(incomingDirPath, incomingHash[0:2])
incomingFilePath := fs.Join(incomingSubDirPath, incomingHash[2:40])
err = fs.MkdirAll(incomingSubDirPath, os.FileMode(0755))
c.Assert(err, IsNil)
f, err := fs.Create(incomingFilePath)
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
err = dir.ObjectDelete(plumbing.NewHash(incomingHash))
c.Assert(err, IsNil)
}
func (s *SuiteDotGit) TestObjectNotFound(c *C) {
fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit()
dir := New(fs)
hash := plumbing.NewHash("not-found-object")
file, err := dir.Object(hash)
c.Assert(err, NotNil)
c.Assert(file, IsNil)
}
func (s *SuiteDotGit) TestSubmodules(c *C) {
fs := fixtures.ByTag("submodule").One().DotGit()
dir := New(fs)
m, err := dir.Module("basic")
c.Assert(err, IsNil)
c.Assert(strings.HasSuffix(m.Root(), m.Join(".git", "modules", "basic")), Equals, true)
}
func (s *SuiteDotGit) TestPackRefs(c *C) {
fs := s.TemporalFilesystem(c)
dir := New(fs)
err := dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/foo",
"e8d3ffab552895c19b9fcf7aa264d277cde33881",
), nil)
c.Assert(err, IsNil)
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/bar",
"a8d3ffab552895c19b9fcf7aa264d277cde33881",
), nil)
c.Assert(err, IsNil)
refs, err := dir.Refs()
c.Assert(err, IsNil)
c.Assert(refs, HasLen, 2)
looseCount, err := dir.CountLooseRefs()
c.Assert(err, IsNil)
c.Assert(looseCount, Equals, 2)
err = dir.PackRefs()
c.Assert(err, IsNil)
// Make sure the refs are still there, but no longer loose.
refs, err = dir.Refs()
c.Assert(err, IsNil)
c.Assert(refs, HasLen, 2)
looseCount, err = dir.CountLooseRefs()
c.Assert(err, IsNil)
c.Assert(looseCount, Equals, 0)
ref, err := dir.Ref("refs/heads/foo")
c.Assert(err, IsNil)
c.Assert(ref, NotNil)
c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
ref, err = dir.Ref("refs/heads/bar")
c.Assert(err, IsNil)
c.Assert(ref, NotNil)
c.Assert(ref.Hash().String(), Equals, "a8d3ffab552895c19b9fcf7aa264d277cde33881")
// Now update one of them, re-pack, and check again.
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/foo",
"b8d3ffab552895c19b9fcf7aa264d277cde33881",
), nil)
c.Assert(err, IsNil)
looseCount, err = dir.CountLooseRefs()
c.Assert(err, IsNil)
c.Assert(looseCount, Equals, 1)
err = dir.PackRefs()
c.Assert(err, IsNil)
// Make sure the refs are still there, but no longer loose.
refs, err = dir.Refs()
c.Assert(err, IsNil)
c.Assert(refs, HasLen, 2)
looseCount, err = dir.CountLooseRefs()
c.Assert(err, IsNil)
c.Assert(looseCount, Equals, 0)
ref, err = dir.Ref("refs/heads/foo")
c.Assert(err, IsNil)
c.Assert(ref, NotNil)
c.Assert(ref.Hash().String(), Equals, "b8d3ffab552895c19b9fcf7aa264d277cde33881")
}
func TestAlternatesDefault(t *testing.T) {
// Create a new dotgit object.
dotFS := osfs.New(t.TempDir())
testAlternates(t, dotFS, dotFS)
}
func TestAlternatesWithFS(t *testing.T) {
// Create a new dotgit object with a specific FS for alternates.
altFS := osfs.New(t.TempDir())
dotFS, _ := altFS.Chroot("repo2")
testAlternates(t, dotFS, altFS)
}
func TestAlternatesWithBoundOS(t *testing.T) {
// Create a new dotgit object with a specific FS for alternates.
altFS := osfs.New(t.TempDir(), osfs.WithBoundOS())
dotFS, _ := altFS.Chroot("repo2")
testAlternates(t, dotFS, altFS)
}
func testAlternates(t *testing.T, dotFS, altFS billy.Filesystem) {
tests := []struct {
name string
in []string
inWindows []string
setup func()
wantErr bool
wantRoots []string
}{
{
name: "no alternates",
},
{
name: "abs path",
in: []string{filepath.Join(altFS.Root(), "./repo1/.git/objects")},
inWindows: []string{filepath.Join(altFS.Root(), ".\\repo1\\.git\\objects")},
setup: func() {
err := altFS.MkdirAll(filepath.Join("repo1", ".git", "objects"), 0o700)
assert.NoError(t, err)
},
wantRoots: []string{filepath.Join("repo1", ".git")},
},
{
name: "rel path",
in: []string{"../../../repo3//.git/objects"},
inWindows: []string{"..\\..\\..\\repo3\\.git\\objects"},
setup: func() {
err := altFS.MkdirAll(filepath.Join("repo3", ".git", "objects"), 0o700)
assert.NoError(t, err)
},
wantRoots: []string{filepath.Join("repo3", ".git")},
},
{
name: "invalid abs path",
in: []string{"/alt/target2"},
inWindows: []string{"\\alt\\target2"},
wantErr: true,
},
{
name: "invalid rel path",
in: []string{"../../../alt/target3"},
inWindows: []string{"..\\..\\..\\alt\\target3"},
wantErr: true,
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
dir := NewWithOptions(dotFS, Options{AlternatesFS: altFS})
err := dir.Initialize()
assert.NoError(t, err)
content := strings.Join(tc.in, "\n")
if runtime.GOOS == "windows" {
content = strings.Join(tc.inWindows, "\r\n")
}
// Create alternates file.
altpath := dotFS.Join("objects", "info", "alternates")
f, err := dotFS.Create(altpath)
assert.NoError(t, err)
f.Write([]byte(content))
f.Close()
if tc.setup != nil {
tc.setup()
}
dotgits, err := dir.Alternates()
if tc.wantErr {
assert.Error(t, err)
} else {
assert.NoError(t, err)
}
for i, d := range dotgits {
assert.Regexp(t, "^"+regexp.QuoteMeta(altFS.Root()), d.fs.Root())
assert.Regexp(t, regexp.QuoteMeta(tc.wantRoots[i])+"$", d.fs.Root())
}
})
}
}
func TestAlternatesDupes(t *testing.T) {
dotFS := osfs.New(t.TempDir())
dir := New(dotFS)
err := dir.Initialize()
assert.NoError(t, err)
path := filepath.Join(dotFS.Root(), "target3")
dupes := []string{path, path, path, path, path}
content := strings.Join(dupes, "\n")
if runtime.GOOS == "windows" {
content = strings.Join(dupes, "\r\n")
}
err = dotFS.MkdirAll("target3", 0o700)
assert.NoError(t, err)
// Create alternates file.
altpath := dotFS.Join("objects", "info", "alternates")
f, err := dotFS.Create(altpath)
assert.NoError(t, err)
f.Write([]byte(content))
f.Close()
dotgits, err := dir.Alternates()
assert.NoError(t, err)
assert.Len(t, dotgits, 1)
}
type norwfs struct {
billy.Filesystem
}
func (f *norwfs) Capabilities() billy.Capability {
return billy.Capabilities(f.Filesystem) &^ billy.ReadAndWriteCapability
}
func (s *SuiteDotGit) TestIncBytes(c *C) {
tests := []struct {
in []byte
out []byte
overflow bool
}{
{[]byte{0}, []byte{1}, false},
{[]byte{0xff}, []byte{0}, true},
{[]byte{7, 0xff}, []byte{8, 0}, false},
{[]byte{0xff, 0xff}, []byte{0, 0}, true},
}
for _, test := range tests {
out, overflow := incBytes(test.in)
c.Assert(out, DeepEquals, test.out)
c.Assert(overflow, Equals, test.overflow)
}
}
// this filesystem wrapper returns os.ErrNotExist if the file matches
// the provided paths list
type notExistsFS struct {
billy.Filesystem
paths []string
}
func (f *notExistsFS) matches(path string) bool {
p := filepath.ToSlash(path)
for _, n := range f.paths {
if p == n {
return true
}
}
return false
}
func (f *notExistsFS) Open(filename string) (billy.File, error) {
if f.matches(filename) {
return nil, os.ErrNotExist
}
return f.Filesystem.Open(filename)
}
func (f *notExistsFS) ReadDir(path string) ([]os.FileInfo, error) {
if f.matches(path) {
return nil, os.ErrNotExist
}
return f.Filesystem.ReadDir(path)
}
func (s *SuiteDotGit) TestDeletedRefs(c *C) {
fs := s.TemporalFilesystem(c)
dir := New(¬ExistsFS{
Filesystem: fs,
paths: []string{
"refs/heads/bar",
"refs/heads/baz",
},
})
err := dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/foo",
"e8d3ffab552895c19b9fcf7aa264d277cde33881",
), nil)
c.Assert(err, IsNil)
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/bar",
"a8d3ffab552895c19b9fcf7aa264d277cde33881",
), nil)
c.Assert(err, IsNil)
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/baz/baz",
"a8d3ffab552895c19b9fcf7aa264d277cde33881",
), nil)
c.Assert(err, IsNil)
refs, err := dir.Refs()
c.Assert(err, IsNil)
c.Assert(refs, HasLen, 1)
c.Assert(refs[0].Name(), Equals, plumbing.ReferenceName("refs/heads/foo"))
}
// Checks that setting a reference that has been packed and checking its old value is successful
func (s *SuiteDotGit) TestSetPackedRef(c *C) {
fs := s.TemporalFilesystem(c)
dir := New(fs)
err := dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/foo",
"e8d3ffab552895c19b9fcf7aa264d277cde33881",
), nil)
c.Assert(err, IsNil)
refs, err := dir.Refs()
c.Assert(err, IsNil)
c.Assert(refs, HasLen, 1)
looseCount, err := dir.CountLooseRefs()
c.Assert(err, IsNil)
c.Assert(looseCount, Equals, 1)
err = dir.PackRefs()
c.Assert(err, IsNil)
// Make sure the refs are still there, but no longer loose.
refs, err = dir.Refs()
c.Assert(err, IsNil)
c.Assert(refs, HasLen, 1)
looseCount, err = dir.CountLooseRefs()
c.Assert(err, IsNil)
c.Assert(looseCount, Equals, 0)
ref, err := dir.Ref("refs/heads/foo")
c.Assert(err, IsNil)
c.Assert(ref, NotNil)
c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
// Attempt to update the reference using an invalid old reference value
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/foo",
"b8d3ffab552895c19b9fcf7aa264d277cde33881",
), plumbing.NewReferenceFromStrings(
"refs/heads/foo",
"e8d3ffab552895c19b9fcf7aa264d277cde33882",
))
c.Assert(err, Equals, storage.ErrReferenceHasChanged)
// Now update the reference and it should pass
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/foo",
"b8d3ffab552895c19b9fcf7aa264d277cde33881",
), plumbing.NewReferenceFromStrings(
"refs/heads/foo",
"e8d3ffab552895c19b9fcf7aa264d277cde33881",
))
c.Assert(err, IsNil)
looseCount, err = dir.CountLooseRefs()
c.Assert(err, IsNil)
c.Assert(looseCount, Equals, 1)
}
go-git-5.13.2/storage/filesystem/dotgit/reader.go 0000664 0000000 0000000 00000002651 14744245500 0021714 0 ustar 00root root 0000000 0000000 package dotgit
import (
"fmt"
"io"
"os"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/objfile"
"github.com/go-git/go-git/v5/utils/ioutil"
)
var _ (plumbing.EncodedObject) = &EncodedObject{}
type EncodedObject struct {
dir *DotGit
h plumbing.Hash
t plumbing.ObjectType
sz int64
}
func (e *EncodedObject) Hash() plumbing.Hash {
return e.h
}
func (e *EncodedObject) Reader() (io.ReadCloser, error) {
f, err := e.dir.Object(e.h)
if err != nil {
if os.IsNotExist(err) {
return nil, plumbing.ErrObjectNotFound
}
return nil, err
}
r, err := objfile.NewReader(f)
if err != nil {
return nil, err
}
t, size, err := r.Header()
if err != nil {
_ = r.Close()
return nil, err
}
if t != e.t {
_ = r.Close()
return nil, objfile.ErrHeader
}
if size != e.sz {
_ = r.Close()
return nil, objfile.ErrHeader
}
return ioutil.NewReadCloserWithCloser(r, f.Close), nil
}
func (e *EncodedObject) SetType(plumbing.ObjectType) {}
func (e *EncodedObject) Type() plumbing.ObjectType {
return e.t
}
func (e *EncodedObject) Size() int64 {
return e.sz
}
func (e *EncodedObject) SetSize(int64) {}
func (e *EncodedObject) Writer() (io.WriteCloser, error) {
return nil, fmt.Errorf("not supported")
}
func NewEncodedObject(dir *DotGit, h plumbing.Hash, t plumbing.ObjectType, size int64) *EncodedObject {
return &EncodedObject{
dir: dir,
h: h,
t: t,
sz: size,
}
}
go-git-5.13.2/storage/filesystem/dotgit/repository_filesystem.go 0000664 0000000 0000000 00000007237 14744245500 0025142 0 ustar 00root root 0000000 0000000 package dotgit
import (
"os"
"path/filepath"
"strings"
"github.com/go-git/go-billy/v5"
)
// RepositoryFilesystem is a billy.Filesystem compatible object wrapper
// which handles dot-git filesystem operations and supports commondir according to git scm layout:
// https://github.com/git/git/blob/master/Documentation/gitrepository-layout.txt
type RepositoryFilesystem struct {
dotGitFs billy.Filesystem
commonDotGitFs billy.Filesystem
}
func NewRepositoryFilesystem(dotGitFs, commonDotGitFs billy.Filesystem) *RepositoryFilesystem {
return &RepositoryFilesystem{
dotGitFs: dotGitFs,
commonDotGitFs: commonDotGitFs,
}
}
func (fs *RepositoryFilesystem) mapToRepositoryFsByPath(path string) billy.Filesystem {
// Nothing to decide if commondir not defined
if fs.commonDotGitFs == nil {
return fs.dotGitFs
}
cleanPath := filepath.Clean(path)
// Check exceptions for commondir (https://git-scm.com/docs/gitrepository-layout#Documentation/gitrepository-layout.txt)
switch cleanPath {
case fs.dotGitFs.Join(logsPath, "HEAD"):
return fs.dotGitFs
case fs.dotGitFs.Join(refsPath, "bisect"), fs.dotGitFs.Join(refsPath, "rewritten"), fs.dotGitFs.Join(refsPath, "worktree"):
return fs.dotGitFs
}
// Determine dot-git root by first path element.
// There are some elements which should always use commondir when commondir defined.
// Usual dot-git root will be used for the rest of files.
switch strings.Split(cleanPath, string(filepath.Separator))[0] {
case objectsPath, refsPath, packedRefsPath, configPath, branchesPath, hooksPath, infoPath, remotesPath, logsPath, shallowPath, worktreesPath:
return fs.commonDotGitFs
default:
return fs.dotGitFs
}
}
func (fs *RepositoryFilesystem) Create(filename string) (billy.File, error) {
return fs.mapToRepositoryFsByPath(filename).Create(filename)
}
func (fs *RepositoryFilesystem) Open(filename string) (billy.File, error) {
return fs.mapToRepositoryFsByPath(filename).Open(filename)
}
func (fs *RepositoryFilesystem) OpenFile(filename string, flag int, perm os.FileMode) (billy.File, error) {
return fs.mapToRepositoryFsByPath(filename).OpenFile(filename, flag, perm)
}
func (fs *RepositoryFilesystem) Stat(filename string) (os.FileInfo, error) {
return fs.mapToRepositoryFsByPath(filename).Stat(filename)
}
func (fs *RepositoryFilesystem) Rename(oldpath, newpath string) error {
return fs.mapToRepositoryFsByPath(oldpath).Rename(oldpath, newpath)
}
func (fs *RepositoryFilesystem) Remove(filename string) error {
return fs.mapToRepositoryFsByPath(filename).Remove(filename)
}
func (fs *RepositoryFilesystem) Join(elem ...string) string {
return fs.dotGitFs.Join(elem...)
}
func (fs *RepositoryFilesystem) TempFile(dir, prefix string) (billy.File, error) {
return fs.mapToRepositoryFsByPath(dir).TempFile(dir, prefix)
}
func (fs *RepositoryFilesystem) ReadDir(path string) ([]os.FileInfo, error) {
return fs.mapToRepositoryFsByPath(path).ReadDir(path)
}
func (fs *RepositoryFilesystem) MkdirAll(filename string, perm os.FileMode) error {
return fs.mapToRepositoryFsByPath(filename).MkdirAll(filename, perm)
}
func (fs *RepositoryFilesystem) Lstat(filename string) (os.FileInfo, error) {
return fs.mapToRepositoryFsByPath(filename).Lstat(filename)
}
func (fs *RepositoryFilesystem) Symlink(target, link string) error {
return fs.mapToRepositoryFsByPath(target).Symlink(target, link)
}
func (fs *RepositoryFilesystem) Readlink(link string) (string, error) {
return fs.mapToRepositoryFsByPath(link).Readlink(link)
}
func (fs *RepositoryFilesystem) Chroot(path string) (billy.Filesystem, error) {
return fs.mapToRepositoryFsByPath(path).Chroot(path)
}
func (fs *RepositoryFilesystem) Root() string {
return fs.dotGitFs.Root()
}
go-git-5.13.2/storage/filesystem/dotgit/repository_filesystem_test.go 0000664 0000000 0000000 00000006452 14744245500 0026177 0 ustar 00root root 0000000 0000000 package dotgit
import (
"os"
. "gopkg.in/check.v1"
)
func (s *SuiteDotGit) TestRepositoryFilesystem(c *C) {
fs := s.TemporalFilesystem(c)
err := fs.MkdirAll("dotGit", 0777)
c.Assert(err, IsNil)
dotGitFs, err := fs.Chroot("dotGit")
c.Assert(err, IsNil)
err = fs.MkdirAll("commonDotGit", 0777)
c.Assert(err, IsNil)
commonDotGitFs, err := fs.Chroot("commonDotGit")
c.Assert(err, IsNil)
repositoryFs := NewRepositoryFilesystem(dotGitFs, commonDotGitFs)
c.Assert(repositoryFs.Root(), Equals, dotGitFs.Root())
somedir, err := repositoryFs.Chroot("somedir")
c.Assert(err, IsNil)
c.Assert(somedir.Root(), Equals, repositoryFs.Join(dotGitFs.Root(), "somedir"))
_, err = repositoryFs.Create("somefile")
c.Assert(err, IsNil)
_, err = repositoryFs.Stat("somefile")
c.Assert(err, IsNil)
file, err := repositoryFs.Open("somefile")
c.Assert(err, IsNil)
err = file.Close()
c.Assert(err, IsNil)
file, err = repositoryFs.OpenFile("somefile", os.O_RDONLY, 0666)
c.Assert(err, IsNil)
err = file.Close()
c.Assert(err, IsNil)
file, err = repositoryFs.Create("somefile2")
c.Assert(err, IsNil)
err = file.Close()
c.Assert(err, IsNil)
_, err = repositoryFs.Stat("somefile2")
c.Assert(err, IsNil)
err = repositoryFs.Rename("somefile2", "newfile")
c.Assert(err, IsNil)
tempDir, err := repositoryFs.TempFile("tmp", "myprefix")
c.Assert(err, IsNil)
c.Assert(repositoryFs.Join(repositoryFs.Root(), "tmp", tempDir.Name()), Equals, repositoryFs.Join(dotGitFs.Root(), "tmp", tempDir.Name()))
err = repositoryFs.Symlink("newfile", "somelink")
c.Assert(err, IsNil)
_, err = repositoryFs.Lstat("somelink")
c.Assert(err, IsNil)
link, err := repositoryFs.Readlink("somelink")
c.Assert(err, IsNil)
c.Assert(link, Equals, "newfile")
err = repositoryFs.Remove("somelink")
c.Assert(err, IsNil)
_, err = repositoryFs.Stat("somelink")
c.Assert(os.IsNotExist(err), Equals, true)
dirs := []string{objectsPath, refsPath, packedRefsPath, configPath, branchesPath, hooksPath, infoPath, remotesPath, logsPath, shallowPath, worktreesPath}
for _, dir := range dirs {
err := repositoryFs.MkdirAll(dir, 0777)
c.Assert(err, IsNil)
_, err = commonDotGitFs.Stat(dir)
c.Assert(err, IsNil)
_, err = dotGitFs.Stat(dir)
c.Assert(os.IsNotExist(err), Equals, true)
}
exceptionsPaths := []string{repositoryFs.Join(logsPath, "HEAD"), repositoryFs.Join(refsPath, "bisect"), repositoryFs.Join(refsPath, "rewritten"), repositoryFs.Join(refsPath, "worktree")}
for _, path := range exceptionsPaths {
_, err := repositoryFs.Create(path)
c.Assert(err, IsNil)
_, err = commonDotGitFs.Stat(path)
c.Assert(os.IsNotExist(err), Equals, true)
_, err = dotGitFs.Stat(path)
c.Assert(err, IsNil)
}
err = repositoryFs.MkdirAll("refs/heads", 0777)
c.Assert(err, IsNil)
_, err = commonDotGitFs.Stat("refs/heads")
c.Assert(err, IsNil)
_, err = dotGitFs.Stat("refs/heads")
c.Assert(os.IsNotExist(err), Equals, true)
err = repositoryFs.MkdirAll("objects/pack", 0777)
c.Assert(err, IsNil)
_, err = commonDotGitFs.Stat("objects/pack")
c.Assert(err, IsNil)
_, err = dotGitFs.Stat("objects/pack")
c.Assert(os.IsNotExist(err), Equals, true)
err = repositoryFs.MkdirAll("a/b/c", 0777)
c.Assert(err, IsNil)
_, err = commonDotGitFs.Stat("a/b/c")
c.Assert(os.IsNotExist(err), Equals, true)
_, err = dotGitFs.Stat("a/b/c")
c.Assert(err, IsNil)
}
go-git-5.13.2/storage/filesystem/dotgit/writers.go 0000664 0000000 0000000 00000013143 14744245500 0022147 0 ustar 00root root 0000000 0000000 package dotgit
import (
"fmt"
"io"
"sync/atomic"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/idxfile"
"github.com/go-git/go-git/v5/plumbing/format/objfile"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/plumbing/hash"
"github.com/go-git/go-billy/v5"
)
// PackWriter is a io.Writer that generates the packfile index simultaneously,
// a packfile.Decoder is used with a file reader to read the file being written
// this operation is synchronized with the write operations.
// The packfile is written in a temp file, when Close is called this file
// is renamed/moved (depends on the Filesystem implementation) to the final
// location, if the PackWriter is not used, nothing is written
type PackWriter struct {
Notify func(plumbing.Hash, *idxfile.Writer)
fs billy.Filesystem
fr, fw billy.File
synced *syncedReader
checksum plumbing.Hash
parser *packfile.Parser
writer *idxfile.Writer
result chan error
}
func newPackWrite(fs billy.Filesystem) (*PackWriter, error) {
fw, err := fs.TempFile(fs.Join(objectsPath, packPath), "tmp_pack_")
if err != nil {
return nil, err
}
fr, err := fs.Open(fw.Name())
if err != nil {
return nil, err
}
writer := &PackWriter{
fs: fs,
fw: fw,
fr: fr,
synced: newSyncedReader(fw, fr),
result: make(chan error),
}
go writer.buildIndex()
return writer, nil
}
func (w *PackWriter) buildIndex() {
s := packfile.NewScanner(w.synced)
w.writer = new(idxfile.Writer)
var err error
w.parser, err = packfile.NewParser(s, w.writer)
if err != nil {
w.result <- err
return
}
checksum, err := w.parser.Parse()
if err != nil {
w.result <- err
return
}
w.checksum = checksum
w.result <- err
}
// waitBuildIndex waits until buildIndex function finishes, this can terminate
// with a packfile.ErrEmptyPackfile, this means that nothing was written so we
// ignore the error
func (w *PackWriter) waitBuildIndex() error {
err := <-w.result
if err == packfile.ErrEmptyPackfile {
return nil
}
return err
}
func (w *PackWriter) Write(p []byte) (int, error) {
return w.synced.Write(p)
}
// Close closes all the file descriptors and save the final packfile, if nothing
// was written, the tempfiles are deleted without writing a packfile.
func (w *PackWriter) Close() error {
defer func() {
if w.Notify != nil && w.writer != nil && w.writer.Finished() {
w.Notify(w.checksum, w.writer)
}
close(w.result)
}()
if err := w.synced.Close(); err != nil {
return err
}
if err := w.waitBuildIndex(); err != nil {
return err
}
if err := w.fr.Close(); err != nil {
return err
}
if err := w.fw.Close(); err != nil {
return err
}
if w.writer == nil || !w.writer.Finished() {
return w.clean()
}
return w.save()
}
func (w *PackWriter) clean() error {
return w.fs.Remove(w.fw.Name())
}
func (w *PackWriter) save() error {
base := w.fs.Join(objectsPath, packPath, fmt.Sprintf("pack-%s", w.checksum))
idx, err := w.fs.Create(fmt.Sprintf("%s.idx", base))
if err != nil {
return err
}
if err := w.encodeIdx(idx); err != nil {
return err
}
if err := idx.Close(); err != nil {
return err
}
return w.fs.Rename(w.fw.Name(), fmt.Sprintf("%s.pack", base))
}
func (w *PackWriter) encodeIdx(writer io.Writer) error {
idx, err := w.writer.Index()
if err != nil {
return err
}
e := idxfile.NewEncoder(writer)
_, err = e.Encode(idx)
return err
}
type syncedReader struct {
w io.Writer
r io.ReadSeeker
blocked, done uint32
written, read uint64
news chan bool
}
func newSyncedReader(w io.Writer, r io.ReadSeeker) *syncedReader {
return &syncedReader{
w: w,
r: r,
news: make(chan bool),
}
}
func (s *syncedReader) Write(p []byte) (n int, err error) {
defer func() {
written := atomic.AddUint64(&s.written, uint64(n))
read := atomic.LoadUint64(&s.read)
if written > read {
s.wake()
}
}()
n, err = s.w.Write(p)
return
}
func (s *syncedReader) Read(p []byte) (n int, err error) {
defer func() { atomic.AddUint64(&s.read, uint64(n)) }()
for {
s.sleep()
n, err = s.r.Read(p)
if err == io.EOF && !s.isDone() && n == 0 {
continue
}
break
}
return
}
func (s *syncedReader) isDone() bool {
return atomic.LoadUint32(&s.done) == 1
}
func (s *syncedReader) isBlocked() bool {
return atomic.LoadUint32(&s.blocked) == 1
}
func (s *syncedReader) wake() {
if s.isBlocked() {
atomic.StoreUint32(&s.blocked, 0)
s.news <- true
}
}
func (s *syncedReader) sleep() {
read := atomic.LoadUint64(&s.read)
written := atomic.LoadUint64(&s.written)
if read >= written {
atomic.StoreUint32(&s.blocked, 1)
<-s.news
}
}
func (s *syncedReader) Seek(offset int64, whence int) (int64, error) {
if whence == io.SeekCurrent {
return s.r.Seek(offset, whence)
}
p, err := s.r.Seek(offset, whence)
atomic.StoreUint64(&s.read, uint64(p))
return p, err
}
func (s *syncedReader) Close() error {
atomic.StoreUint32(&s.done, 1)
close(s.news)
return nil
}
type ObjectWriter struct {
objfile.Writer
fs billy.Filesystem
f billy.File
}
func newObjectWriter(fs billy.Filesystem) (*ObjectWriter, error) {
f, err := fs.TempFile(fs.Join(objectsPath, packPath), "tmp_obj_")
if err != nil {
return nil, err
}
return &ObjectWriter{
Writer: (*objfile.NewWriter(f)),
fs: fs,
f: f,
}, nil
}
func (w *ObjectWriter) Close() error {
if err := w.Writer.Close(); err != nil {
return err
}
if err := w.f.Close(); err != nil {
return err
}
return w.save()
}
func (w *ObjectWriter) save() error {
hex := w.Hash().String()
file := w.fs.Join(objectsPath, hex[0:2], hex[2:hash.HexSize])
return w.fs.Rename(w.f.Name(), file)
}
go-git-5.13.2/storage/filesystem/dotgit/writers_test.go 0000664 0000000 0000000 00000005541 14744245500 0023211 0 ustar 00root root 0000000 0000000 package dotgit
import (
"fmt"
"io"
"os"
"strconv"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-billy/v5/util"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/idxfile"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
func (s *SuiteDotGit) TestNewObjectPack(c *C) {
f := fixtures.Basic().One()
fs := s.TemporalFilesystem(c)
dot := New(fs)
w, err := dot.NewObjectPack()
c.Assert(err, IsNil)
_, err = io.Copy(w, f.Packfile())
c.Assert(err, IsNil)
c.Assert(w.Close(), IsNil)
pfPath := fmt.Sprintf("objects/pack/pack-%s.pack", f.PackfileHash)
idxPath := fmt.Sprintf("objects/pack/pack-%s.idx", f.PackfileHash)
stat, err := fs.Stat(pfPath)
c.Assert(err, IsNil)
c.Assert(stat.Size(), Equals, int64(84794))
stat, err = fs.Stat(idxPath)
c.Assert(err, IsNil)
c.Assert(stat.Size(), Equals, int64(1940))
pf, err := fs.Open(pfPath)
c.Assert(err, IsNil)
pfs := packfile.NewScanner(pf)
_, objects, err := pfs.Header()
c.Assert(err, IsNil)
for i := uint32(0); i < objects; i++ {
_, err := pfs.NextObjectHeader()
if err != nil {
c.Assert(err, IsNil)
break
}
}
c.Assert(pfs.Close(), IsNil)
}
func (s *SuiteDotGit) TestNewObjectPackUnused(c *C) {
fs := s.TemporalFilesystem(c)
dot := New(fs)
w, err := dot.NewObjectPack()
c.Assert(err, IsNil)
c.Assert(w.Close(), IsNil)
info, err := fs.ReadDir("objects/pack")
c.Assert(err, IsNil)
c.Assert(info, HasLen, 0)
// check clean up of temporary files
info, err = fs.ReadDir("")
c.Assert(err, IsNil)
for _, fi := range info {
c.Assert(fi.IsDir(), Equals, true)
}
}
func (s *SuiteDotGit) TestSyncedReader(c *C) {
tmpw, err := util.TempFile(osfs.Default, "", "example")
c.Assert(err, IsNil)
tmpr, err := osfs.Default.Open(tmpw.Name())
c.Assert(err, IsNil)
defer func() {
tmpw.Close()
tmpr.Close()
os.Remove(tmpw.Name())
}()
synced := newSyncedReader(tmpw, tmpr)
go func() {
for i := 0; i < 281; i++ {
_, err := synced.Write([]byte(strconv.Itoa(i) + "\n"))
c.Assert(err, IsNil)
}
synced.Close()
}()
o, err := synced.Seek(1002, io.SeekStart)
c.Assert(err, IsNil)
c.Assert(o, Equals, int64(1002))
head := make([]byte, 3)
n, err := io.ReadFull(synced, head)
c.Assert(err, IsNil)
c.Assert(n, Equals, 3)
c.Assert(string(head), Equals, "278")
o, err = synced.Seek(1010, io.SeekStart)
c.Assert(err, IsNil)
c.Assert(o, Equals, int64(1010))
n, err = io.ReadFull(synced, head)
c.Assert(err, IsNil)
c.Assert(n, Equals, 3)
c.Assert(string(head), Equals, "280")
}
func (s *SuiteDotGit) TestPackWriterUnusedNotify(c *C) {
fs := s.TemporalFilesystem(c)
w, err := newPackWrite(fs)
c.Assert(err, IsNil)
w.Notify = func(h plumbing.Hash, idx *idxfile.Writer) {
c.Fatal("unexpected call to PackWriter.Notify")
}
c.Assert(w.Close(), IsNil)
}
go-git-5.13.2/storage/filesystem/index.go 0000664 0000000 0000000 00000001610 14744245500 0020261 0 ustar 00root root 0000000 0000000 package filesystem
import (
"bufio"
"os"
"github.com/go-git/go-git/v5/plumbing/format/index"
"github.com/go-git/go-git/v5/storage/filesystem/dotgit"
"github.com/go-git/go-git/v5/utils/ioutil"
)
type IndexStorage struct {
dir *dotgit.DotGit
}
func (s *IndexStorage) SetIndex(idx *index.Index) (err error) {
f, err := s.dir.IndexWriter()
if err != nil {
return err
}
defer ioutil.CheckClose(f, &err)
bw := bufio.NewWriter(f)
defer func() {
if e := bw.Flush(); err == nil && e != nil {
err = e
}
}()
e := index.NewEncoder(bw)
err = e.Encode(idx)
return err
}
func (s *IndexStorage) Index() (i *index.Index, err error) {
idx := &index.Index{
Version: 2,
}
f, err := s.dir.Index()
if err != nil {
if os.IsNotExist(err) {
return idx, nil
}
return nil, err
}
defer ioutil.CheckClose(f, &err)
d := index.NewDecoder(f)
err = d.Decode(idx)
return idx, err
}
go-git-5.13.2/storage/filesystem/module.go 0000664 0000000 0000000 00000000650 14744245500 0020442 0 ustar 00root root 0000000 0000000 package filesystem
import (
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/storage"
"github.com/go-git/go-git/v5/storage/filesystem/dotgit"
)
type ModuleStorage struct {
dir *dotgit.DotGit
}
func (s *ModuleStorage) Module(name string) (storage.Storer, error) {
fs, err := s.dir.Module(name)
if err != nil {
return nil, err
}
return NewStorage(fs, cache.NewObjectLRUDefault()), nil
}
go-git-5.13.2/storage/filesystem/object.go 0000664 0000000 0000000 00000046610 14744245500 0020431 0 ustar 00root root 0000000 0000000 package filesystem
import (
"bytes"
"io"
"os"
"sync"
"time"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/format/idxfile"
"github.com/go-git/go-git/v5/plumbing/format/objfile"
"github.com/go-git/go-git/v5/plumbing/format/packfile"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/filesystem/dotgit"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-billy/v5"
)
type ObjectStorage struct {
options Options
// objectCache is an object cache uses to cache delta's bases and also recently
// loaded loose objects
objectCache cache.Object
dir *dotgit.DotGit
index map[plumbing.Hash]idxfile.Index
packList []plumbing.Hash
packListIdx int
packfiles map[plumbing.Hash]*packfile.Packfile
}
// NewObjectStorage creates a new ObjectStorage with the given .git directory and cache.
func NewObjectStorage(dir *dotgit.DotGit, objectCache cache.Object) *ObjectStorage {
return NewObjectStorageWithOptions(dir, objectCache, Options{})
}
// NewObjectStorageWithOptions creates a new ObjectStorage with the given .git directory, cache and extra options
func NewObjectStorageWithOptions(dir *dotgit.DotGit, objectCache cache.Object, ops Options) *ObjectStorage {
return &ObjectStorage{
options: ops,
objectCache: objectCache,
dir: dir,
}
}
func (s *ObjectStorage) requireIndex() error {
if s.index != nil {
return nil
}
s.index = make(map[plumbing.Hash]idxfile.Index)
packs, err := s.dir.ObjectPacks()
if err != nil {
return err
}
for _, h := range packs {
if err := s.loadIdxFile(h); err != nil {
return err
}
}
return nil
}
// Reindex indexes again all packfiles. Useful if git changed packfiles externally
func (s *ObjectStorage) Reindex() {
s.index = nil
}
func (s *ObjectStorage) loadIdxFile(h plumbing.Hash) (err error) {
f, err := s.dir.ObjectPackIdx(h)
if err != nil {
return err
}
defer ioutil.CheckClose(f, &err)
idxf := idxfile.NewMemoryIndex()
d := idxfile.NewDecoder(f)
if err = d.Decode(idxf); err != nil {
return err
}
s.index[h] = idxf
return err
}
func (s *ObjectStorage) NewEncodedObject() plumbing.EncodedObject {
return &plumbing.MemoryObject{}
}
func (s *ObjectStorage) PackfileWriter() (io.WriteCloser, error) {
if err := s.requireIndex(); err != nil {
return nil, err
}
w, err := s.dir.NewObjectPack()
if err != nil {
return nil, err
}
w.Notify = func(h plumbing.Hash, writer *idxfile.Writer) {
index, err := writer.Index()
if err == nil {
s.index[h] = index
}
}
return w, nil
}
// SetEncodedObject adds a new object to the storage.
func (s *ObjectStorage) SetEncodedObject(o plumbing.EncodedObject) (h plumbing.Hash, err error) {
if o.Type() == plumbing.OFSDeltaObject || o.Type() == plumbing.REFDeltaObject {
return plumbing.ZeroHash, plumbing.ErrInvalidType
}
ow, err := s.dir.NewObject()
if err != nil {
return plumbing.ZeroHash, err
}
defer ioutil.CheckClose(ow, &err)
or, err := o.Reader()
if err != nil {
return plumbing.ZeroHash, err
}
defer ioutil.CheckClose(or, &err)
if err = ow.WriteHeader(o.Type(), o.Size()); err != nil {
return plumbing.ZeroHash, err
}
if _, err = io.Copy(ow, or); err != nil {
return plumbing.ZeroHash, err
}
return o.Hash(), err
}
// LazyWriter returns a lazy ObjectWriter that is bound to a DotGit file.
// It first write the header passing on the object type and size, so
// that the object contents can be written later, without the need to
// create a MemoryObject and buffering its entire contents into memory.
func (s *ObjectStorage) LazyWriter() (w io.WriteCloser, wh func(typ plumbing.ObjectType, sz int64) error, err error) {
ow, err := s.dir.NewObject()
if err != nil {
return nil, nil, err
}
return ow, ow.WriteHeader, nil
}
// HasEncodedObject returns nil if the object exists, without actually
// reading the object data from storage.
func (s *ObjectStorage) HasEncodedObject(h plumbing.Hash) (err error) {
// Check unpacked objects
f, err := s.dir.Object(h)
if err != nil {
if !os.IsNotExist(err) {
return err
}
// Fall through to check packed objects.
} else {
defer ioutil.CheckClose(f, &err)
return nil
}
// Check packed objects.
if err := s.requireIndex(); err != nil {
return err
}
_, _, offset := s.findObjectInPackfile(h)
if offset == -1 {
return plumbing.ErrObjectNotFound
}
return nil
}
func (s *ObjectStorage) encodedObjectSizeFromUnpacked(h plumbing.Hash) (
size int64, err error) {
f, err := s.dir.Object(h)
if err != nil {
if os.IsNotExist(err) {
return 0, plumbing.ErrObjectNotFound
}
return 0, err
}
r, err := objfile.NewReader(f)
if err != nil {
return 0, err
}
defer ioutil.CheckClose(r, &err)
_, size, err = r.Header()
return size, err
}
func (s *ObjectStorage) packfile(idx idxfile.Index, pack plumbing.Hash) (*packfile.Packfile, error) {
if p := s.packfileFromCache(pack); p != nil {
return p, nil
}
f, err := s.dir.ObjectPack(pack)
if err != nil {
return nil, err
}
var p *packfile.Packfile
if s.objectCache != nil {
p = packfile.NewPackfileWithCache(idx, s.dir.Fs(), f, s.objectCache, s.options.LargeObjectThreshold)
} else {
p = packfile.NewPackfile(idx, s.dir.Fs(), f, s.options.LargeObjectThreshold)
}
return p, s.storePackfileInCache(pack, p)
}
func (s *ObjectStorage) packfileFromCache(hash plumbing.Hash) *packfile.Packfile {
if s.packfiles == nil {
if s.options.KeepDescriptors {
s.packfiles = make(map[plumbing.Hash]*packfile.Packfile)
} else if s.options.MaxOpenDescriptors > 0 {
s.packList = make([]plumbing.Hash, s.options.MaxOpenDescriptors)
s.packfiles = make(map[plumbing.Hash]*packfile.Packfile, s.options.MaxOpenDescriptors)
}
}
return s.packfiles[hash]
}
func (s *ObjectStorage) storePackfileInCache(hash plumbing.Hash, p *packfile.Packfile) error {
if s.options.KeepDescriptors {
s.packfiles[hash] = p
return nil
}
if s.options.MaxOpenDescriptors <= 0 {
return nil
}
// start over as the limit of packList is hit
if s.packListIdx >= len(s.packList) {
s.packListIdx = 0
}
// close the existing packfile if open
if next := s.packList[s.packListIdx]; !next.IsZero() {
open := s.packfiles[next]
delete(s.packfiles, next)
if open != nil {
if err := open.Close(); err != nil {
return err
}
}
}
// cache newly open packfile
s.packList[s.packListIdx] = hash
s.packfiles[hash] = p
s.packListIdx++
return nil
}
func (s *ObjectStorage) encodedObjectSizeFromPackfile(h plumbing.Hash) (
size int64, err error) {
if err := s.requireIndex(); err != nil {
return 0, err
}
pack, _, offset := s.findObjectInPackfile(h)
if offset == -1 {
return 0, plumbing.ErrObjectNotFound
}
idx := s.index[pack]
hash, err := idx.FindHash(offset)
if err == nil {
obj, ok := s.objectCache.Get(hash)
if ok {
return obj.Size(), nil
}
} else if err != nil && err != plumbing.ErrObjectNotFound {
return 0, err
}
p, err := s.packfile(idx, pack)
if err != nil {
return 0, err
}
if !s.options.KeepDescriptors && s.options.MaxOpenDescriptors == 0 {
defer ioutil.CheckClose(p, &err)
}
return p.GetSizeByOffset(offset)
}
// EncodedObjectSize returns the plaintext size of the given object,
// without actually reading the full object data from storage.
func (s *ObjectStorage) EncodedObjectSize(h plumbing.Hash) (
size int64, err error) {
size, err = s.encodedObjectSizeFromUnpacked(h)
if err != nil && err != plumbing.ErrObjectNotFound {
return 0, err
} else if err == nil {
return size, nil
}
return s.encodedObjectSizeFromPackfile(h)
}
// EncodedObject returns the object with the given hash, by searching for it in
// the packfile and the git object directories.
func (s *ObjectStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (plumbing.EncodedObject, error) {
var obj plumbing.EncodedObject
var err error
if s.index != nil {
obj, err = s.getFromPackfile(h, false)
if err == plumbing.ErrObjectNotFound {
obj, err = s.getFromUnpacked(h)
}
} else {
obj, err = s.getFromUnpacked(h)
if err == plumbing.ErrObjectNotFound {
obj, err = s.getFromPackfile(h, false)
}
}
// If the error is still object not found, check if it's a shared object
// repository.
if err == plumbing.ErrObjectNotFound {
dotgits, e := s.dir.Alternates()
if e == nil {
// Create a new object storage with the DotGit(s) and check for the
// required hash object. Skip when not found.
for _, dg := range dotgits {
o := NewObjectStorage(dg, s.objectCache)
enobj, enerr := o.EncodedObject(t, h)
if enerr != nil {
continue
}
return enobj, nil
}
}
}
if err != nil {
return nil, err
}
if plumbing.AnyObject != t && obj.Type() != t {
return nil, plumbing.ErrObjectNotFound
}
return obj, nil
}
// DeltaObject returns the object with the given hash, by searching for
// it in the packfile and the git object directories.
func (s *ObjectStorage) DeltaObject(t plumbing.ObjectType,
h plumbing.Hash) (plumbing.EncodedObject, error) {
obj, err := s.getFromUnpacked(h)
if err == plumbing.ErrObjectNotFound {
obj, err = s.getFromPackfile(h, true)
}
if err != nil {
return nil, err
}
if plumbing.AnyObject != t && obj.Type() != t {
return nil, plumbing.ErrObjectNotFound
}
return obj, nil
}
func (s *ObjectStorage) getFromUnpacked(h plumbing.Hash) (obj plumbing.EncodedObject, err error) {
f, err := s.dir.Object(h)
if err != nil {
if os.IsNotExist(err) {
return nil, plumbing.ErrObjectNotFound
}
return nil, err
}
defer ioutil.CheckClose(f, &err)
if cacheObj, found := s.objectCache.Get(h); found {
return cacheObj, nil
}
r, err := objfile.NewReader(f)
if err != nil {
return nil, err
}
defer ioutil.CheckClose(r, &err)
t, size, err := r.Header()
if err != nil {
return nil, err
}
if s.options.LargeObjectThreshold > 0 && size > s.options.LargeObjectThreshold {
obj = dotgit.NewEncodedObject(s.dir, h, t, size)
return obj, nil
}
obj = s.NewEncodedObject()
obj.SetType(t)
obj.SetSize(size)
w, err := obj.Writer()
if err != nil {
return nil, err
}
defer ioutil.CheckClose(w, &err)
bufp := copyBufferPool.Get().(*[]byte)
buf := *bufp
_, err = io.CopyBuffer(w, r, buf)
copyBufferPool.Put(bufp)
s.objectCache.Put(obj)
return obj, err
}
var copyBufferPool = sync.Pool{
New: func() interface{} {
b := make([]byte, 32*1024)
return &b
},
}
// Get returns the object with the given hash, by searching for it in
// the packfile.
func (s *ObjectStorage) getFromPackfile(h plumbing.Hash, canBeDelta bool) (
plumbing.EncodedObject, error) {
if err := s.requireIndex(); err != nil {
return nil, err
}
pack, hash, offset := s.findObjectInPackfile(h)
if offset == -1 {
return nil, plumbing.ErrObjectNotFound
}
idx := s.index[pack]
p, err := s.packfile(idx, pack)
if err != nil {
return nil, err
}
if !s.options.KeepDescriptors && s.options.MaxOpenDescriptors == 0 {
defer ioutil.CheckClose(p, &err)
}
if canBeDelta {
return s.decodeDeltaObjectAt(p, offset, hash)
}
return s.decodeObjectAt(p, offset)
}
func (s *ObjectStorage) decodeObjectAt(
p *packfile.Packfile,
offset int64,
) (plumbing.EncodedObject, error) {
hash, err := p.FindHash(offset)
if err == nil {
obj, ok := s.objectCache.Get(hash)
if ok {
return obj, nil
}
}
if err != nil && err != plumbing.ErrObjectNotFound {
return nil, err
}
return p.GetByOffset(offset)
}
func (s *ObjectStorage) decodeDeltaObjectAt(
p *packfile.Packfile,
offset int64,
hash plumbing.Hash,
) (plumbing.EncodedObject, error) {
scan := p.Scanner()
header, err := scan.SeekObjectHeader(offset)
if err != nil {
return nil, err
}
var (
base plumbing.Hash
)
switch header.Type {
case plumbing.REFDeltaObject:
base = header.Reference
case plumbing.OFSDeltaObject:
base, err = p.FindHash(header.OffsetReference)
if err != nil {
return nil, err
}
default:
return s.decodeObjectAt(p, offset)
}
obj := &plumbing.MemoryObject{}
obj.SetType(header.Type)
w, err := obj.Writer()
if err != nil {
return nil, err
}
if _, _, err := scan.NextObject(w); err != nil {
return nil, err
}
return newDeltaObject(obj, hash, base, header.Length), nil
}
func (s *ObjectStorage) findObjectInPackfile(h plumbing.Hash) (plumbing.Hash, plumbing.Hash, int64) {
for packfile, index := range s.index {
offset, err := index.FindOffset(h)
if err == nil {
return packfile, h, offset
}
}
return plumbing.ZeroHash, plumbing.ZeroHash, -1
}
// HashesWithPrefix returns all objects with a hash that starts with a prefix by searching for
// them in the packfile and the git object directories.
func (s *ObjectStorage) HashesWithPrefix(prefix []byte) ([]plumbing.Hash, error) {
hashes, err := s.dir.ObjectsWithPrefix(prefix)
if err != nil {
return nil, err
}
seen := hashListAsMap(hashes)
// TODO: This could be faster with some idxfile changes,
// or diving into the packfile.
if err := s.requireIndex(); err != nil {
return nil, err
}
for _, index := range s.index {
ei, err := index.Entries()
if err != nil {
return nil, err
}
for {
e, err := ei.Next()
if err == io.EOF {
break
} else if err != nil {
return nil, err
}
if bytes.HasPrefix(e.Hash[:], prefix) {
if _, ok := seen[e.Hash]; ok {
continue
}
hashes = append(hashes, e.Hash)
}
}
ei.Close()
}
return hashes, nil
}
// IterEncodedObjects returns an iterator for all the objects in the packfile
// with the given type.
func (s *ObjectStorage) IterEncodedObjects(t plumbing.ObjectType) (storer.EncodedObjectIter, error) {
objects, err := s.dir.Objects()
if err != nil {
return nil, err
}
seen := make(map[plumbing.Hash]struct{})
var iters []storer.EncodedObjectIter
if len(objects) != 0 {
iters = append(iters, &objectsIter{s: s, t: t, h: objects})
seen = hashListAsMap(objects)
}
packi, err := s.buildPackfileIters(t, seen)
if err != nil {
return nil, err
}
iters = append(iters, packi)
return storer.NewMultiEncodedObjectIter(iters), nil
}
func (s *ObjectStorage) buildPackfileIters(
t plumbing.ObjectType,
seen map[plumbing.Hash]struct{},
) (storer.EncodedObjectIter, error) {
if err := s.requireIndex(); err != nil {
return nil, err
}
packs, err := s.dir.ObjectPacks()
if err != nil {
return nil, err
}
return &lazyPackfilesIter{
hashes: packs,
open: func(h plumbing.Hash) (storer.EncodedObjectIter, error) {
pack, err := s.dir.ObjectPack(h)
if err != nil {
return nil, err
}
return newPackfileIter(
s.dir.Fs(), pack, t, seen, s.index[h],
s.objectCache, s.options.KeepDescriptors,
s.options.LargeObjectThreshold,
)
},
}, nil
}
// Close closes all opened files.
func (s *ObjectStorage) Close() error {
var firstError error
if s.options.KeepDescriptors || s.options.MaxOpenDescriptors > 0 {
for _, packfile := range s.packfiles {
err := packfile.Close()
if firstError == nil && err != nil {
firstError = err
}
}
}
s.packfiles = nil
s.dir.Close()
return firstError
}
type lazyPackfilesIter struct {
hashes []plumbing.Hash
open func(h plumbing.Hash) (storer.EncodedObjectIter, error)
cur storer.EncodedObjectIter
}
func (it *lazyPackfilesIter) Next() (plumbing.EncodedObject, error) {
for {
if it.cur == nil {
if len(it.hashes) == 0 {
return nil, io.EOF
}
h := it.hashes[0]
it.hashes = it.hashes[1:]
sub, err := it.open(h)
if err == io.EOF {
continue
} else if err != nil {
return nil, err
}
it.cur = sub
}
ob, err := it.cur.Next()
if err == io.EOF {
it.cur.Close()
it.cur = nil
continue
} else if err != nil {
return nil, err
}
return ob, nil
}
}
func (it *lazyPackfilesIter) ForEach(cb func(plumbing.EncodedObject) error) error {
return storer.ForEachIterator(it, cb)
}
func (it *lazyPackfilesIter) Close() {
if it.cur != nil {
it.cur.Close()
it.cur = nil
}
it.hashes = nil
}
type packfileIter struct {
pack billy.File
iter storer.EncodedObjectIter
seen map[plumbing.Hash]struct{}
// tells whether the pack file should be left open after iteration or not
keepPack bool
}
// NewPackfileIter returns a new EncodedObjectIter for the provided packfile
// and object type. Packfile and index file will be closed after they're
// used. If keepPack is true the packfile won't be closed after the iteration
// finished.
func NewPackfileIter(
fs billy.Filesystem,
f billy.File,
idxFile billy.File,
t plumbing.ObjectType,
keepPack bool,
largeObjectThreshold int64,
) (storer.EncodedObjectIter, error) {
idx := idxfile.NewMemoryIndex()
if err := idxfile.NewDecoder(idxFile).Decode(idx); err != nil {
return nil, err
}
if err := idxFile.Close(); err != nil {
return nil, err
}
seen := make(map[plumbing.Hash]struct{})
return newPackfileIter(fs, f, t, seen, idx, nil, keepPack, largeObjectThreshold)
}
func newPackfileIter(
fs billy.Filesystem,
f billy.File,
t plumbing.ObjectType,
seen map[plumbing.Hash]struct{},
index idxfile.Index,
cache cache.Object,
keepPack bool,
largeObjectThreshold int64,
) (storer.EncodedObjectIter, error) {
var p *packfile.Packfile
if cache != nil {
p = packfile.NewPackfileWithCache(index, fs, f, cache, largeObjectThreshold)
} else {
p = packfile.NewPackfile(index, fs, f, largeObjectThreshold)
}
iter, err := p.GetByType(t)
if err != nil {
return nil, err
}
return &packfileIter{
pack: f,
iter: iter,
seen: seen,
keepPack: keepPack,
}, nil
}
func (iter *packfileIter) Next() (plumbing.EncodedObject, error) {
for {
obj, err := iter.iter.Next()
if err != nil {
return nil, err
}
if _, ok := iter.seen[obj.Hash()]; ok {
continue
}
return obj, nil
}
}
func (iter *packfileIter) ForEach(cb func(plumbing.EncodedObject) error) error {
for {
o, err := iter.Next()
if err != nil {
if err == io.EOF {
iter.Close()
return nil
}
return err
}
if err := cb(o); err != nil {
return err
}
}
}
func (iter *packfileIter) Close() {
iter.iter.Close()
if !iter.keepPack {
_ = iter.pack.Close()
}
}
type objectsIter struct {
s *ObjectStorage
t plumbing.ObjectType
h []plumbing.Hash
}
func (iter *objectsIter) Next() (plumbing.EncodedObject, error) {
if len(iter.h) == 0 {
return nil, io.EOF
}
obj, err := iter.s.getFromUnpacked(iter.h[0])
iter.h = iter.h[1:]
if err != nil {
return nil, err
}
if iter.t != plumbing.AnyObject && iter.t != obj.Type() {
return iter.Next()
}
return obj, err
}
func (iter *objectsIter) ForEach(cb func(plumbing.EncodedObject) error) error {
for {
o, err := iter.Next()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
if err := cb(o); err != nil {
return err
}
}
}
func (iter *objectsIter) Close() {
iter.h = []plumbing.Hash{}
}
func hashListAsMap(l []plumbing.Hash) map[plumbing.Hash]struct{} {
m := make(map[plumbing.Hash]struct{}, len(l))
for _, h := range l {
m[h] = struct{}{}
}
return m
}
func (s *ObjectStorage) ForEachObjectHash(fun func(plumbing.Hash) error) error {
err := s.dir.ForEachObjectHash(fun)
if err == storer.ErrStop {
return nil
}
return err
}
func (s *ObjectStorage) LooseObjectTime(hash plumbing.Hash) (time.Time, error) {
fi, err := s.dir.ObjectStat(hash)
if err != nil {
return time.Time{}, err
}
return fi.ModTime(), nil
}
func (s *ObjectStorage) DeleteLooseObject(hash plumbing.Hash) error {
return s.dir.ObjectDelete(hash)
}
func (s *ObjectStorage) ObjectPacks() ([]plumbing.Hash, error) {
return s.dir.ObjectPacks()
}
func (s *ObjectStorage) DeleteOldObjectPackAndIndex(h plumbing.Hash, t time.Time) error {
return s.dir.DeleteOldObjectPackAndIndex(h, t)
}
go-git-5.13.2/storage/filesystem/object_test.go 0000664 0000000 0000000 00000042157 14744245500 0021472 0 ustar 00root root 0000000 0000000 package filesystem
import (
"encoding/hex"
"fmt"
"io"
"os"
"path/filepath"
"testing"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/storage/filesystem/dotgit"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type FsSuite struct {
fixtures.Suite
}
var objectTypes = []plumbing.ObjectType{
plumbing.CommitObject,
plumbing.TagObject,
plumbing.TreeObject,
plumbing.BlobObject,
}
var _ = Suite(&FsSuite{})
func (s *FsSuite) TestGetFromObjectFile(c *C) {
fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit()
o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault())
expected := plumbing.NewHash("f3dfe29d268303fc6e1bbce268605fc99573406e")
obj, err := o.EncodedObject(plumbing.AnyObject, expected)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
}
func (s *FsSuite) TestGetFromPackfile(c *C) {
fixtures.Basic().ByTag(".git").Test(c, func(f *fixtures.Fixture) {
fs := f.DotGit()
o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault())
expected := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
obj, err := o.EncodedObject(plumbing.AnyObject, expected)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
})
}
func (s *FsSuite) TestGetFromPackfileKeepDescriptors(c *C) {
fixtures.Basic().ByTag(".git").Test(c, func(f *fixtures.Fixture) {
fs := f.DotGit()
dg := dotgit.NewWithOptions(fs, dotgit.Options{KeepDescriptors: true})
o := NewObjectStorageWithOptions(dg, cache.NewObjectLRUDefault(), Options{KeepDescriptors: true})
expected := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
obj, err := o.EncodedObject(plumbing.AnyObject, expected)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
packfiles, err := dg.ObjectPacks()
c.Assert(err, IsNil)
pack1, err := dg.ObjectPack(packfiles[0])
c.Assert(err, IsNil)
pack1.Seek(42, io.SeekStart)
err = o.Close()
c.Assert(err, IsNil)
pack2, err := dg.ObjectPack(packfiles[0])
c.Assert(err, IsNil)
offset, err := pack2.Seek(0, io.SeekCurrent)
c.Assert(err, IsNil)
c.Assert(offset, Equals, int64(0))
err = o.Close()
c.Assert(err, IsNil)
})
}
func (s *FsSuite) TestGetFromPackfileMaxOpenDescriptors(c *C) {
fs := fixtures.ByTag(".git").ByTag("multi-packfile").One().DotGit()
o := NewObjectStorageWithOptions(dotgit.New(fs), cache.NewObjectLRUDefault(), Options{MaxOpenDescriptors: 1})
expected := plumbing.NewHash("8d45a34641d73851e01d3754320b33bb5be3c4d3")
obj, err := o.getFromPackfile(expected, false)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
expected = plumbing.NewHash("e9cfa4c9ca160546efd7e8582ec77952a27b17db")
obj, err = o.getFromPackfile(expected, false)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
err = o.Close()
c.Assert(err, IsNil)
}
func (s *FsSuite) TestGetFromPackfileMaxOpenDescriptorsLargeObjectThreshold(c *C) {
fs := fixtures.ByTag(".git").ByTag("multi-packfile").One().DotGit()
o := NewObjectStorageWithOptions(dotgit.New(fs), cache.NewObjectLRUDefault(), Options{
MaxOpenDescriptors: 1,
LargeObjectThreshold: 1,
})
expected := plumbing.NewHash("8d45a34641d73851e01d3754320b33bb5be3c4d3")
obj, err := o.getFromPackfile(expected, false)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
expected = plumbing.NewHash("e9cfa4c9ca160546efd7e8582ec77952a27b17db")
obj, err = o.getFromPackfile(expected, false)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
err = o.Close()
c.Assert(err, IsNil)
}
func (s *FsSuite) TestGetSizeOfObjectFile(c *C) {
fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit()
o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault())
// Get the size of `tree_walker.go`.
expected := plumbing.NewHash("cbd81c47be12341eb1185b379d1c82675aeded6a")
size, err := o.EncodedObjectSize(expected)
c.Assert(err, IsNil)
c.Assert(size, Equals, int64(2412))
}
func (s *FsSuite) TestGetSizeFromPackfile(c *C) {
fixtures.Basic().ByTag(".git").Test(c, func(f *fixtures.Fixture) {
fs := f.DotGit()
o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault())
// Get the size of `binary.jpg`.
expected := plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d")
size, err := o.EncodedObjectSize(expected)
c.Assert(err, IsNil)
c.Assert(size, Equals, int64(76110))
})
}
func (s *FsSuite) TestGetSizeOfAllObjectFiles(c *C) {
fs := fixtures.ByTag(".git").One().DotGit()
o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault())
// Get the size of `tree_walker.go`.
err := o.ForEachObjectHash(func(h plumbing.Hash) error {
size, err := o.EncodedObjectSize(h)
c.Assert(err, IsNil)
c.Assert(size, Not(Equals), int64(0))
return nil
})
c.Assert(err, IsNil)
}
func (s *FsSuite) TestGetFromPackfileMultiplePackfiles(c *C) {
fs := fixtures.ByTag(".git").ByTag("multi-packfile").One().DotGit()
o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault())
expected := plumbing.NewHash("8d45a34641d73851e01d3754320b33bb5be3c4d3")
obj, err := o.getFromPackfile(expected, false)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
expected = plumbing.NewHash("e9cfa4c9ca160546efd7e8582ec77952a27b17db")
obj, err = o.getFromPackfile(expected, false)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
}
func (s *FsSuite) TestGetFromPackfileMultiplePackfilesLargeObjectThreshold(c *C) {
fs := fixtures.ByTag(".git").ByTag("multi-packfile").One().DotGit()
o := NewObjectStorageWithOptions(dotgit.New(fs), cache.NewObjectLRUDefault(), Options{LargeObjectThreshold: 1})
expected := plumbing.NewHash("8d45a34641d73851e01d3754320b33bb5be3c4d3")
obj, err := o.getFromPackfile(expected, false)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
expected = plumbing.NewHash("e9cfa4c9ca160546efd7e8582ec77952a27b17db")
obj, err = o.getFromPackfile(expected, false)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
}
func (s *FsSuite) TestIter(c *C) {
fixtures.ByTag(".git").ByTag("packfile").Test(c, func(f *fixtures.Fixture) {
fs := f.DotGit()
o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault())
iter, err := o.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
var count int32
err = iter.ForEach(func(o plumbing.EncodedObject) error {
count++
return nil
})
c.Assert(err, IsNil)
c.Assert(count, Equals, f.ObjectsCount)
})
}
func (s *FsSuite) TestIterLargeObjectThreshold(c *C) {
fixtures.ByTag(".git").ByTag("packfile").Test(c, func(f *fixtures.Fixture) {
fs := f.DotGit()
o := NewObjectStorageWithOptions(dotgit.New(fs), cache.NewObjectLRUDefault(), Options{LargeObjectThreshold: 1})
iter, err := o.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
var count int32
err = iter.ForEach(func(o plumbing.EncodedObject) error {
count++
return nil
})
c.Assert(err, IsNil)
c.Assert(count, Equals, f.ObjectsCount)
})
}
func (s *FsSuite) TestIterWithType(c *C) {
fixtures.ByTag(".git").Test(c, func(f *fixtures.Fixture) {
for _, t := range objectTypes {
fs := f.DotGit()
o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault())
iter, err := o.IterEncodedObjects(t)
c.Assert(err, IsNil)
err = iter.ForEach(func(o plumbing.EncodedObject) error {
c.Assert(o.Type(), Equals, t)
return nil
})
c.Assert(err, IsNil)
}
})
}
func (s *FsSuite) TestPackfileIter(c *C) {
fixtures.ByTag(".git").Test(c, func(f *fixtures.Fixture) {
fs := f.DotGit()
dg := dotgit.New(fs)
for _, t := range objectTypes {
ph, err := dg.ObjectPacks()
c.Assert(err, IsNil)
for _, h := range ph {
f, err := dg.ObjectPack(h)
c.Assert(err, IsNil)
idxf, err := dg.ObjectPackIdx(h)
c.Assert(err, IsNil)
iter, err := NewPackfileIter(fs, f, idxf, t, false, 0)
c.Assert(err, IsNil)
err = iter.ForEach(func(o plumbing.EncodedObject) error {
c.Assert(o.Type(), Equals, t)
return nil
})
c.Assert(err, IsNil)
}
}
})
}
func copyFile(c *C, dstDir, dstFilename string, srcFile billy.File) {
_, err := srcFile.Seek(0, 0)
c.Assert(err, IsNil)
err = osfs.Default.MkdirAll(dstDir, 0750|os.ModeDir)
c.Assert(err, IsNil)
dst, err := osfs.Default.OpenFile(filepath.Join(dstDir, dstFilename), os.O_CREATE|os.O_WRONLY, 0666)
c.Assert(err, IsNil)
defer dst.Close()
_, err = io.Copy(dst, srcFile)
c.Assert(err, IsNil)
}
// TestPackfileReindex tests that externally-added packfiles are considered by go-git
// after calling the Reindex method
func (s *FsSuite) TestPackfileReindex(c *C) {
// obtain a standalone packfile that is not part of any other repository
// in the fixtures:
packFixture := fixtures.ByTag("packfile").ByTag("standalone").One()
packFile := packFixture.Packfile()
idxFile := packFixture.Idx()
packFilename := packFixture.PackfileHash
testObjectHash := plumbing.NewHash("a771b1e94141480861332fd0e4684d33071306c6") // this is an object we know exists in the standalone packfile
fixtures.ByTag(".git").Test(c, func(f *fixtures.Fixture) {
fs := f.DotGit()
storer := NewStorage(fs, cache.NewObjectLRUDefault())
// check that our test object is NOT found
_, err := storer.EncodedObject(plumbing.CommitObject, testObjectHash)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
// add the external packfile+idx to the packs folder
// this simulates a git bundle unbundle command, or a repack, for example.
copyFile(c, filepath.Join(storer.Filesystem().Root(), "objects", "pack"),
fmt.Sprintf("pack-%s.pack", packFilename), packFile)
copyFile(c, filepath.Join(storer.Filesystem().Root(), "objects", "pack"),
fmt.Sprintf("pack-%s.idx", packFilename), idxFile)
// check that we cannot still retrieve the test object
_, err = storer.EncodedObject(plumbing.CommitObject, testObjectHash)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
storer.Reindex() // actually reindex
// Now check that the test object can be retrieved
_, err = storer.EncodedObject(plumbing.CommitObject, testObjectHash)
c.Assert(err, IsNil)
})
}
func (s *FsSuite) TestPackfileIterKeepDescriptors(c *C) {
fixtures.ByTag(".git").Test(c, func(f *fixtures.Fixture) {
fs := f.DotGit()
ops := dotgit.Options{KeepDescriptors: true}
dg := dotgit.NewWithOptions(fs, ops)
for _, t := range objectTypes {
ph, err := dg.ObjectPacks()
c.Assert(err, IsNil)
for _, h := range ph {
f, err := dg.ObjectPack(h)
c.Assert(err, IsNil)
idxf, err := dg.ObjectPackIdx(h)
c.Assert(err, IsNil)
iter, err := NewPackfileIter(fs, f, idxf, t, true, 0)
c.Assert(err, IsNil)
err = iter.ForEach(func(o plumbing.EncodedObject) error {
c.Assert(o.Type(), Equals, t)
return nil
})
c.Assert(err, IsNil)
// test twice to check that packfiles are not closed
err = iter.ForEach(func(o plumbing.EncodedObject) error {
c.Assert(o.Type(), Equals, t)
return nil
})
c.Assert(err, IsNil)
}
}
})
}
func (s *FsSuite) TestGetFromObjectFileSharedCache(c *C) {
f1 := fixtures.ByTag("worktree").One().DotGit()
f2 := fixtures.ByTag("worktree").ByTag("submodule").One().DotGit()
ch := cache.NewObjectLRUDefault()
o1 := NewObjectStorage(dotgit.New(f1), ch)
o2 := NewObjectStorage(dotgit.New(f2), ch)
expected := plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a")
obj, err := o1.EncodedObject(plumbing.CommitObject, expected)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
_, err = o2.EncodedObject(plumbing.CommitObject, expected)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
}
func (s *FsSuite) TestHashesWithPrefix(c *C) {
// Same setup as TestGetFromObjectFile.
fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit()
o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault())
expected := plumbing.NewHash("f3dfe29d268303fc6e1bbce268605fc99573406e")
obj, err := o.EncodedObject(plumbing.AnyObject, expected)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
prefix, _ := hex.DecodeString("f3dfe2")
hashes, err := o.HashesWithPrefix(prefix)
c.Assert(err, IsNil)
c.Assert(hashes, HasLen, 1)
c.Assert(hashes[0].String(), Equals, "f3dfe29d268303fc6e1bbce268605fc99573406e")
}
func (s *FsSuite) TestHashesWithPrefixFromPackfile(c *C) {
// Same setup as TestGetFromPackfile
fixtures.Basic().ByTag(".git").Test(c, func(f *fixtures.Fixture) {
fs := f.DotGit()
o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault())
expected := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
// Only pass the first 8 bytes
hashes, err := o.HashesWithPrefix(expected[:8])
c.Assert(err, IsNil)
c.Assert(hashes, HasLen, 1)
c.Assert(hashes[0], Equals, expected)
})
}
func BenchmarkPackfileIter(b *testing.B) {
defer fixtures.Clean()
for _, f := range fixtures.ByTag(".git") {
b.Run(f.URL, func(b *testing.B) {
fs := f.DotGit()
dg := dotgit.New(fs)
for i := 0; i < b.N; i++ {
for _, t := range objectTypes {
ph, err := dg.ObjectPacks()
if err != nil {
b.Fatal(err)
}
for _, h := range ph {
f, err := dg.ObjectPack(h)
if err != nil {
b.Fatal(err)
}
idxf, err := dg.ObjectPackIdx(h)
if err != nil {
b.Fatal(err)
}
iter, err := NewPackfileIter(fs, f, idxf, t, false, 0)
if err != nil {
b.Fatal(err)
}
err = iter.ForEach(func(o plumbing.EncodedObject) error {
if o.Type() != t {
b.Errorf("expecting %s, got %s", t, o.Type())
}
return nil
})
if err != nil {
b.Fatal(err)
}
}
}
}
})
}
}
func BenchmarkPackfileIterReadContent(b *testing.B) {
defer fixtures.Clean()
for _, f := range fixtures.ByTag(".git") {
b.Run(f.URL, func(b *testing.B) {
fs := f.DotGit()
dg := dotgit.New(fs)
for i := 0; i < b.N; i++ {
for _, t := range objectTypes {
ph, err := dg.ObjectPacks()
if err != nil {
b.Fatal(err)
}
for _, h := range ph {
f, err := dg.ObjectPack(h)
if err != nil {
b.Fatal(err)
}
idxf, err := dg.ObjectPackIdx(h)
if err != nil {
b.Fatal(err)
}
iter, err := NewPackfileIter(fs, f, idxf, t, false, 0)
if err != nil {
b.Fatal(err)
}
err = iter.ForEach(func(o plumbing.EncodedObject) error {
if o.Type() != t {
b.Errorf("expecting %s, got %s", t, o.Type())
}
r, err := o.Reader()
if err != nil {
b.Fatal(err)
}
if _, err := io.ReadAll(r); err != nil {
b.Fatal(err)
}
return r.Close()
})
if err != nil {
b.Fatal(err)
}
}
}
}
})
}
}
func BenchmarkGetObjectFromPackfile(b *testing.B) {
defer fixtures.Clean()
for _, f := range fixtures.Basic() {
b.Run(f.URL, func(b *testing.B) {
fs := f.DotGit()
o := NewObjectStorage(dotgit.New(fs), cache.NewObjectLRUDefault())
for i := 0; i < b.N; i++ {
expected := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
obj, err := o.EncodedObject(plumbing.AnyObject, expected)
if err != nil {
b.Fatal(err)
}
if obj.Hash() != expected {
b.Errorf("expecting %s, got %s", expected, obj.Hash())
}
}
})
}
}
func (s *FsSuite) TestGetFromUnpackedCachesObjects(c *C) {
fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit()
objectCache := cache.NewObjectLRUDefault()
objectStorage := NewObjectStorage(dotgit.New(fs), objectCache)
hash := plumbing.NewHash("f3dfe29d268303fc6e1bbce268605fc99573406e")
// Assert the cache is empty initially
_, ok := objectCache.Get(hash)
c.Assert(ok, Equals, false)
// Load the object
obj, err := objectStorage.EncodedObject(plumbing.AnyObject, hash)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, hash)
// The object should've been cached during the load
cachedObj, ok := objectCache.Get(hash)
c.Assert(ok, Equals, true)
c.Assert(cachedObj, DeepEquals, obj)
// Assert that both objects can be read and that they both produce the same bytes
objReader, err := obj.Reader()
c.Assert(err, IsNil)
objBytes, err := io.ReadAll(objReader)
c.Assert(err, IsNil)
c.Assert(len(objBytes), Not(Equals), 0)
err = objReader.Close()
c.Assert(err, IsNil)
cachedObjReader, err := cachedObj.Reader()
c.Assert(err, IsNil)
cachedObjBytes, err := io.ReadAll(cachedObjReader)
c.Assert(len(cachedObjBytes), Not(Equals), 0)
c.Assert(err, IsNil)
err = cachedObjReader.Close()
c.Assert(err, IsNil)
c.Assert(cachedObjBytes, DeepEquals, objBytes)
}
func (s *FsSuite) TestGetFromUnpackedDoesNotCacheLargeObjects(c *C) {
fs := fixtures.ByTag(".git").ByTag("unpacked").One().DotGit()
objectCache := cache.NewObjectLRUDefault()
objectStorage := NewObjectStorageWithOptions(dotgit.New(fs), objectCache, Options{LargeObjectThreshold: 1})
hash := plumbing.NewHash("f3dfe29d268303fc6e1bbce268605fc99573406e")
// Assert the cache is empty initially
_, ok := objectCache.Get(hash)
c.Assert(ok, Equals, false)
// Load the object
obj, err := objectStorage.EncodedObject(plumbing.AnyObject, hash)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, hash)
// The object should not have been cached during the load
_, ok = objectCache.Get(hash)
c.Assert(ok, Equals, false)
}
go-git-5.13.2/storage/filesystem/reference.go 0000664 0000000 0000000 00000002021 14744245500 0021105 0 ustar 00root root 0000000 0000000 package filesystem
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/filesystem/dotgit"
)
type ReferenceStorage struct {
dir *dotgit.DotGit
}
func (r *ReferenceStorage) SetReference(ref *plumbing.Reference) error {
return r.dir.SetRef(ref, nil)
}
func (r *ReferenceStorage) CheckAndSetReference(ref, old *plumbing.Reference) error {
return r.dir.SetRef(ref, old)
}
func (r *ReferenceStorage) Reference(n plumbing.ReferenceName) (*plumbing.Reference, error) {
return r.dir.Ref(n)
}
func (r *ReferenceStorage) IterReferences() (storer.ReferenceIter, error) {
refs, err := r.dir.Refs()
if err != nil {
return nil, err
}
return storer.NewReferenceSliceIter(refs), nil
}
func (r *ReferenceStorage) RemoveReference(n plumbing.ReferenceName) error {
return r.dir.RemoveRef(n)
}
func (r *ReferenceStorage) CountLooseRefs() (int, error) {
return r.dir.CountLooseRefs()
}
func (r *ReferenceStorage) PackRefs() error {
return r.dir.PackRefs()
}
go-git-5.13.2/storage/filesystem/shallow.go 0000664 0000000 0000000 00000002266 14744245500 0020633 0 ustar 00root root 0000000 0000000 package filesystem
import (
"bufio"
"fmt"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/storage/filesystem/dotgit"
"github.com/go-git/go-git/v5/utils/ioutil"
)
// ShallowStorage where the shallow commits are stored, an internal to
// manipulate the shallow file
type ShallowStorage struct {
dir *dotgit.DotGit
}
// SetShallow save the shallows in the shallow file in the .git folder as one
// commit per line represented by 40-byte hexadecimal object terminated by a
// newline.
func (s *ShallowStorage) SetShallow(commits []plumbing.Hash) error {
f, err := s.dir.ShallowWriter()
if err != nil {
return err
}
defer ioutil.CheckClose(f, &err)
for _, h := range commits {
if _, err := fmt.Fprintf(f, "%s\n", h); err != nil {
return err
}
}
return err
}
// Shallow returns the shallow commits reading from shallo file from .git
func (s *ShallowStorage) Shallow() ([]plumbing.Hash, error) {
f, err := s.dir.Shallow()
if f == nil || err != nil {
return nil, err
}
defer ioutil.CheckClose(f, &err)
var hash []plumbing.Hash
scn := bufio.NewScanner(f)
for scn.Scan() {
hash = append(hash, plumbing.NewHash(scn.Text()))
}
return hash, scn.Err()
}
go-git-5.13.2/storage/filesystem/storage.go 0000664 0000000 0000000 00000005204 14744245500 0020621 0 ustar 00root root 0000000 0000000 // Package filesystem is a storage backend base on filesystems
package filesystem
import (
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/storage/filesystem/dotgit"
"github.com/go-git/go-billy/v5"
)
// Storage is an implementation of git.Storer that stores data on disk in the
// standard git format (this is, the .git directory). Zero values of this type
// are not safe to use, see the NewStorage function below.
type Storage struct {
fs billy.Filesystem
dir *dotgit.DotGit
ObjectStorage
ReferenceStorage
IndexStorage
ShallowStorage
ConfigStorage
ModuleStorage
}
// Options holds configuration for the storage.
type Options struct {
// ExclusiveAccess means that the filesystem is not modified externally
// while the repo is open.
ExclusiveAccess bool
// KeepDescriptors makes the file descriptors to be reused but they will
// need to be manually closed calling Close().
KeepDescriptors bool
// MaxOpenDescriptors is the max number of file descriptors to keep
// open. If KeepDescriptors is true, all file descriptors will remain open.
MaxOpenDescriptors int
// LargeObjectThreshold maximum object size (in bytes) that will be read in to memory.
// If left unset or set to 0 there is no limit
LargeObjectThreshold int64
// AlternatesFS provides the billy filesystem to be used for Git Alternates.
// If none is provided, it falls back to using the underlying instance used for
// DotGit.
AlternatesFS billy.Filesystem
}
// NewStorage returns a new Storage backed by a given `fs.Filesystem` and cache.
func NewStorage(fs billy.Filesystem, cache cache.Object) *Storage {
return NewStorageWithOptions(fs, cache, Options{})
}
// NewStorageWithOptions returns a new Storage with extra options,
// backed by a given `fs.Filesystem` and cache.
func NewStorageWithOptions(fs billy.Filesystem, cache cache.Object, ops Options) *Storage {
dirOps := dotgit.Options{
ExclusiveAccess: ops.ExclusiveAccess,
AlternatesFS: ops.AlternatesFS,
}
dir := dotgit.NewWithOptions(fs, dirOps)
return &Storage{
fs: fs,
dir: dir,
ObjectStorage: *NewObjectStorageWithOptions(dir, cache, ops),
ReferenceStorage: ReferenceStorage{dir: dir},
IndexStorage: IndexStorage{dir: dir},
ShallowStorage: ShallowStorage{dir: dir},
ConfigStorage: ConfigStorage{dir: dir},
ModuleStorage: ModuleStorage{dir: dir},
}
}
// Filesystem returns the underlying filesystem
func (s *Storage) Filesystem() billy.Filesystem {
return s.fs
}
// Init initializes .git directory
func (s *Storage) Init() error {
return s.dir.Initialize()
}
func (s *Storage) AddAlternate(remote string) error {
return s.dir.AddAlternate(remote)
}
go-git-5.13.2/storage/filesystem/storage_test.go 0000664 0000000 0000000 00000003617 14744245500 0021666 0 ustar 00root root 0000000 0000000 package filesystem
import (
"testing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/test"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-billy/v5/util"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type StorageSuite struct {
test.BaseStorageSuite
dir string
fs billy.Filesystem
}
var _ = Suite(&StorageSuite{})
func (s *StorageSuite) SetUpTest(c *C) {
tmp, err := util.TempDir(osfs.Default, "", "go-git-filestystem-config")
c.Assert(err, IsNil)
s.dir = tmp
s.fs = osfs.New(s.dir)
storage := NewStorage(s.fs, cache.NewObjectLRUDefault())
setUpTest(s, c, storage)
}
func setUpTest(s *StorageSuite, c *C, storage *Storage) {
// ensure that right interfaces are implemented
var _ storer.EncodedObjectStorer = storage
var _ storer.IndexStorer = storage
var _ storer.ReferenceStorer = storage
var _ storer.ShallowStorer = storage
var _ storer.DeltaObjectStorer = storage
var _ storer.PackfileWriter = storage
s.BaseStorageSuite = test.NewBaseStorageSuite(storage)
}
func (s *StorageSuite) TestFilesystem(c *C) {
fs := memfs.New()
storage := NewStorage(fs, cache.NewObjectLRUDefault())
c.Assert(storage.Filesystem(), Equals, fs)
}
func (s *StorageSuite) TestNewStorageShouldNotAddAnyContentsToDir(c *C) {
fis, err := s.fs.ReadDir("/")
c.Assert(err, IsNil)
c.Assert(fis, HasLen, 0)
}
type StorageExclusiveSuite struct {
StorageSuite
}
var _ = Suite(&StorageExclusiveSuite{})
func (s *StorageExclusiveSuite) SetUpTest(c *C) {
tmp, err := util.TempDir(osfs.Default, "", "go-git-filestystem-config")
c.Assert(err, IsNil)
s.dir = tmp
s.fs = osfs.New(s.dir)
storage := NewStorageWithOptions(
s.fs,
cache.NewObjectLRUDefault(),
Options{ExclusiveAccess: true})
setUpTest(&s.StorageSuite, c, storage)
}
go-git-5.13.2/storage/memory/ 0000775 0000000 0000000 00000000000 14744245500 0015751 5 ustar 00root root 0000000 0000000 go-git-5.13.2/storage/memory/storage.go 0000664 0000000 0000000 00000016612 14744245500 0017752 0 ustar 00root root 0000000 0000000 // Package memory is a storage backend base on memory
package memory
import (
"fmt"
"time"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/index"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage"
)
var ErrUnsupportedObjectType = fmt.Errorf("unsupported object type")
// Storage is an implementation of git.Storer that stores data on memory, being
// ephemeral. The use of this storage should be done in controlled environments,
// since the representation in memory of some repository can fill the machine
// memory. in the other hand this storage has the best performance.
type Storage struct {
ConfigStorage
ObjectStorage
ShallowStorage
IndexStorage
ReferenceStorage
ModuleStorage
}
// NewStorage returns a new Storage base on memory
func NewStorage() *Storage {
return &Storage{
ReferenceStorage: make(ReferenceStorage),
ConfigStorage: ConfigStorage{},
ShallowStorage: ShallowStorage{},
ObjectStorage: ObjectStorage{
Objects: make(map[plumbing.Hash]plumbing.EncodedObject),
Commits: make(map[plumbing.Hash]plumbing.EncodedObject),
Trees: make(map[plumbing.Hash]plumbing.EncodedObject),
Blobs: make(map[plumbing.Hash]plumbing.EncodedObject),
Tags: make(map[plumbing.Hash]plumbing.EncodedObject),
},
ModuleStorage: make(ModuleStorage),
}
}
type ConfigStorage struct {
config *config.Config
}
func (c *ConfigStorage) SetConfig(cfg *config.Config) error {
if err := cfg.Validate(); err != nil {
return err
}
c.config = cfg
return nil
}
func (c *ConfigStorage) Config() (*config.Config, error) {
if c.config == nil {
c.config = config.NewConfig()
}
return c.config, nil
}
type IndexStorage struct {
index *index.Index
}
func (c *IndexStorage) SetIndex(idx *index.Index) error {
c.index = idx
return nil
}
func (c *IndexStorage) Index() (*index.Index, error) {
if c.index == nil {
c.index = &index.Index{Version: 2}
}
return c.index, nil
}
type ObjectStorage struct {
Objects map[plumbing.Hash]plumbing.EncodedObject
Commits map[plumbing.Hash]plumbing.EncodedObject
Trees map[plumbing.Hash]plumbing.EncodedObject
Blobs map[plumbing.Hash]plumbing.EncodedObject
Tags map[plumbing.Hash]plumbing.EncodedObject
}
func (o *ObjectStorage) NewEncodedObject() plumbing.EncodedObject {
return &plumbing.MemoryObject{}
}
func (o *ObjectStorage) SetEncodedObject(obj plumbing.EncodedObject) (plumbing.Hash, error) {
h := obj.Hash()
o.Objects[h] = obj
switch obj.Type() {
case plumbing.CommitObject:
o.Commits[h] = o.Objects[h]
case plumbing.TreeObject:
o.Trees[h] = o.Objects[h]
case plumbing.BlobObject:
o.Blobs[h] = o.Objects[h]
case plumbing.TagObject:
o.Tags[h] = o.Objects[h]
default:
return h, ErrUnsupportedObjectType
}
return h, nil
}
func (o *ObjectStorage) HasEncodedObject(h plumbing.Hash) (err error) {
if _, ok := o.Objects[h]; !ok {
return plumbing.ErrObjectNotFound
}
return nil
}
func (o *ObjectStorage) EncodedObjectSize(h plumbing.Hash) (
size int64, err error) {
obj, ok := o.Objects[h]
if !ok {
return 0, plumbing.ErrObjectNotFound
}
return obj.Size(), nil
}
func (o *ObjectStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (plumbing.EncodedObject, error) {
obj, ok := o.Objects[h]
if !ok || (plumbing.AnyObject != t && obj.Type() != t) {
return nil, plumbing.ErrObjectNotFound
}
return obj, nil
}
func (o *ObjectStorage) IterEncodedObjects(t plumbing.ObjectType) (storer.EncodedObjectIter, error) {
var series []plumbing.EncodedObject
switch t {
case plumbing.AnyObject:
series = flattenObjectMap(o.Objects)
case plumbing.CommitObject:
series = flattenObjectMap(o.Commits)
case plumbing.TreeObject:
series = flattenObjectMap(o.Trees)
case plumbing.BlobObject:
series = flattenObjectMap(o.Blobs)
case plumbing.TagObject:
series = flattenObjectMap(o.Tags)
}
return storer.NewEncodedObjectSliceIter(series), nil
}
func flattenObjectMap(m map[plumbing.Hash]plumbing.EncodedObject) []plumbing.EncodedObject {
objects := make([]plumbing.EncodedObject, 0, len(m))
for _, obj := range m {
objects = append(objects, obj)
}
return objects
}
func (o *ObjectStorage) Begin() storer.Transaction {
return &TxObjectStorage{
Storage: o,
Objects: make(map[plumbing.Hash]plumbing.EncodedObject),
}
}
func (o *ObjectStorage) ForEachObjectHash(fun func(plumbing.Hash) error) error {
for h := range o.Objects {
err := fun(h)
if err != nil {
if err == storer.ErrStop {
return nil
}
return err
}
}
return nil
}
func (o *ObjectStorage) ObjectPacks() ([]plumbing.Hash, error) {
return nil, nil
}
func (o *ObjectStorage) DeleteOldObjectPackAndIndex(plumbing.Hash, time.Time) error {
return nil
}
var errNotSupported = fmt.Errorf("not supported")
func (o *ObjectStorage) LooseObjectTime(hash plumbing.Hash) (time.Time, error) {
return time.Time{}, errNotSupported
}
func (o *ObjectStorage) DeleteLooseObject(plumbing.Hash) error {
return errNotSupported
}
func (o *ObjectStorage) AddAlternate(remote string) error {
return errNotSupported
}
type TxObjectStorage struct {
Storage *ObjectStorage
Objects map[plumbing.Hash]plumbing.EncodedObject
}
func (tx *TxObjectStorage) SetEncodedObject(obj plumbing.EncodedObject) (plumbing.Hash, error) {
h := obj.Hash()
tx.Objects[h] = obj
return h, nil
}
func (tx *TxObjectStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (plumbing.EncodedObject, error) {
obj, ok := tx.Objects[h]
if !ok || (plumbing.AnyObject != t && obj.Type() != t) {
return nil, plumbing.ErrObjectNotFound
}
return obj, nil
}
func (tx *TxObjectStorage) Commit() error {
for h, obj := range tx.Objects {
delete(tx.Objects, h)
if _, err := tx.Storage.SetEncodedObject(obj); err != nil {
return err
}
}
return nil
}
func (tx *TxObjectStorage) Rollback() error {
tx.Objects = make(map[plumbing.Hash]plumbing.EncodedObject)
return nil
}
type ReferenceStorage map[plumbing.ReferenceName]*plumbing.Reference
func (r ReferenceStorage) SetReference(ref *plumbing.Reference) error {
if ref != nil {
r[ref.Name()] = ref
}
return nil
}
func (r ReferenceStorage) CheckAndSetReference(ref, old *plumbing.Reference) error {
if ref == nil {
return nil
}
if old != nil {
tmp := r[ref.Name()]
if tmp != nil && tmp.Hash() != old.Hash() {
return storage.ErrReferenceHasChanged
}
}
r[ref.Name()] = ref
return nil
}
func (r ReferenceStorage) Reference(n plumbing.ReferenceName) (*plumbing.Reference, error) {
ref, ok := r[n]
if !ok {
return nil, plumbing.ErrReferenceNotFound
}
return ref, nil
}
func (r ReferenceStorage) IterReferences() (storer.ReferenceIter, error) {
var refs []*plumbing.Reference
for _, ref := range r {
refs = append(refs, ref)
}
return storer.NewReferenceSliceIter(refs), nil
}
func (r ReferenceStorage) CountLooseRefs() (int, error) {
return len(r), nil
}
func (r ReferenceStorage) PackRefs() error {
return nil
}
func (r ReferenceStorage) RemoveReference(n plumbing.ReferenceName) error {
delete(r, n)
return nil
}
type ShallowStorage []plumbing.Hash
func (s *ShallowStorage) SetShallow(commits []plumbing.Hash) error {
*s = commits
return nil
}
func (s ShallowStorage) Shallow() ([]plumbing.Hash, error) {
return s, nil
}
type ModuleStorage map[string]*Storage
func (s ModuleStorage) Module(name string) (storage.Storer, error) {
if m, ok := s[name]; ok {
return m, nil
}
m := NewStorage()
s[name] = m
return m, nil
}
go-git-5.13.2/storage/memory/storage_test.go 0000664 0000000 0000000 00000000521 14744245500 0021001 0 ustar 00root root 0000000 0000000 package memory
import (
"testing"
"github.com/go-git/go-git/v5/storage/test"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type StorageSuite struct {
test.BaseStorageSuite
}
var _ = Suite(&StorageSuite{})
func (s *StorageSuite) SetUpTest(c *C) {
s.BaseStorageSuite = test.NewBaseStorageSuite(NewStorage())
}
go-git-5.13.2/storage/storer.go 0000664 0000000 0000000 00000001570 14744245500 0016311 0 ustar 00root root 0000000 0000000 package storage
import (
"errors"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing/storer"
)
var ErrReferenceHasChanged = errors.New("reference has changed concurrently")
// Storer is a generic storage of objects, references and any information
// related to a particular repository. The package github.com/go-git/go-git/v5/storage
// contains two implementation a filesystem base implementation (such as `.git`)
// and a memory implementations being ephemeral
type Storer interface {
storer.EncodedObjectStorer
storer.ReferenceStorer
storer.ShallowStorer
storer.IndexStorer
config.ConfigStorer
ModuleStorer
}
// ModuleStorer allows interact with the modules' Storers
type ModuleStorer interface {
// Module returns a Storer representing a submodule, if not exists returns a
// new empty Storer is returned
Module(name string) (Storer, error)
}
go-git-5.13.2/storage/test/ 0000775 0000000 0000000 00000000000 14744245500 0015420 5 ustar 00root root 0000000 0000000 go-git-5.13.2/storage/test/storage_suite.go 0000664 0000000 0000000 00000033157 14744245500 0020635 0 ustar 00root root 0000000 0000000 package test
import (
"encoding/hex"
"errors"
"fmt"
"io"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/index"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type Storer interface {
storer.EncodedObjectStorer
storer.ReferenceStorer
storer.ShallowStorer
storer.IndexStorer
config.ConfigStorer
storage.ModuleStorer
}
type TestObject struct {
Object plumbing.EncodedObject
Hash string
Type plumbing.ObjectType
}
type BaseStorageSuite struct {
Storer Storer
validTypes []plumbing.ObjectType
testObjects map[plumbing.ObjectType]TestObject
}
func NewBaseStorageSuite(s Storer) BaseStorageSuite {
commit := &plumbing.MemoryObject{}
commit.SetType(plumbing.CommitObject)
tree := &plumbing.MemoryObject{}
tree.SetType(plumbing.TreeObject)
blob := &plumbing.MemoryObject{}
blob.SetType(plumbing.BlobObject)
tag := &plumbing.MemoryObject{}
tag.SetType(plumbing.TagObject)
return BaseStorageSuite{
Storer: s,
validTypes: []plumbing.ObjectType{
plumbing.CommitObject,
plumbing.BlobObject,
plumbing.TagObject,
plumbing.TreeObject,
},
testObjects: map[plumbing.ObjectType]TestObject{
plumbing.CommitObject: {commit, "dcf5b16e76cce7425d0beaef62d79a7d10fce1f5", plumbing.CommitObject},
plumbing.TreeObject: {tree, "4b825dc642cb6eb9a060e54bf8d69288fbee4904", plumbing.TreeObject},
plumbing.BlobObject: {blob, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", plumbing.BlobObject},
plumbing.TagObject: {tag, "d994c6bb648123a17e8f70a966857c546b2a6f94", plumbing.TagObject},
}}
}
func (s *BaseStorageSuite) TearDownTest(c *C) {
fixtures.Clean()
}
func (s *BaseStorageSuite) TestSetEncodedObjectAndEncodedObject(c *C) {
for _, to := range s.testObjects {
comment := Commentf("failed for type %s", to.Type.String())
h, err := s.Storer.SetEncodedObject(to.Object)
c.Assert(err, IsNil)
c.Assert(h.String(), Equals, to.Hash, comment)
o, err := s.Storer.EncodedObject(to.Type, h)
c.Assert(err, IsNil)
c.Assert(objectEquals(o, to.Object), IsNil)
o, err = s.Storer.EncodedObject(plumbing.AnyObject, h)
c.Assert(err, IsNil)
c.Assert(objectEquals(o, to.Object), IsNil)
for _, t := range s.validTypes {
if t == to.Type {
continue
}
o, err = s.Storer.EncodedObject(t, h)
c.Assert(o, IsNil)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
}
}
}
func (s *BaseStorageSuite) TestSetEncodedObjectInvalid(c *C) {
o := s.Storer.NewEncodedObject()
o.SetType(plumbing.REFDeltaObject)
_, err := s.Storer.SetEncodedObject(o)
c.Assert(err, NotNil)
}
func (s *BaseStorageSuite) TestIterEncodedObjects(c *C) {
for _, o := range s.testObjects {
h, err := s.Storer.SetEncodedObject(o.Object)
c.Assert(err, IsNil)
c.Assert(h, Equals, o.Object.Hash())
}
for _, t := range s.validTypes {
comment := Commentf("failed for type %s)", t.String())
i, err := s.Storer.IterEncodedObjects(t)
c.Assert(err, IsNil, comment)
o, err := i.Next()
c.Assert(err, IsNil)
c.Assert(objectEquals(o, s.testObjects[t].Object), IsNil)
o, err = i.Next()
c.Assert(o, IsNil)
c.Assert(err, Equals, io.EOF, comment)
}
i, err := s.Storer.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
foundObjects := []plumbing.EncodedObject{}
i.ForEach(func(o plumbing.EncodedObject) error {
foundObjects = append(foundObjects, o)
return nil
})
c.Assert(foundObjects, HasLen, len(s.testObjects))
for _, to := range s.testObjects {
found := false
for _, o := range foundObjects {
if to.Object.Hash() == o.Hash() {
found = true
break
}
}
c.Assert(found, Equals, true, Commentf("Object of type %s not found", to.Type.String()))
}
}
func (s *BaseStorageSuite) TestPackfileWriter(c *C) {
pwr, ok := s.Storer.(storer.PackfileWriter)
if !ok {
c.Skip("not a storer.PackWriter")
}
pw, err := pwr.PackfileWriter()
c.Assert(err, IsNil)
f := fixtures.Basic().One()
_, err = io.Copy(pw, f.Packfile())
c.Assert(err, IsNil)
err = pw.Close()
c.Assert(err, IsNil)
iter, err := s.Storer.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
objects := 0
err = iter.ForEach(func(plumbing.EncodedObject) error {
objects++
return nil
})
c.Assert(err, IsNil)
c.Assert(objects, Equals, 31)
}
func (s *BaseStorageSuite) TestObjectStorerTxSetEncodedObjectAndCommit(c *C) {
storer, ok := s.Storer.(storer.Transactioner)
if !ok {
c.Skip("not a plumbing.ObjectStorerTx")
}
tx := storer.Begin()
for _, o := range s.testObjects {
h, err := tx.SetEncodedObject(o.Object)
c.Assert(err, IsNil)
c.Assert(h.String(), Equals, o.Hash)
}
iter, err := s.Storer.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
_, err = iter.Next()
c.Assert(err, Equals, io.EOF)
err = tx.Commit()
c.Assert(err, IsNil)
iter, err = s.Storer.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
var count int
iter.ForEach(func(o plumbing.EncodedObject) error {
count++
return nil
})
c.Assert(count, Equals, 4)
}
func (s *BaseStorageSuite) TestObjectStorerTxSetObjectAndGetObject(c *C) {
storer, ok := s.Storer.(storer.Transactioner)
if !ok {
c.Skip("not a plumbing.ObjectStorerTx")
}
tx := storer.Begin()
for _, expected := range s.testObjects {
h, err := tx.SetEncodedObject(expected.Object)
c.Assert(err, IsNil)
c.Assert(h.String(), Equals, expected.Hash)
o, err := tx.EncodedObject(expected.Type, plumbing.NewHash(expected.Hash))
c.Assert(err, IsNil)
c.Assert(o.Hash().String(), DeepEquals, expected.Hash)
}
}
func (s *BaseStorageSuite) TestObjectStorerTxGetObjectNotFound(c *C) {
storer, ok := s.Storer.(storer.Transactioner)
if !ok {
c.Skip("not a plumbing.ObjectStorerTx")
}
tx := storer.Begin()
o, err := tx.EncodedObject(plumbing.AnyObject, plumbing.ZeroHash)
c.Assert(o, IsNil)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
}
func (s *BaseStorageSuite) TestObjectStorerTxSetObjectAndRollback(c *C) {
storer, ok := s.Storer.(storer.Transactioner)
if !ok {
c.Skip("not a plumbing.ObjectStorerTx")
}
tx := storer.Begin()
for _, o := range s.testObjects {
h, err := tx.SetEncodedObject(o.Object)
c.Assert(err, IsNil)
c.Assert(h.String(), Equals, o.Hash)
}
err := tx.Rollback()
c.Assert(err, IsNil)
iter, err := s.Storer.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
_, err = iter.Next()
c.Assert(err, Equals, io.EOF)
}
func (s *BaseStorageSuite) TestSetReferenceAndGetReference(c *C) {
err := s.Storer.SetReference(
plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
)
c.Assert(err, IsNil)
err = s.Storer.SetReference(
plumbing.NewReferenceFromStrings("bar", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
)
c.Assert(err, IsNil)
e, err := s.Storer.Reference(plumbing.ReferenceName("foo"))
c.Assert(err, IsNil)
c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
}
func (s *BaseStorageSuite) TestCheckAndSetReference(c *C) {
err := s.Storer.SetReference(
plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
)
c.Assert(err, IsNil)
err = s.Storer.CheckAndSetReference(
plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
)
c.Assert(err, IsNil)
e, err := s.Storer.Reference(plumbing.ReferenceName("foo"))
c.Assert(err, IsNil)
c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
}
func (s *BaseStorageSuite) TestCheckAndSetReferenceNil(c *C) {
err := s.Storer.SetReference(
plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
)
c.Assert(err, IsNil)
err = s.Storer.CheckAndSetReference(
plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
nil,
)
c.Assert(err, IsNil)
e, err := s.Storer.Reference(plumbing.ReferenceName("foo"))
c.Assert(err, IsNil)
c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
}
func (s *BaseStorageSuite) TestCheckAndSetReferenceError(c *C) {
err := s.Storer.SetReference(
plumbing.NewReferenceFromStrings("foo", "c3f4688a08fd86f1bf8e055724c84b7a40a09733"),
)
c.Assert(err, IsNil)
err = s.Storer.CheckAndSetReference(
plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
)
c.Assert(err, Equals, storage.ErrReferenceHasChanged)
e, err := s.Storer.Reference(plumbing.ReferenceName("foo"))
c.Assert(err, IsNil)
c.Assert(e.Hash().String(), Equals, "c3f4688a08fd86f1bf8e055724c84b7a40a09733")
}
func (s *BaseStorageSuite) TestRemoveReference(c *C) {
err := s.Storer.SetReference(
plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
)
c.Assert(err, IsNil)
err = s.Storer.RemoveReference(plumbing.ReferenceName("foo"))
c.Assert(err, IsNil)
_, err = s.Storer.Reference(plumbing.ReferenceName("foo"))
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
}
func (s *BaseStorageSuite) TestRemoveReferenceNonExistent(c *C) {
err := s.Storer.SetReference(
plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
)
c.Assert(err, IsNil)
err = s.Storer.RemoveReference(plumbing.ReferenceName("nonexistent"))
c.Assert(err, IsNil)
e, err := s.Storer.Reference(plumbing.ReferenceName("foo"))
c.Assert(err, IsNil)
c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
}
func (s *BaseStorageSuite) TestGetReferenceNotFound(c *C) {
r, err := s.Storer.Reference(plumbing.ReferenceName("bar"))
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
c.Assert(r, IsNil)
}
func (s *BaseStorageSuite) TestIterReferences(c *C) {
err := s.Storer.SetReference(
plumbing.NewReferenceFromStrings("refs/foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
)
c.Assert(err, IsNil)
i, err := s.Storer.IterReferences()
c.Assert(err, IsNil)
e, err := i.Next()
c.Assert(err, IsNil)
c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
e, err = i.Next()
c.Assert(e, IsNil)
c.Assert(err, Equals, io.EOF)
}
func (s *BaseStorageSuite) TestSetShallowAndShallow(c *C) {
expected := []plumbing.Hash{
plumbing.NewHash("b66c08ba28aa1f81eb06a1127aa3936ff77e5e2c"),
plumbing.NewHash("c3f4688a08fd86f1bf8e055724c84b7a40a09733"),
plumbing.NewHash("c78874f116be67ecf54df225a613162b84cc6ebf"),
}
err := s.Storer.SetShallow(expected)
c.Assert(err, IsNil)
result, err := s.Storer.Shallow()
c.Assert(err, IsNil)
c.Assert(result, DeepEquals, expected)
}
func (s *BaseStorageSuite) TestSetConfigAndConfig(c *C) {
expected := config.NewConfig()
expected.Core.IsBare = true
expected.Remotes["foo"] = &config.RemoteConfig{
Name: "foo",
URLs: []string{"http://foo/bar.git"},
}
err := s.Storer.SetConfig(expected)
c.Assert(err, IsNil)
cfg, err := s.Storer.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Core.IsBare, DeepEquals, expected.Core.IsBare)
c.Assert(cfg.Remotes, DeepEquals, expected.Remotes)
}
func (s *BaseStorageSuite) TestIndex(c *C) {
expected := &index.Index{}
expected.Version = 2
idx, err := s.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx, DeepEquals, expected)
}
func (s *BaseStorageSuite) TestSetIndexAndIndex(c *C) {
expected := &index.Index{}
expected.Version = 2
err := s.Storer.SetIndex(expected)
c.Assert(err, IsNil)
idx, err := s.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx, DeepEquals, expected)
}
func (s *BaseStorageSuite) TestSetConfigInvalid(c *C) {
cfg := config.NewConfig()
cfg.Remotes["foo"] = &config.RemoteConfig{}
err := s.Storer.SetConfig(cfg)
c.Assert(err, NotNil)
}
func (s *BaseStorageSuite) TestModule(c *C) {
storer, err := s.Storer.Module("foo")
c.Assert(err, IsNil)
c.Assert(storer, NotNil)
storer, err = s.Storer.Module("foo")
c.Assert(err, IsNil)
c.Assert(storer, NotNil)
}
func (s *BaseStorageSuite) TestDeltaObjectStorer(c *C) {
dos, ok := s.Storer.(storer.DeltaObjectStorer)
if !ok {
c.Skip("not an DeltaObjectStorer")
}
pwr, ok := s.Storer.(storer.PackfileWriter)
if !ok {
c.Skip("not a storer.PackWriter")
}
pw, err := pwr.PackfileWriter()
c.Assert(err, IsNil)
f := fixtures.Basic().One()
_, err = io.Copy(pw, f.Packfile())
c.Assert(err, IsNil)
err = pw.Close()
c.Assert(err, IsNil)
h := plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88")
obj, err := dos.DeltaObject(plumbing.AnyObject, h)
c.Assert(err, IsNil)
c.Assert(obj.Type(), Equals, plumbing.BlobObject)
h = plumbing.NewHash("aa9b383c260e1d05fbbf6b30a02914555e20c725")
obj, err = dos.DeltaObject(plumbing.AnyObject, h)
c.Assert(err, IsNil)
c.Assert(obj.Type(), Equals, plumbing.OFSDeltaObject)
_, ok = obj.(plumbing.DeltaObject)
c.Assert(ok, Equals, true)
}
func objectEquals(a plumbing.EncodedObject, b plumbing.EncodedObject) error {
ha := a.Hash()
hb := b.Hash()
if ha != hb {
return fmt.Errorf("hashes do not match: %s != %s",
ha.String(), hb.String())
}
ra, err := a.Reader()
if err != nil {
return fmt.Errorf("can't get reader on a: %q", err)
}
rb, err := b.Reader()
if err != nil {
return fmt.Errorf("can't get reader on b: %q", err)
}
ca, err := io.ReadAll(ra)
if err != nil {
return fmt.Errorf("error reading a: %q", err)
}
cb, err := io.ReadAll(rb)
if err != nil {
return fmt.Errorf("error reading b: %q", err)
}
if hex.EncodeToString(ca) != hex.EncodeToString(cb) {
return errors.New("content does not match")
}
err = rb.Close()
if err != nil {
return fmt.Errorf("can't close reader on b: %q", err)
}
err = ra.Close()
if err != nil {
return fmt.Errorf("can't close reader on a: %q", err)
}
return nil
}
go-git-5.13.2/storage/transactional/ 0000775 0000000 0000000 00000000000 14744245500 0017303 5 ustar 00root root 0000000 0000000 go-git-5.13.2/storage/transactional/config.go 0000664 0000000 0000000 00000002164 14744245500 0021102 0 ustar 00root root 0000000 0000000 package transactional
import "github.com/go-git/go-git/v5/config"
// ConfigStorage implements the storer.ConfigStorage for the transactional package.
type ConfigStorage struct {
config.ConfigStorer
temporal config.ConfigStorer
set bool
}
// NewConfigStorage returns a new ConfigStorer based on a base storer and a
// temporal storer.
func NewConfigStorage(s, temporal config.ConfigStorer) *ConfigStorage {
return &ConfigStorage{ConfigStorer: s, temporal: temporal}
}
// SetConfig honors the storer.ConfigStorer interface.
func (c *ConfigStorage) SetConfig(cfg *config.Config) error {
if err := c.temporal.SetConfig(cfg); err != nil {
return err
}
c.set = true
return nil
}
// Config honors the storer.ConfigStorer interface.
func (c *ConfigStorage) Config() (*config.Config, error) {
if !c.set {
return c.ConfigStorer.Config()
}
return c.temporal.Config()
}
// Commit it copies the config from the temporal storage into the base storage.
func (c *ConfigStorage) Commit() error {
if !c.set {
return nil
}
cfg, err := c.temporal.Config()
if err != nil {
return err
}
return c.ConfigStorer.SetConfig(cfg)
}
go-git-5.13.2/storage/transactional/config_test.go 0000664 0000000 0000000 00000003270 14744245500 0022140 0 ustar 00root root 0000000 0000000 package transactional
import (
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
var _ = Suite(&ConfigSuite{})
type ConfigSuite struct{}
func (s *ConfigSuite) TestSetConfigBase(c *C) {
cfg := config.NewConfig()
cfg.Core.Worktree = "foo"
base := memory.NewStorage()
err := base.SetConfig(cfg)
c.Assert(err, IsNil)
temporal := memory.NewStorage()
cs := NewConfigStorage(base, temporal)
cfg, err = cs.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Core.Worktree, Equals, "foo")
}
func (s *ConfigSuite) TestSetConfigTemporal(c *C) {
cfg := config.NewConfig()
cfg.Core.Worktree = "foo"
base := memory.NewStorage()
err := base.SetConfig(cfg)
c.Assert(err, IsNil)
temporal := memory.NewStorage()
cfg = config.NewConfig()
cfg.Core.Worktree = "bar"
cs := NewConfigStorage(base, temporal)
err = cs.SetConfig(cfg)
c.Assert(err, IsNil)
baseCfg, err := base.Config()
c.Assert(err, IsNil)
c.Assert(baseCfg.Core.Worktree, Equals, "foo")
temporalCfg, err := temporal.Config()
c.Assert(err, IsNil)
c.Assert(temporalCfg.Core.Worktree, Equals, "bar")
cfg, err = cs.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Core.Worktree, Equals, "bar")
}
func (s *ConfigSuite) TestCommit(c *C) {
cfg := config.NewConfig()
cfg.Core.Worktree = "foo"
base := memory.NewStorage()
err := base.SetConfig(cfg)
c.Assert(err, IsNil)
temporal := memory.NewStorage()
cfg = config.NewConfig()
cfg.Core.Worktree = "bar"
cs := NewConfigStorage(base, temporal)
err = cs.SetConfig(cfg)
c.Assert(err, IsNil)
err = cs.Commit()
c.Assert(err, IsNil)
baseCfg, err := base.Config()
c.Assert(err, IsNil)
c.Assert(baseCfg.Core.Worktree, Equals, "bar")
}
go-git-5.13.2/storage/transactional/doc.go 0000664 0000000 0000000 00000000531 14744245500 0020376 0 ustar 00root root 0000000 0000000 // Package transactional is a transactional implementation of git.Storer, it
// demux the write and read operation of two separate storers, allowing to merge
// content calling Storage.Commit.
//
// The API and functionality of this package are considered EXPERIMENTAL and is
// not considered stable nor production ready.
package transactional
go-git-5.13.2/storage/transactional/index.go 0000664 0000000 0000000 00000002247 14744245500 0020746 0 ustar 00root root 0000000 0000000 package transactional
import (
"github.com/go-git/go-git/v5/plumbing/format/index"
"github.com/go-git/go-git/v5/plumbing/storer"
)
// IndexStorage implements the storer.IndexStorage for the transactional package.
type IndexStorage struct {
storer.IndexStorer
temporal storer.IndexStorer
set bool
}
// NewIndexStorage returns a new IndexStorer based on a base storer and a
// temporal storer.
func NewIndexStorage(s, temporal storer.IndexStorer) *IndexStorage {
return &IndexStorage{
IndexStorer: s,
temporal: temporal,
}
}
// SetIndex honors the storer.IndexStorer interface.
func (s *IndexStorage) SetIndex(idx *index.Index) (err error) {
if err := s.temporal.SetIndex(idx); err != nil {
return err
}
s.set = true
return nil
}
// Index honors the storer.IndexStorer interface.
func (s *IndexStorage) Index() (*index.Index, error) {
if !s.set {
return s.IndexStorer.Index()
}
return s.temporal.Index()
}
// Commit it copies the index from the temporal storage into the base storage.
func (s *IndexStorage) Commit() error {
if !s.set {
return nil
}
idx, err := s.temporal.Index()
if err != nil {
return err
}
return s.IndexStorer.SetIndex(idx)
}
go-git-5.13.2/storage/transactional/index_test.go 0000664 0000000 0000000 00000001761 14744245500 0022005 0 ustar 00root root 0000000 0000000 package transactional
import (
"github.com/go-git/go-git/v5/plumbing/format/index"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
var _ = Suite(&IndexSuite{})
type IndexSuite struct{}
func (s *IndexSuite) TestSetIndexBase(c *C) {
idx := &index.Index{}
idx.Version = 2
base := memory.NewStorage()
err := base.SetIndex(idx)
c.Assert(err, IsNil)
temporal := memory.NewStorage()
cs := NewIndexStorage(base, temporal)
idx, err = cs.Index()
c.Assert(err, IsNil)
c.Assert(idx.Version, Equals, uint32(2))
}
func (s *IndexSuite) TestCommit(c *C) {
idx := &index.Index{}
idx.Version = 2
base := memory.NewStorage()
err := base.SetIndex(idx)
c.Assert(err, IsNil)
temporal := memory.NewStorage()
idx = &index.Index{}
idx.Version = 3
is := NewIndexStorage(base, temporal)
err = is.SetIndex(idx)
c.Assert(err, IsNil)
err = is.Commit()
c.Assert(err, IsNil)
baseIndex, err := base.Index()
c.Assert(err, IsNil)
c.Assert(baseIndex.Version, Equals, uint32(3))
}
go-git-5.13.2/storage/transactional/object.go 0000664 0000000 0000000 00000005112 14744245500 0021077 0 ustar 00root root 0000000 0000000 package transactional
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
)
// ObjectStorage implements the storer.EncodedObjectStorer for the transactional package.
type ObjectStorage struct {
storer.EncodedObjectStorer
temporal storer.EncodedObjectStorer
}
// NewObjectStorage returns a new EncodedObjectStorer based on a base storer and
// a temporal storer.
func NewObjectStorage(base, temporal storer.EncodedObjectStorer) *ObjectStorage {
return &ObjectStorage{EncodedObjectStorer: base, temporal: temporal}
}
// SetEncodedObject honors the storer.EncodedObjectStorer interface.
func (o *ObjectStorage) SetEncodedObject(obj plumbing.EncodedObject) (plumbing.Hash, error) {
return o.temporal.SetEncodedObject(obj)
}
// HasEncodedObject honors the storer.EncodedObjectStorer interface.
func (o *ObjectStorage) HasEncodedObject(h plumbing.Hash) error {
err := o.EncodedObjectStorer.HasEncodedObject(h)
if err == plumbing.ErrObjectNotFound {
return o.temporal.HasEncodedObject(h)
}
return err
}
// EncodedObjectSize honors the storer.EncodedObjectStorer interface.
func (o *ObjectStorage) EncodedObjectSize(h plumbing.Hash) (int64, error) {
sz, err := o.EncodedObjectStorer.EncodedObjectSize(h)
if err == plumbing.ErrObjectNotFound {
return o.temporal.EncodedObjectSize(h)
}
return sz, err
}
// EncodedObject honors the storer.EncodedObjectStorer interface.
func (o *ObjectStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (plumbing.EncodedObject, error) {
obj, err := o.EncodedObjectStorer.EncodedObject(t, h)
if err == plumbing.ErrObjectNotFound {
return o.temporal.EncodedObject(t, h)
}
return obj, err
}
// IterEncodedObjects honors the storer.EncodedObjectStorer interface.
func (o *ObjectStorage) IterEncodedObjects(t plumbing.ObjectType) (storer.EncodedObjectIter, error) {
baseIter, err := o.EncodedObjectStorer.IterEncodedObjects(t)
if err != nil {
return nil, err
}
temporalIter, err := o.temporal.IterEncodedObjects(t)
if err != nil {
return nil, err
}
return storer.NewMultiEncodedObjectIter([]storer.EncodedObjectIter{
baseIter,
temporalIter,
}), nil
}
// Commit it copies the objects of the temporal storage into the base storage.
func (o *ObjectStorage) Commit() error {
iter, err := o.temporal.IterEncodedObjects(plumbing.AnyObject)
if err != nil {
return err
}
return iter.ForEach(func(obj plumbing.EncodedObject) error {
_, err := o.EncodedObjectStorer.SetEncodedObject(obj)
return err
})
}
func (o *ObjectStorage) AddAlternate(remote string) error {
return o.temporal.AddAlternate(remote)
}
go-git-5.13.2/storage/transactional/object_test.go 0000664 0000000 0000000 00000007106 14744245500 0022143 0 ustar 00root root 0000000 0000000 package transactional
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
var _ = Suite(&ObjectSuite{})
type ObjectSuite struct{}
func (s *ObjectSuite) TestHasEncodedObject(c *C) {
base := memory.NewStorage()
temporal := memory.NewStorage()
os := NewObjectStorage(base, temporal)
commit := base.NewEncodedObject()
commit.SetType(plumbing.CommitObject)
ch, err := base.SetEncodedObject(commit)
c.Assert(ch.IsZero(), Equals, false)
c.Assert(err, IsNil)
tree := base.NewEncodedObject()
tree.SetType(plumbing.TreeObject)
th, err := os.SetEncodedObject(tree)
c.Assert(th.IsZero(), Equals, false)
c.Assert(err, IsNil)
err = os.HasEncodedObject(th)
c.Assert(err, IsNil)
err = os.HasEncodedObject(ch)
c.Assert(err, IsNil)
err = base.HasEncodedObject(th)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
}
func (s *ObjectSuite) TestEncodedObjectAndEncodedObjectSize(c *C) {
base := memory.NewStorage()
temporal := memory.NewStorage()
os := NewObjectStorage(base, temporal)
commit := base.NewEncodedObject()
commit.SetType(plumbing.CommitObject)
ch, err := base.SetEncodedObject(commit)
c.Assert(ch.IsZero(), Equals, false)
c.Assert(err, IsNil)
tree := base.NewEncodedObject()
tree.SetType(plumbing.TreeObject)
th, err := os.SetEncodedObject(tree)
c.Assert(th.IsZero(), Equals, false)
c.Assert(err, IsNil)
otree, err := os.EncodedObject(plumbing.TreeObject, th)
c.Assert(err, IsNil)
c.Assert(otree.Hash(), Equals, tree.Hash())
treeSz, err := os.EncodedObjectSize(th)
c.Assert(err, IsNil)
c.Assert(treeSz, Equals, int64(0))
ocommit, err := os.EncodedObject(plumbing.CommitObject, ch)
c.Assert(err, IsNil)
c.Assert(ocommit.Hash(), Equals, commit.Hash())
commitSz, err := os.EncodedObjectSize(ch)
c.Assert(err, IsNil)
c.Assert(commitSz, Equals, int64(0))
_, err = base.EncodedObject(plumbing.TreeObject, th)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
_, err = base.EncodedObjectSize(th)
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
}
func (s *ObjectSuite) TestIterEncodedObjects(c *C) {
base := memory.NewStorage()
temporal := memory.NewStorage()
os := NewObjectStorage(base, temporal)
commit := base.NewEncodedObject()
commit.SetType(plumbing.CommitObject)
ch, err := base.SetEncodedObject(commit)
c.Assert(ch.IsZero(), Equals, false)
c.Assert(err, IsNil)
tree := base.NewEncodedObject()
tree.SetType(plumbing.TreeObject)
th, err := os.SetEncodedObject(tree)
c.Assert(th.IsZero(), Equals, false)
c.Assert(err, IsNil)
iter, err := os.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
var hashes []plumbing.Hash
err = iter.ForEach(func(obj plumbing.EncodedObject) error {
hashes = append(hashes, obj.Hash())
return nil
})
c.Assert(err, IsNil)
c.Assert(hashes, HasLen, 2)
c.Assert(hashes[0], Equals, ch)
c.Assert(hashes[1], Equals, th)
}
func (s *ObjectSuite) TestCommit(c *C) {
base := memory.NewStorage()
temporal := memory.NewStorage()
os := NewObjectStorage(base, temporal)
commit := base.NewEncodedObject()
commit.SetType(plumbing.CommitObject)
_, err := os.SetEncodedObject(commit)
c.Assert(err, IsNil)
tree := base.NewEncodedObject()
tree.SetType(plumbing.TreeObject)
_, err = os.SetEncodedObject(tree)
c.Assert(err, IsNil)
err = os.Commit()
c.Assert(err, IsNil)
iter, err := base.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
var hashes []plumbing.Hash
err = iter.ForEach(func(obj plumbing.EncodedObject) error {
hashes = append(hashes, obj.Hash())
return nil
})
c.Assert(err, IsNil)
c.Assert(hashes, HasLen, 2)
}
go-git-5.13.2/storage/transactional/reference.go 0000664 0000000 0000000 00000006633 14744245500 0021600 0 ustar 00root root 0000000 0000000 package transactional
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage"
)
// ReferenceStorage implements the storer.ReferenceStorage for the transactional package.
type ReferenceStorage struct {
storer.ReferenceStorer
temporal storer.ReferenceStorer
// deleted, remaining references at this maps are going to be deleted when
// commit is requested, the entries are added when RemoveReference is called
// and deleted if SetReference is called.
deleted map[plumbing.ReferenceName]struct{}
}
// NewReferenceStorage returns a new ReferenceStorer based on a base storer and
// a temporal storer.
func NewReferenceStorage(base, temporal storer.ReferenceStorer) *ReferenceStorage {
return &ReferenceStorage{
ReferenceStorer: base,
temporal: temporal,
deleted: make(map[plumbing.ReferenceName]struct{}),
}
}
// SetReference honors the storer.ReferenceStorer interface.
func (r *ReferenceStorage) SetReference(ref *plumbing.Reference) error {
delete(r.deleted, ref.Name())
return r.temporal.SetReference(ref)
}
// SetReference honors the storer.ReferenceStorer interface.
func (r *ReferenceStorage) CheckAndSetReference(ref, old *plumbing.Reference) error {
if old == nil {
return r.SetReference(ref)
}
tmp, err := r.temporal.Reference(old.Name())
if err == plumbing.ErrReferenceNotFound {
tmp, err = r.ReferenceStorer.Reference(old.Name())
}
if err != nil {
return err
}
if tmp.Hash() != old.Hash() {
return storage.ErrReferenceHasChanged
}
return r.SetReference(ref)
}
// Reference honors the storer.ReferenceStorer interface.
func (r ReferenceStorage) Reference(n plumbing.ReferenceName) (*plumbing.Reference, error) {
if _, deleted := r.deleted[n]; deleted {
return nil, plumbing.ErrReferenceNotFound
}
ref, err := r.temporal.Reference(n)
if err == plumbing.ErrReferenceNotFound {
return r.ReferenceStorer.Reference(n)
}
return ref, err
}
// IterReferences honors the storer.ReferenceStorer interface.
func (r ReferenceStorage) IterReferences() (storer.ReferenceIter, error) {
baseIter, err := r.ReferenceStorer.IterReferences()
if err != nil {
return nil, err
}
temporalIter, err := r.temporal.IterReferences()
if err != nil {
return nil, err
}
return storer.NewMultiReferenceIter([]storer.ReferenceIter{
baseIter,
temporalIter,
}), nil
}
// CountLooseRefs honors the storer.ReferenceStorer interface.
func (r ReferenceStorage) CountLooseRefs() (int, error) {
tc, err := r.temporal.CountLooseRefs()
if err != nil {
return -1, err
}
bc, err := r.ReferenceStorer.CountLooseRefs()
if err != nil {
return -1, err
}
return tc + bc, nil
}
// PackRefs honors the storer.ReferenceStorer interface.
func (r ReferenceStorage) PackRefs() error {
return nil
}
// RemoveReference honors the storer.ReferenceStorer interface.
func (r ReferenceStorage) RemoveReference(n plumbing.ReferenceName) error {
r.deleted[n] = struct{}{}
return r.temporal.RemoveReference(n)
}
// Commit it copies the reference information of the temporal storage into the
// base storage.
func (r ReferenceStorage) Commit() error {
for name := range r.deleted {
if err := r.ReferenceStorer.RemoveReference(name); err != nil {
return err
}
}
iter, err := r.temporal.IterReferences()
if err != nil {
return err
}
return iter.ForEach(func(ref *plumbing.Reference) error {
return r.ReferenceStorer.SetReference(ref)
})
}
go-git-5.13.2/storage/transactional/reference_test.go 0000664 0000000 0000000 00000010502 14744245500 0022625 0 ustar 00root root 0000000 0000000 package transactional
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
var _ = Suite(&ReferenceSuite{})
type ReferenceSuite struct{}
func (s *ReferenceSuite) TestReference(c *C) {
base := memory.NewStorage()
temporal := memory.NewStorage()
rs := NewReferenceStorage(base, temporal)
refA := plumbing.NewReferenceFromStrings("refs/a", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
refB := plumbing.NewReferenceFromStrings("refs/b", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
err := base.SetReference(refA)
c.Assert(err, IsNil)
err = rs.SetReference(refB)
c.Assert(err, IsNil)
_, err = rs.Reference("refs/a")
c.Assert(err, IsNil)
_, err = rs.Reference("refs/b")
c.Assert(err, IsNil)
_, err = base.Reference("refs/b")
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
}
func (s *ReferenceSuite) TestRemoveReferenceTemporal(c *C) {
base := memory.NewStorage()
temporal := memory.NewStorage()
ref := plumbing.NewReferenceFromStrings("refs/a", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
rs := NewReferenceStorage(base, temporal)
err := rs.SetReference(ref)
c.Assert(err, IsNil)
err = rs.RemoveReference("refs/a")
c.Assert(err, IsNil)
_, err = rs.Reference("refs/a")
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
}
func (s *ReferenceSuite) TestRemoveReferenceBase(c *C) {
base := memory.NewStorage()
temporal := memory.NewStorage()
ref := plumbing.NewReferenceFromStrings("refs/a", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
rs := NewReferenceStorage(base, temporal)
err := base.SetReference(ref)
c.Assert(err, IsNil)
err = rs.RemoveReference("refs/a")
c.Assert(err, IsNil)
_, err = rs.Reference("refs/a")
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
}
func (s *ReferenceSuite) TestCheckAndSetReferenceInBase(c *C) {
base := memory.NewStorage()
temporal := memory.NewStorage()
rs := NewReferenceStorage(base, temporal)
err := base.SetReference(
plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
)
c.Assert(err, IsNil)
err = rs.CheckAndSetReference(
plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
)
c.Assert(err, IsNil)
e, err := rs.Reference(plumbing.ReferenceName("foo"))
c.Assert(err, IsNil)
c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
}
func (s *ReferenceSuite) TestCommit(c *C) {
base := memory.NewStorage()
temporal := memory.NewStorage()
refA := plumbing.NewReferenceFromStrings("refs/a", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
refB := plumbing.NewReferenceFromStrings("refs/b", "b66c08ba28aa1f81eb06a1127aa3936ff77e5e2c")
refC := plumbing.NewReferenceFromStrings("refs/c", "c3f4688a08fd86f1bf8e055724c84b7a40a09733")
rs := NewReferenceStorage(base, temporal)
c.Assert(rs.SetReference(refA), IsNil)
c.Assert(rs.SetReference(refB), IsNil)
c.Assert(rs.SetReference(refC), IsNil)
err := rs.Commit()
c.Assert(err, IsNil)
iter, err := base.IterReferences()
c.Assert(err, IsNil)
var count int
iter.ForEach(func(ref *plumbing.Reference) error {
count++
return nil
})
c.Assert(count, Equals, 3)
}
func (s *ReferenceSuite) TestCommitDelete(c *C) {
base := memory.NewStorage()
temporal := memory.NewStorage()
refA := plumbing.NewReferenceFromStrings("refs/a", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
refB := plumbing.NewReferenceFromStrings("refs/b", "b66c08ba28aa1f81eb06a1127aa3936ff77e5e2c")
refC := plumbing.NewReferenceFromStrings("refs/c", "c3f4688a08fd86f1bf8e055724c84b7a40a09733")
rs := NewReferenceStorage(base, temporal)
c.Assert(base.SetReference(refA), IsNil)
c.Assert(base.SetReference(refB), IsNil)
c.Assert(base.SetReference(refC), IsNil)
c.Assert(rs.RemoveReference(refA.Name()), IsNil)
c.Assert(rs.RemoveReference(refB.Name()), IsNil)
c.Assert(rs.RemoveReference(refC.Name()), IsNil)
c.Assert(rs.SetReference(refC), IsNil)
err := rs.Commit()
c.Assert(err, IsNil)
iter, err := base.IterReferences()
c.Assert(err, IsNil)
var count int
iter.ForEach(func(ref *plumbing.Reference) error {
count++
return nil
})
c.Assert(count, Equals, 1)
ref, err := rs.Reference(refC.Name())
c.Assert(err, IsNil)
c.Assert(ref.Hash().String(), Equals, "c3f4688a08fd86f1bf8e055724c84b7a40a09733")
}
go-git-5.13.2/storage/transactional/shallow.go 0000664 0000000 0000000 00000002371 14744245500 0021306 0 ustar 00root root 0000000 0000000 package transactional
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/storer"
)
// ShallowStorage implements the storer.ShallowStorer for the transactional package.
type ShallowStorage struct {
storer.ShallowStorer
temporal storer.ShallowStorer
}
// NewShallowStorage returns a new ShallowStorage based on a base storer and
// a temporal storer.
func NewShallowStorage(base, temporal storer.ShallowStorer) *ShallowStorage {
return &ShallowStorage{
ShallowStorer: base,
temporal: temporal,
}
}
// SetShallow honors the storer.ShallowStorer interface.
func (s *ShallowStorage) SetShallow(commits []plumbing.Hash) error {
return s.temporal.SetShallow(commits)
}
// Shallow honors the storer.ShallowStorer interface.
func (s *ShallowStorage) Shallow() ([]plumbing.Hash, error) {
shallow, err := s.temporal.Shallow()
if err != nil {
return nil, err
}
if len(shallow) != 0 {
return shallow, nil
}
return s.ShallowStorer.Shallow()
}
// Commit it copies the shallow information of the temporal storage into the
// base storage.
func (s *ShallowStorage) Commit() error {
commits, err := s.temporal.Shallow()
if err != nil || len(commits) == 0 {
return err
}
return s.ShallowStorer.SetShallow(commits)
}
go-git-5.13.2/storage/transactional/shallow_test.go 0000664 0000000 0000000 00000003054 14744245500 0022344 0 ustar 00root root 0000000 0000000 package transactional
import (
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
var _ = Suite(&ShallowSuite{})
type ShallowSuite struct{}
func (s *ShallowSuite) TestShallow(c *C) {
base := memory.NewStorage()
temporal := memory.NewStorage()
rs := NewShallowStorage(base, temporal)
commitA := plumbing.NewHash("bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
commitB := plumbing.NewHash("aa9968d75e48de59f0870ffb71f5e160bbbdcf52")
err := base.SetShallow([]plumbing.Hash{commitA})
c.Assert(err, IsNil)
err = rs.SetShallow([]plumbing.Hash{commitB})
c.Assert(err, IsNil)
commits, err := rs.Shallow()
c.Assert(err, IsNil)
c.Assert(commits, HasLen, 1)
c.Assert(commits[0], Equals, commitB)
commits, err = base.Shallow()
c.Assert(err, IsNil)
c.Assert(commits, HasLen, 1)
c.Assert(commits[0], Equals, commitA)
}
func (s *ShallowSuite) TestCommit(c *C) {
base := memory.NewStorage()
temporal := memory.NewStorage()
rs := NewShallowStorage(base, temporal)
commitA := plumbing.NewHash("bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
commitB := plumbing.NewHash("aa9968d75e48de59f0870ffb71f5e160bbbdcf52")
c.Assert(base.SetShallow([]plumbing.Hash{commitA}), IsNil)
c.Assert(rs.SetShallow([]plumbing.Hash{commitB}), IsNil)
c.Assert(rs.Commit(), IsNil)
commits, err := rs.Shallow()
c.Assert(err, IsNil)
c.Assert(commits, HasLen, 1)
c.Assert(commits[0], Equals, commitB)
commits, err = base.Shallow()
c.Assert(err, IsNil)
c.Assert(commits, HasLen, 1)
c.Assert(commits[0], Equals, commitB)
}
go-git-5.13.2/storage/transactional/storage.go 0000664 0000000 0000000 00000004476 14744245500 0021311 0 ustar 00root root 0000000 0000000 package transactional
import (
"io"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage"
)
// Storage is a transactional implementation of git.Storer, it demux the write
// and read operation of two separate storers, allowing to merge content calling
// Storage.Commit.
//
// The API and functionality of this package are considered EXPERIMENTAL and is
// not considered stable nor production ready.
type Storage interface {
storage.Storer
Commit() error
}
// basic implements the Storage interface.
type basic struct {
s, temporal storage.Storer
*ObjectStorage
*ReferenceStorage
*IndexStorage
*ShallowStorage
*ConfigStorage
}
// packageWriter implements storer.PackfileWriter interface over
// a Storage with a temporal storer that supports it.
type packageWriter struct {
*basic
pw storer.PackfileWriter
}
// NewStorage returns a new Storage based on two repositories, base is the base
// repository where the read operations are read and temporal is were all
// the write operations are stored.
func NewStorage(base, temporal storage.Storer) Storage {
st := &basic{
s: base,
temporal: temporal,
ObjectStorage: NewObjectStorage(base, temporal),
ReferenceStorage: NewReferenceStorage(base, temporal),
IndexStorage: NewIndexStorage(base, temporal),
ShallowStorage: NewShallowStorage(base, temporal),
ConfigStorage: NewConfigStorage(base, temporal),
}
pw, ok := temporal.(storer.PackfileWriter)
if ok {
return &packageWriter{
basic: st,
pw: pw,
}
}
return st
}
// Module it honors the storage.ModuleStorer interface.
func (s *basic) Module(name string) (storage.Storer, error) {
base, err := s.s.Module(name)
if err != nil {
return nil, err
}
temporal, err := s.temporal.Module(name)
if err != nil {
return nil, err
}
return NewStorage(base, temporal), nil
}
// Commit it copies the content of the temporal storage into the base storage.
func (s *basic) Commit() error {
for _, c := range []interface{ Commit() error }{
s.ObjectStorage,
s.ReferenceStorage,
s.IndexStorage,
s.ShallowStorage,
s.ConfigStorage,
} {
if err := c.Commit(); err != nil {
return err
}
}
return nil
}
// PackfileWriter honors storage.PackfileWriter.
func (s *packageWriter) PackfileWriter() (io.WriteCloser, error) {
return s.pw.PackfileWriter()
}
go-git-5.13.2/storage/transactional/storage_test.go 0000664 0000000 0000000 00000003554 14744245500 0022344 0 ustar 00root root 0000000 0000000 package transactional
import (
"testing"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-git/v5/storage/memory"
"github.com/go-git/go-git/v5/storage/test"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type StorageSuite struct {
test.BaseStorageSuite
temporal func() storage.Storer
}
var _ = Suite(&StorageSuite{
temporal: func() storage.Storer {
return memory.NewStorage()
},
})
var _ = Suite(&StorageSuite{
temporal: func() storage.Storer {
fs := memfs.New()
return filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
},
})
func (s *StorageSuite) SetUpTest(c *C) {
base := memory.NewStorage()
temporal := s.temporal()
s.BaseStorageSuite = test.NewBaseStorageSuite(NewStorage(base, temporal))
}
func (s *StorageSuite) TestCommit(c *C) {
base := memory.NewStorage()
temporal := s.temporal()
st := NewStorage(base, temporal)
commit := base.NewEncodedObject()
commit.SetType(plumbing.CommitObject)
_, err := st.SetEncodedObject(commit)
c.Assert(err, IsNil)
ref := plumbing.NewHashReference("refs/a", commit.Hash())
c.Assert(st.SetReference(ref), IsNil)
err = st.Commit()
c.Assert(err, IsNil)
ref, err = base.Reference(ref.Name())
c.Assert(err, IsNil)
c.Assert(ref.Hash(), Equals, commit.Hash())
obj, err := base.EncodedObject(plumbing.AnyObject, commit.Hash())
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, commit.Hash())
}
func (s *StorageSuite) TestTransactionalPackfileWriter(c *C) {
base := memory.NewStorage()
temporal := s.temporal()
st := NewStorage(base, temporal)
_, tmpOK := temporal.(storer.PackfileWriter)
_, ok := st.(storer.PackfileWriter)
c.Assert(ok, Equals, tmpOK)
}
go-git-5.13.2/submodule.go 0000664 0000000 0000000 00000021664 14744245500 0015334 0 ustar 00root root 0000000 0000000 package git
import (
"bytes"
"context"
"errors"
"fmt"
"path"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/index"
"github.com/go-git/go-git/v5/plumbing/transport"
)
var (
ErrSubmoduleAlreadyInitialized = errors.New("submodule already initialized")
ErrSubmoduleNotInitialized = errors.New("submodule not initialized")
)
// Submodule a submodule allows you to keep another Git repository in a
// subdirectory of your repository.
type Submodule struct {
// initialized defines if a submodule was already initialized.
initialized bool
c *config.Submodule
w *Worktree
}
// Config returns the submodule config
func (s *Submodule) Config() *config.Submodule {
return s.c
}
// Init initialize the submodule reading the recorded Entry in the index for
// the given submodule
func (s *Submodule) Init() error {
cfg, err := s.w.r.Config()
if err != nil {
return err
}
_, ok := cfg.Submodules[s.c.Name]
if ok {
return ErrSubmoduleAlreadyInitialized
}
s.initialized = true
cfg.Submodules[s.c.Name] = s.c
return s.w.r.Storer.SetConfig(cfg)
}
// Status returns the status of the submodule.
func (s *Submodule) Status() (*SubmoduleStatus, error) {
idx, err := s.w.r.Storer.Index()
if err != nil {
return nil, err
}
return s.status(idx)
}
func (s *Submodule) status(idx *index.Index) (*SubmoduleStatus, error) {
status := &SubmoduleStatus{
Path: s.c.Path,
}
e, err := idx.Entry(s.c.Path)
if err != nil && err != index.ErrEntryNotFound {
return nil, err
}
if e != nil {
status.Expected = e.Hash
}
if !s.initialized {
return status, nil
}
r, err := s.Repository()
if err != nil {
return nil, err
}
head, err := r.Head()
if err == nil {
status.Current = head.Hash()
}
if err != nil && err == plumbing.ErrReferenceNotFound {
err = nil
}
return status, err
}
// Repository returns the Repository represented by this submodule
func (s *Submodule) Repository() (*Repository, error) {
if !s.initialized {
return nil, ErrSubmoduleNotInitialized
}
storer, err := s.w.r.Storer.Module(s.c.Name)
if err != nil {
return nil, err
}
_, err = storer.Reference(plumbing.HEAD)
if err != nil && err != plumbing.ErrReferenceNotFound {
return nil, err
}
var exists bool
if err == nil {
exists = true
}
var worktree billy.Filesystem
if worktree, err = s.w.Filesystem.Chroot(s.c.Path); err != nil {
return nil, err
}
if exists {
return Open(storer, worktree)
}
r, err := Init(storer, worktree)
if err != nil {
return nil, err
}
moduleEndpoint, err := transport.NewEndpoint(s.c.URL)
if err != nil {
return nil, err
}
if !path.IsAbs(moduleEndpoint.Path) && moduleEndpoint.Protocol == "file" {
remotes, err := s.w.r.Remotes()
if err != nil {
return nil, err
}
rootEndpoint, err := transport.NewEndpoint(remotes[0].c.URLs[0])
if err != nil {
return nil, err
}
rootEndpoint.Path = path.Join(rootEndpoint.Path, moduleEndpoint.Path)
*moduleEndpoint = *rootEndpoint
}
_, err = r.CreateRemote(&config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{moduleEndpoint.String()},
})
return r, err
}
// Update the registered submodule to match what the superproject expects, the
// submodule should be initialized first calling the Init method or setting in
// the options SubmoduleUpdateOptions.Init equals true
func (s *Submodule) Update(o *SubmoduleUpdateOptions) error {
return s.UpdateContext(context.Background(), o)
}
// UpdateContext the registered submodule to match what the superproject
// expects, the submodule should be initialized first calling the Init method or
// setting in the options SubmoduleUpdateOptions.Init equals true.
//
// The provided Context must be non-nil. If the context expires before the
// operation is complete, an error is returned. The context only affects the
// transport operations.
func (s *Submodule) UpdateContext(ctx context.Context, o *SubmoduleUpdateOptions) error {
return s.update(ctx, o, plumbing.ZeroHash)
}
func (s *Submodule) update(ctx context.Context, o *SubmoduleUpdateOptions, forceHash plumbing.Hash) error {
if !s.initialized && !o.Init {
return ErrSubmoduleNotInitialized
}
if !s.initialized && o.Init {
if err := s.Init(); err != nil {
return err
}
}
idx, err := s.w.r.Storer.Index()
if err != nil {
return err
}
hash := forceHash
if hash.IsZero() {
e, err := idx.Entry(s.c.Path)
if err != nil {
return err
}
hash = e.Hash
}
r, err := s.Repository()
if err != nil {
return err
}
if err := s.fetchAndCheckout(ctx, r, o, hash); err != nil {
return err
}
return s.doRecursiveUpdate(ctx, r, o)
}
func (s *Submodule) doRecursiveUpdate(ctx context.Context, r *Repository, o *SubmoduleUpdateOptions) error {
if o.RecurseSubmodules == NoRecurseSubmodules {
return nil
}
w, err := r.Worktree()
if err != nil {
return err
}
l, err := w.Submodules()
if err != nil {
return err
}
new := &SubmoduleUpdateOptions{}
*new = *o
new.RecurseSubmodules--
return l.UpdateContext(ctx, new)
}
func (s *Submodule) fetchAndCheckout(
ctx context.Context, r *Repository, o *SubmoduleUpdateOptions, hash plumbing.Hash,
) error {
if !o.NoFetch {
err := r.FetchContext(ctx, &FetchOptions{Auth: o.Auth, Depth: o.Depth})
if err != nil && err != NoErrAlreadyUpToDate {
return err
}
}
w, err := r.Worktree()
if err != nil {
return err
}
// Handle a case when submodule refers to an orphaned commit that's still reachable
// through Git server using a special protocol capability[1].
//
// [1]: https://git-scm.com/docs/protocol-capabilities#_allow_reachable_sha1_in_want
if !o.NoFetch {
if _, err := w.r.Object(plumbing.AnyObject, hash); err != nil {
refSpec := config.RefSpec("+" + hash.String() + ":" + hash.String())
err := r.FetchContext(ctx, &FetchOptions{
Auth: o.Auth,
RefSpecs: []config.RefSpec{refSpec},
Depth: o.Depth,
})
if err != nil && err != NoErrAlreadyUpToDate && err != ErrExactSHA1NotSupported {
return err
}
}
}
if err := w.Checkout(&CheckoutOptions{Hash: hash}); err != nil {
return err
}
head := plumbing.NewHashReference(plumbing.HEAD, hash)
return r.Storer.SetReference(head)
}
// Submodules list of several submodules from the same repository.
type Submodules []*Submodule
// Init initializes the submodules in this list.
func (s Submodules) Init() error {
for _, sub := range s {
if err := sub.Init(); err != nil {
return err
}
}
return nil
}
// Update updates all the submodules in this list.
func (s Submodules) Update(o *SubmoduleUpdateOptions) error {
return s.UpdateContext(context.Background(), o)
}
// UpdateContext updates all the submodules in this list.
//
// The provided Context must be non-nil. If the context expires before the
// operation is complete, an error is returned. The context only affects the
// transport operations.
func (s Submodules) UpdateContext(ctx context.Context, o *SubmoduleUpdateOptions) error {
for _, sub := range s {
if err := sub.UpdateContext(ctx, o); err != nil {
return err
}
}
return nil
}
// Status returns the status of the submodules.
func (s Submodules) Status() (SubmodulesStatus, error) {
var list SubmodulesStatus
var r *Repository
for _, sub := range s {
if r == nil {
r = sub.w.r
}
idx, err := r.Storer.Index()
if err != nil {
return nil, err
}
status, err := sub.status(idx)
if err != nil {
return nil, err
}
list = append(list, status)
}
return list, nil
}
// SubmodulesStatus contains the status for all submodiles in the worktree
type SubmodulesStatus []*SubmoduleStatus
// String is equivalent to `git submodule status`
func (s SubmodulesStatus) String() string {
buf := bytes.NewBuffer(nil)
for _, sub := range s {
fmt.Fprintln(buf, sub)
}
return buf.String()
}
// SubmoduleStatus contains the status for a submodule in the worktree
type SubmoduleStatus struct {
Path string
Current plumbing.Hash
Expected plumbing.Hash
Branch plumbing.ReferenceName
}
// IsClean is the HEAD of the submodule is equals to the expected commit
func (s *SubmoduleStatus) IsClean() bool {
return s.Current == s.Expected
}
// String is equivalent to `git submodule status `
//
// This will print the SHA-1 of the currently checked out commit for a
// submodule, along with the submodule path and the output of git describe fo
// the SHA-1. Each SHA-1 will be prefixed with - if the submodule is not
// initialized, + if the currently checked out submodule commit does not match
// the SHA-1 found in the index of the containing repository.
func (s *SubmoduleStatus) String() string {
var extra string
var status = ' '
if s.Current.IsZero() {
status = '-'
} else if !s.IsClean() {
status = '+'
}
if len(s.Branch) != 0 {
extra = string(s.Branch[5:])
} else if !s.Current.IsZero() {
extra = s.Current.String()[:7]
}
if extra != "" {
extra = fmt.Sprintf(" (%s)", extra)
}
return fmt.Sprintf("%c%s %s%s", status, s.Expected, s.Path, extra)
}
go-git-5.13.2/submodule_test.go 0000664 0000000 0000000 00000013530 14744245500 0016364 0 ustar 00root root 0000000 0000000 package git
import (
"context"
"path/filepath"
"testing"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/storage/memory"
fixtures "github.com/go-git/go-git-fixtures/v4"
. "gopkg.in/check.v1"
)
type SubmoduleSuite struct {
BaseSuite
Worktree *Worktree
}
var _ = Suite(&SubmoduleSuite{})
func (s *SubmoduleSuite) SetUpTest(c *C) {
path := fixtures.ByTag("submodule").One().Worktree().Root()
dir := c.MkDir()
r, err := PlainClone(filepath.Join(dir, "worktree"), false, &CloneOptions{
URL: path,
})
c.Assert(err, IsNil)
s.Repository = r
s.Worktree, err = r.Worktree()
c.Assert(err, IsNil)
}
func (s *SubmoduleSuite) TestInit(c *C) {
sm, err := s.Worktree.Submodule("basic")
c.Assert(err, IsNil)
c.Assert(sm.initialized, Equals, false)
err = sm.Init()
c.Assert(err, IsNil)
c.Assert(sm.initialized, Equals, true)
cfg, err := s.Repository.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Submodules, HasLen, 1)
c.Assert(cfg.Submodules["basic"], NotNil)
status, err := sm.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, false)
}
func (s *SubmoduleSuite) TestUpdate(c *C) {
if testing.Short() {
c.Skip("skipping test in short mode.")
}
sm, err := s.Worktree.Submodule("basic")
c.Assert(err, IsNil)
err = sm.Update(&SubmoduleUpdateOptions{
Init: true,
})
c.Assert(err, IsNil)
r, err := sm.Repository()
c.Assert(err, IsNil)
ref, err := r.Reference(plumbing.HEAD, true)
c.Assert(err, IsNil)
c.Assert(ref.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
status, err := sm.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
func (s *SubmoduleSuite) TestRepositoryWithoutInit(c *C) {
sm, err := s.Worktree.Submodule("basic")
c.Assert(err, IsNil)
r, err := sm.Repository()
c.Assert(err, Equals, ErrSubmoduleNotInitialized)
c.Assert(r, IsNil)
}
func (s *SubmoduleSuite) TestUpdateWithoutInit(c *C) {
sm, err := s.Worktree.Submodule("basic")
c.Assert(err, IsNil)
err = sm.Update(&SubmoduleUpdateOptions{})
c.Assert(err, Equals, ErrSubmoduleNotInitialized)
}
func (s *SubmoduleSuite) TestUpdateWithNotFetch(c *C) {
sm, err := s.Worktree.Submodule("basic")
c.Assert(err, IsNil)
err = sm.Update(&SubmoduleUpdateOptions{
Init: true,
NoFetch: true,
})
// Since we are not fetching, the object is not there
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
}
func (s *SubmoduleSuite) TestUpdateWithRecursion(c *C) {
if testing.Short() {
c.Skip("skipping test in short mode.")
}
sm, err := s.Worktree.Submodule("itself")
c.Assert(err, IsNil)
err = sm.Update(&SubmoduleUpdateOptions{
Init: true,
RecurseSubmodules: 2,
})
c.Assert(err, IsNil)
fs := s.Worktree.Filesystem
_, err = fs.Stat(fs.Join("itself", "basic", "LICENSE"))
c.Assert(err, IsNil)
}
func (s *SubmoduleSuite) TestUpdateWithInitAndUpdate(c *C) {
if testing.Short() {
c.Skip("skipping test in short mode.")
}
sm, err := s.Worktree.Submodule("basic")
c.Assert(err, IsNil)
err = sm.Update(&SubmoduleUpdateOptions{
Init: true,
})
c.Assert(err, IsNil)
idx, err := s.Repository.Storer.Index()
c.Assert(err, IsNil)
for i, e := range idx.Entries {
if e.Name == "basic" {
e.Hash = plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d")
}
idx.Entries[i] = e
}
err = s.Repository.Storer.SetIndex(idx)
c.Assert(err, IsNil)
err = sm.Update(&SubmoduleUpdateOptions{})
c.Assert(err, IsNil)
r, err := sm.Repository()
c.Assert(err, IsNil)
ref, err := r.Reference(plumbing.HEAD, true)
c.Assert(err, IsNil)
c.Assert(ref.Hash().String(), Equals, "b029517f6300c2da0f4b651b8642506cd6aaf45d")
}
func (s *SubmoduleSuite) TestSubmodulesInit(c *C) {
sm, err := s.Worktree.Submodules()
c.Assert(err, IsNil)
err = sm.Init()
c.Assert(err, IsNil)
sm, err = s.Worktree.Submodules()
c.Assert(err, IsNil)
for _, m := range sm {
c.Assert(m.initialized, Equals, true)
}
}
func (s *SubmoduleSuite) TestGitSubmodulesSymlink(c *C) {
f, err := s.Worktree.Filesystem.Create("badfile")
c.Assert(err, IsNil)
defer func() { _ = f.Close() }()
err = s.Worktree.Filesystem.Remove(gitmodulesFile)
c.Assert(err, IsNil)
err = s.Worktree.Filesystem.Symlink("badfile", gitmodulesFile)
c.Assert(err, IsNil)
_, err = s.Worktree.Submodules()
c.Assert(err, Equals, ErrGitModulesSymlink)
}
func (s *SubmoduleSuite) TestSubmodulesStatus(c *C) {
sm, err := s.Worktree.Submodules()
c.Assert(err, IsNil)
status, err := sm.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 2)
}
func (s *SubmoduleSuite) TestSubmodulesUpdateContext(c *C) {
if testing.Short() {
c.Skip("skipping test in short mode.")
}
sm, err := s.Worktree.Submodules()
c.Assert(err, IsNil)
ctx, cancel := context.WithCancel(context.Background())
cancel()
err = sm.UpdateContext(ctx, &SubmoduleUpdateOptions{Init: true})
c.Assert(err, NotNil)
}
func (s *SubmoduleSuite) TestSubmodulesFetchDepth(c *C) {
if testing.Short() {
c.Skip("skipping test in short mode.")
}
sm, err := s.Worktree.Submodule("basic")
c.Assert(err, IsNil)
err = sm.Update(&SubmoduleUpdateOptions{
Init: true,
Depth: 1,
})
c.Assert(err, IsNil)
r, err := sm.Repository()
c.Assert(err, IsNil)
lr, err := r.Log(&LogOptions{})
c.Assert(err, IsNil)
commitCount := 0
for _, err := lr.Next(); err == nil; _, err = lr.Next() {
commitCount++
}
c.Assert(err, IsNil)
c.Assert(commitCount, Equals, 1)
}
func (s *SubmoduleSuite) TestSubmoduleParseScp(c *C) {
repo := &Repository{
Storer: memory.NewStorage(),
wt: memfs.New(),
}
worktree := &Worktree{
Filesystem: memfs.New(),
r: repo,
}
submodule := &Submodule{
initialized: true,
c: nil,
w: worktree,
}
submodule.c = &config.Submodule{
URL: "git@github.com:username/submodule_repo",
}
_, err := submodule.Repository()
c.Assert(err, IsNil)
}
go-git-5.13.2/utils/ 0000775 0000000 0000000 00000000000 14744245500 0014135 5 ustar 00root root 0000000 0000000 go-git-5.13.2/utils/binary/ 0000775 0000000 0000000 00000000000 14744245500 0015421 5 ustar 00root root 0000000 0000000 go-git-5.13.2/utils/binary/read.go 0000664 0000000 0000000 00000010435 14744245500 0016666 0 ustar 00root root 0000000 0000000 // Package binary implements syntax-sugar functions on top of the standard
// library binary package
package binary
import (
"bufio"
"encoding/binary"
"io"
"github.com/go-git/go-git/v5/plumbing"
)
// Read reads structured binary data from r into data. Bytes are read and
// decoded in BigEndian order
// https://golang.org/pkg/encoding/binary/#Read
func Read(r io.Reader, data ...interface{}) error {
for _, v := range data {
if err := binary.Read(r, binary.BigEndian, v); err != nil {
return err
}
}
return nil
}
// ReadUntil reads from r untin delim is found
func ReadUntil(r io.Reader, delim byte) ([]byte, error) {
if bufr, ok := r.(*bufio.Reader); ok {
return ReadUntilFromBufioReader(bufr, delim)
}
var buf [1]byte
value := make([]byte, 0, 16)
for {
if _, err := io.ReadFull(r, buf[:]); err != nil {
if err == io.EOF {
return nil, err
}
return nil, err
}
if buf[0] == delim {
return value, nil
}
value = append(value, buf[0])
}
}
// ReadUntilFromBufioReader is like bufio.ReadBytes but drops the delimiter
// from the result.
func ReadUntilFromBufioReader(r *bufio.Reader, delim byte) ([]byte, error) {
value, err := r.ReadBytes(delim)
if err != nil || len(value) == 0 {
return nil, err
}
return value[:len(value)-1], nil
}
// ReadVariableWidthInt reads and returns an int in Git VLQ special format:
//
// Ordinary VLQ has some redundancies, example: the number 358 can be
// encoded as the 2-octet VLQ 0x8166 or the 3-octet VLQ 0x808166 or the
// 4-octet VLQ 0x80808166 and so forth.
//
// To avoid these redundancies, the VLQ format used in Git removes this
// prepending redundancy and extends the representable range of shorter
// VLQs by adding an offset to VLQs of 2 or more octets in such a way
// that the lowest possible value for such an (N+1)-octet VLQ becomes
// exactly one more than the maximum possible value for an N-octet VLQ.
// In particular, since a 1-octet VLQ can store a maximum value of 127,
// the minimum 2-octet VLQ (0x8000) is assigned the value 128 instead of
// 0. Conversely, the maximum value of such a 2-octet VLQ (0xff7f) is
// 16511 instead of just 16383. Similarly, the minimum 3-octet VLQ
// (0x808000) has a value of 16512 instead of zero, which means
// that the maximum 3-octet VLQ (0xffff7f) is 2113663 instead of
// just 2097151. And so forth.
//
// This is how the offset is saved in C:
//
// dheader[pos] = ofs & 127;
// while (ofs >>= 7)
// dheader[--pos] = 128 | (--ofs & 127);
//
func ReadVariableWidthInt(r io.Reader) (int64, error) {
var c byte
if err := Read(r, &c); err != nil {
return 0, err
}
var v = int64(c & maskLength)
for c&maskContinue > 0 {
v++
if err := Read(r, &c); err != nil {
return 0, err
}
v = (v << lengthBits) + int64(c&maskLength)
}
return v, nil
}
const (
maskContinue = uint8(128) // 1000 000
maskLength = uint8(127) // 0111 1111
lengthBits = uint8(7) // subsequent bytes has 7 bits to store the length
)
// ReadUint64 reads 8 bytes and returns them as a BigEndian uint32
func ReadUint64(r io.Reader) (uint64, error) {
var v uint64
if err := binary.Read(r, binary.BigEndian, &v); err != nil {
return 0, err
}
return v, nil
}
// ReadUint32 reads 4 bytes and returns them as a BigEndian uint32
func ReadUint32(r io.Reader) (uint32, error) {
var v uint32
if err := binary.Read(r, binary.BigEndian, &v); err != nil {
return 0, err
}
return v, nil
}
// ReadUint16 reads 2 bytes and returns them as a BigEndian uint16
func ReadUint16(r io.Reader) (uint16, error) {
var v uint16
if err := binary.Read(r, binary.BigEndian, &v); err != nil {
return 0, err
}
return v, nil
}
// ReadHash reads a plumbing.Hash from r
func ReadHash(r io.Reader) (plumbing.Hash, error) {
var h plumbing.Hash
if err := binary.Read(r, binary.BigEndian, h[:]); err != nil {
return plumbing.ZeroHash, err
}
return h, nil
}
const sniffLen = 8000
// IsBinary detects if data is a binary value based on:
// http://git.kernel.org/cgit/git/git.git/tree/xdiff-interface.c?id=HEAD#n198
func IsBinary(r io.Reader) (bool, error) {
reader := bufio.NewReader(r)
c := 0
for {
if c == sniffLen {
break
}
b, err := reader.ReadByte()
if err == io.EOF {
break
}
if err != nil {
return false, err
}
if b == byte(0) {
return true, nil
}
c++
}
return false, nil
}
go-git-5.13.2/utils/binary/read_test.go 0000664 0000000 0000000 00000005335 14744245500 0017730 0 ustar 00root root 0000000 0000000 package binary
import (
"bufio"
"bytes"
"encoding/binary"
"testing"
"github.com/go-git/go-git/v5/plumbing"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type BinarySuite struct{}
var _ = Suite(&BinarySuite{})
func (s *BinarySuite) TestRead(c *C) {
buf := bytes.NewBuffer(nil)
err := binary.Write(buf, binary.BigEndian, int64(42))
c.Assert(err, IsNil)
err = binary.Write(buf, binary.BigEndian, int32(42))
c.Assert(err, IsNil)
var i64 int64
var i32 int32
err = Read(buf, &i64, &i32)
c.Assert(err, IsNil)
c.Assert(i64, Equals, int64(42))
c.Assert(i32, Equals, int32(42))
}
func (s *BinarySuite) TestReadUntil(c *C) {
buf := bytes.NewBuffer([]byte("foo bar"))
b, err := ReadUntil(buf, ' ')
c.Assert(err, IsNil)
c.Assert(b, HasLen, 3)
c.Assert(string(b), Equals, "foo")
}
func (s *BinarySuite) TestReadUntilFromBufioReader(c *C) {
buf := bufio.NewReader(bytes.NewBuffer([]byte("foo bar")))
b, err := ReadUntilFromBufioReader(buf, ' ')
c.Assert(err, IsNil)
c.Assert(b, HasLen, 3)
c.Assert(string(b), Equals, "foo")
}
func (s *BinarySuite) TestReadVariableWidthInt(c *C) {
buf := bytes.NewBuffer([]byte{129, 110})
i, err := ReadVariableWidthInt(buf)
c.Assert(err, IsNil)
c.Assert(i, Equals, int64(366))
}
func (s *BinarySuite) TestReadVariableWidthIntShort(c *C) {
buf := bytes.NewBuffer([]byte{19})
i, err := ReadVariableWidthInt(buf)
c.Assert(err, IsNil)
c.Assert(i, Equals, int64(19))
}
func (s *BinarySuite) TestReadUint32(c *C) {
buf := bytes.NewBuffer(nil)
err := binary.Write(buf, binary.BigEndian, uint32(42))
c.Assert(err, IsNil)
i32, err := ReadUint32(buf)
c.Assert(err, IsNil)
c.Assert(i32, Equals, uint32(42))
}
func (s *BinarySuite) TestReadUint16(c *C) {
buf := bytes.NewBuffer(nil)
err := binary.Write(buf, binary.BigEndian, uint16(42))
c.Assert(err, IsNil)
i32, err := ReadUint16(buf)
c.Assert(err, IsNil)
c.Assert(i32, Equals, uint16(42))
}
func (s *BinarySuite) TestReadHash(c *C) {
expected := plumbing.NewHash("43aec75c611f22c73b27ece2841e6ccca592f285")
buf := bytes.NewBuffer(nil)
err := binary.Write(buf, binary.BigEndian, expected)
c.Assert(err, IsNil)
hash, err := ReadHash(buf)
c.Assert(err, IsNil)
c.Assert(hash.String(), Equals, expected.String())
}
func (s *BinarySuite) TestIsBinary(c *C) {
buf := bytes.NewBuffer(nil)
buf.Write(bytes.Repeat([]byte{'A'}, sniffLen))
buf.Write([]byte{0})
ok, err := IsBinary(buf)
c.Assert(err, IsNil)
c.Assert(ok, Equals, false)
buf.Reset()
buf.Write(bytes.Repeat([]byte{'A'}, sniffLen-1))
buf.Write([]byte{0})
ok, err = IsBinary(buf)
c.Assert(err, IsNil)
c.Assert(ok, Equals, true)
buf.Reset()
buf.Write(bytes.Repeat([]byte{'A'}, 10))
ok, err = IsBinary(buf)
c.Assert(err, IsNil)
c.Assert(ok, Equals, false)
}
go-git-5.13.2/utils/binary/write.go 0000664 0000000 0000000 00000002221 14744245500 0017077 0 ustar 00root root 0000000 0000000 package binary
import (
"encoding/binary"
"io"
)
// Write writes the binary representation of data into w, using BigEndian order
// https://golang.org/pkg/encoding/binary/#Write
func Write(w io.Writer, data ...interface{}) error {
for _, v := range data {
if err := binary.Write(w, binary.BigEndian, v); err != nil {
return err
}
}
return nil
}
func WriteVariableWidthInt(w io.Writer, n int64) error {
buf := []byte{byte(n & 0x7f)}
n >>= 7
for n != 0 {
n--
buf = append([]byte{0x80 | (byte(n & 0x7f))}, buf...)
n >>= 7
}
_, err := w.Write(buf)
return err
}
// WriteUint64 writes the binary representation of a uint64 into w, in BigEndian
// order
func WriteUint64(w io.Writer, value uint64) error {
return binary.Write(w, binary.BigEndian, value)
}
// WriteUint32 writes the binary representation of a uint32 into w, in BigEndian
// order
func WriteUint32(w io.Writer, value uint32) error {
return binary.Write(w, binary.BigEndian, value)
}
// WriteUint16 writes the binary representation of a uint16 into w, in BigEndian
// order
func WriteUint16(w io.Writer, value uint16) error {
return binary.Write(w, binary.BigEndian, value)
}
go-git-5.13.2/utils/binary/write_test.go 0000664 0000000 0000000 00000002612 14744245500 0020142 0 ustar 00root root 0000000 0000000 package binary
import (
"bytes"
"encoding/binary"
. "gopkg.in/check.v1"
)
func (s *BinarySuite) TestWrite(c *C) {
expected := bytes.NewBuffer(nil)
err := binary.Write(expected, binary.BigEndian, int64(42))
c.Assert(err, IsNil)
err = binary.Write(expected, binary.BigEndian, int32(42))
c.Assert(err, IsNil)
buf := bytes.NewBuffer(nil)
err = Write(buf, int64(42), int32(42))
c.Assert(err, IsNil)
c.Assert(buf, DeepEquals, expected)
}
func (s *BinarySuite) TestWriteUint32(c *C) {
expected := bytes.NewBuffer(nil)
err := binary.Write(expected, binary.BigEndian, int32(42))
c.Assert(err, IsNil)
buf := bytes.NewBuffer(nil)
err = WriteUint32(buf, 42)
c.Assert(err, IsNil)
c.Assert(buf, DeepEquals, expected)
}
func (s *BinarySuite) TestWriteUint16(c *C) {
expected := bytes.NewBuffer(nil)
err := binary.Write(expected, binary.BigEndian, int16(42))
c.Assert(err, IsNil)
buf := bytes.NewBuffer(nil)
err = WriteUint16(buf, 42)
c.Assert(err, IsNil)
c.Assert(buf, DeepEquals, expected)
}
func (s *BinarySuite) TestWriteVariableWidthInt(c *C) {
buf := bytes.NewBuffer(nil)
err := WriteVariableWidthInt(buf, 366)
c.Assert(err, IsNil)
c.Assert(buf.Bytes(), DeepEquals, []byte{129, 110})
}
func (s *BinarySuite) TestWriteVariableWidthIntShort(c *C) {
buf := bytes.NewBuffer(nil)
err := WriteVariableWidthInt(buf, 19)
c.Assert(err, IsNil)
c.Assert(buf.Bytes(), DeepEquals, []byte{19})
}
go-git-5.13.2/utils/blame2humantest.bash 0000775 0000000 0000000 00000002072 14744245500 0020073 0 ustar 00root root 0000000 0000000 #!/bin/bash
set -e
repo=`git remote show origin | grep Fetch | cut -d' ' -f5`
branch="master"
if [ "$#" -eq 1 ] ; then
commit=`git log | head -1 | cut -d' ' -f2`
path=$1
elif [ "$#" -eq 2 ] ; then
commit=$1
path=$2
else
echo "bad number of parameters" > /dev/stderr
echo > /dev/stderr
echo " try with: [commit] path" > /dev/stderr
exit
fi
blames=`git blame --root $path | cut -d' ' -f1`
declare -a blame
i=0
for shortBlame in $blames ; do
blame[$i]=`git show $shortBlame | head -1 | cut -d' ' -f2`
i=`expr $i + 1`
done
# some remotes have the .git, other don't,
# repoDot makes sure all have
repoDot="${repo%.git}.git"
echo -e "\t{\"${repoDot}\", \"${branch}\", \"${commit}\", \"${path}\", concat(&[]string{},"
prev=""
count=1
for i in ${blame[@]} ; do
if [ "${prev}" == "" ] ; then
prev=$i
elif [ "$prev" == "$i" ] ; then
count=`expr $count + 1`
else
echo -e "\t\trepeat(\"${prev}\", $count),"
count=1
prev=$i
fi
done
echo -e "\t\trepeat(\"${prev}\", $count),"
echo -e "\t)},"
go-git-5.13.2/utils/diff/ 0000775 0000000 0000000 00000000000 14744245500 0015045 5 ustar 00root root 0000000 0000000 go-git-5.13.2/utils/diff/diff.go 0000664 0000000 0000000 00000004074 14744245500 0016311 0 ustar 00root root 0000000 0000000 // Package diff implements line oriented diffs, similar to the ancient
// Unix diff command.
//
// The current implementation is just a wrapper around Sergi's
// go-diff/diffmatchpatch library, which is a go port of Neil
// Fraser's google-diff-match-patch code
package diff
import (
"bytes"
"time"
"github.com/sergi/go-diff/diffmatchpatch"
)
// Do computes the (line oriented) modifications needed to turn the src
// string into the dst string. The underlying algorithm is Meyers,
// its complexity is O(N*d) where N is min(lines(src), lines(dst)) and d
// is the size of the diff.
func Do(src, dst string) (diffs []diffmatchpatch.Diff) {
// the default timeout is time.Second which may be too small under heavy load
return DoWithTimeout(src, dst, time.Hour)
}
// DoWithTimeout computes the (line oriented) modifications needed to turn the src
// string into the dst string. The `timeout` argument specifies the maximum
// amount of time it is allowed to spend in this function. If the timeout
// is exceeded, the parts of the strings which were not considered are turned into
// a bulk delete+insert and the half-baked suboptimal result is returned at once.
// The underlying algorithm is Meyers, its complexity is O(N*d) where N is
// min(lines(src), lines(dst)) and d is the size of the diff.
func DoWithTimeout(src, dst string, timeout time.Duration) (diffs []diffmatchpatch.Diff) {
dmp := diffmatchpatch.New()
dmp.DiffTimeout = timeout
wSrc, wDst, warray := dmp.DiffLinesToRunes(src, dst)
diffs = dmp.DiffMainRunes(wSrc, wDst, false)
diffs = dmp.DiffCharsToLines(diffs, warray)
return diffs
}
// Dst computes and returns the destination text.
func Dst(diffs []diffmatchpatch.Diff) string {
var text bytes.Buffer
for _, d := range diffs {
if d.Type != diffmatchpatch.DiffDelete {
text.WriteString(d.Text)
}
}
return text.String()
}
// Src computes and returns the source text
func Src(diffs []diffmatchpatch.Diff) string {
var text bytes.Buffer
for _, d := range diffs {
if d.Type != diffmatchpatch.DiffInsert {
text.WriteString(d.Text)
}
}
return text.String()
}
go-git-5.13.2/utils/diff/diff_ext_test.go 0000664 0000000 0000000 00000006125 14744245500 0020227 0 ustar 00root root 0000000 0000000 package diff_test
import (
"testing"
"github.com/go-git/go-git/v5/utils/diff"
"github.com/sergi/go-diff/diffmatchpatch"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type suiteCommon struct{}
var _ = Suite(&suiteCommon{})
var diffTests = [...]struct {
src string // the src string to diff
dst string // the dst string to diff
}{
// equal inputs
{"", ""},
{"a", "a"},
{"a\n", "a\n"},
{"a\nb", "a\nb"},
{"a\nb\n", "a\nb\n"},
{"a\nb\nc", "a\nb\nc"},
{"a\nb\nc\n", "a\nb\nc\n"},
// missing '\n'
{"", "\n"},
{"\n", ""},
{"a", "a\n"},
{"a\n", "a"},
{"a\nb", "a\nb"},
{"a\nb\n", "a\nb\n"},
{"a\nb\nc", "a\nb\nc"},
{"a\nb\nc\n", "a\nb\nc\n"},
// generic
{"a\nbbbbb\n\tccc\ndd\n\tfffffffff\n", "bbbbb\n\tccc\n\tDD\n\tffff\n"},
}
func (s *suiteCommon) TestAll(c *C) {
for i, t := range diffTests {
diffs := diff.Do(t.src, t.dst)
src := diff.Src(diffs)
dst := diff.Dst(diffs)
c.Assert(src, Equals, t.src, Commentf("subtest %d, src=%q, dst=%q, bad calculated src", i, t.src, t.dst))
c.Assert(dst, Equals, t.dst, Commentf("subtest %d, src=%q, dst=%q, bad calculated dst", i, t.src, t.dst))
}
}
var doTests = [...]struct {
src, dst string
exp []diffmatchpatch.Diff
}{
{
src: "",
dst: "",
exp: []diffmatchpatch.Diff{},
},
{
src: "a",
dst: "a",
exp: []diffmatchpatch.Diff{
{
Type: 0,
Text: "a",
},
},
},
{
src: "",
dst: "abc\ncba",
exp: []diffmatchpatch.Diff{
{
Type: 1,
Text: "abc\ncba",
},
},
},
{
src: "abc\ncba",
dst: "",
exp: []diffmatchpatch.Diff{
{
Type: -1,
Text: "abc\ncba",
},
},
},
{
src: "abc\nbcd\ncde",
dst: "000\nabc\n111\nBCD\n",
exp: []diffmatchpatch.Diff{
{Type: 1, Text: "000\n"},
{Type: 0, Text: "abc\n"},
{Type: -1, Text: "bcd\ncde"},
{Type: 1, Text: "111\nBCD\n"},
},
},
{
src: "A\nB\nC\nD\nE\nF\nG\nH\nI\nJ\nK\nL\nM\nN\nÑ\nO\nP\nQ\nR\nS\nT\nU\nV\nW\nX\nY\nZ",
dst: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\nY\nZ",
exp: []diffmatchpatch.Diff{
{Type: -1, Text: "A\n"},
{Type: 0, Text: "B\nC\nD\nE\nF\nG\n"},
{Type: -1, Text: "H\n"},
{Type: 0, Text: "I\nJ\nK\nL\nM\nN\n"},
{Type: -1, Text: "Ñ\n"},
{Type: 0, Text: "O\nP\nQ\nR\nS\nT\n"},
{Type: -1, Text: "U\n"},
{Type: 0, Text: "V\nW\nX\nY\nZ"},
},
},
{
src: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\nY\nZ",
dst: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\nY\n",
exp: []diffmatchpatch.Diff{
{Type: 0, Text: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\nY\n"},
{Type: -1, Text: "Z"},
},
},
{
src: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\nY\nZ",
dst: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\nY",
exp: []diffmatchpatch.Diff{
{Type: 0, Text: "B\nC\nD\nE\nF\nG\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nV\nW\nX\n"},
{Type: -1, Text: "Y\nZ"},
{Type: 1, Text: "Y"},
},
},
}
func (s *suiteCommon) TestDo(c *C) {
for i, t := range doTests {
diffs := diff.Do(t.src, t.dst)
c.Assert(diffs, DeepEquals, t.exp, Commentf("subtest %d", i))
}
}
go-git-5.13.2/utils/ioutil/ 0000775 0000000 0000000 00000000000 14744245500 0015442 5 ustar 00root root 0000000 0000000 go-git-5.13.2/utils/ioutil/common.go 0000664 0000000 0000000 00000012551 14744245500 0017265 0 ustar 00root root 0000000 0000000 // Package ioutil implements some I/O utility functions.
package ioutil
import (
"bufio"
"context"
"errors"
"io"
ctxio "github.com/jbenet/go-context/io"
)
type readPeeker interface {
io.Reader
Peek(int) ([]byte, error)
}
var (
ErrEmptyReader = errors.New("reader is empty")
)
// NonEmptyReader takes a reader and returns it if it is not empty, or
// `ErrEmptyReader` if it is empty. If there is an error when reading the first
// byte of the given reader, it will be propagated.
func NonEmptyReader(r io.Reader) (io.Reader, error) {
pr, ok := r.(readPeeker)
if !ok {
pr = bufio.NewReader(r)
}
_, err := pr.Peek(1)
if err == io.EOF {
return nil, ErrEmptyReader
}
if err != nil {
return nil, err
}
return pr, nil
}
type readCloser struct {
io.Reader
closer io.Closer
}
func (r *readCloser) Close() error {
return r.closer.Close()
}
// NewReadCloser creates an `io.ReadCloser` with the given `io.Reader` and
// `io.Closer`.
func NewReadCloser(r io.Reader, c io.Closer) io.ReadCloser {
return &readCloser{Reader: r, closer: c}
}
type readCloserCloser struct {
io.ReadCloser
closer func() error
}
func (r *readCloserCloser) Close() (err error) {
defer func() {
if err == nil {
err = r.closer()
return
}
_ = r.closer()
}()
return r.ReadCloser.Close()
}
// NewReadCloserWithCloser creates an `io.ReadCloser` with the given `io.ReaderCloser` and
// `io.Closer` that ensures that the closer is closed on close
func NewReadCloserWithCloser(r io.ReadCloser, c func() error) io.ReadCloser {
return &readCloserCloser{ReadCloser: r, closer: c}
}
type writeCloser struct {
io.Writer
closer io.Closer
}
func (r *writeCloser) Close() error {
return r.closer.Close()
}
// NewWriteCloser creates an `io.WriteCloser` with the given `io.Writer` and
// `io.Closer`.
func NewWriteCloser(w io.Writer, c io.Closer) io.WriteCloser {
return &writeCloser{Writer: w, closer: c}
}
type writeNopCloser struct {
io.Writer
}
func (writeNopCloser) Close() error { return nil }
// WriteNopCloser returns a WriteCloser with a no-op Close method wrapping
// the provided Writer w.
func WriteNopCloser(w io.Writer) io.WriteCloser {
return writeNopCloser{w}
}
type readerAtAsReader struct {
io.ReaderAt
offset int64
}
func (r *readerAtAsReader) Read(bs []byte) (int, error) {
n, err := r.ReaderAt.ReadAt(bs, r.offset)
r.offset += int64(n)
return n, err
}
func NewReaderUsingReaderAt(r io.ReaderAt, offset int64) io.Reader {
return &readerAtAsReader{
ReaderAt: r,
offset: offset,
}
}
// CheckClose calls Close on the given io.Closer. If the given *error points to
// nil, it will be assigned the error returned by Close. Otherwise, any error
// returned by Close will be ignored. CheckClose is usually called with defer.
func CheckClose(c io.Closer, err *error) {
if cerr := c.Close(); cerr != nil && *err == nil {
*err = cerr
}
}
// NewContextWriter wraps a writer to make it respect given Context.
// If there is a blocking write, the returned Writer will return whenever the
// context is cancelled (the return values are n=0 and err=ctx.Err()).
func NewContextWriter(ctx context.Context, w io.Writer) io.Writer {
return ctxio.NewWriter(ctx, w)
}
// NewContextReader wraps a reader to make it respect given Context.
// If there is a blocking read, the returned Reader will return whenever the
// context is cancelled (the return values are n=0 and err=ctx.Err()).
func NewContextReader(ctx context.Context, r io.Reader) io.Reader {
return ctxio.NewReader(ctx, r)
}
// NewContextWriteCloser as NewContextWriter but with io.Closer interface.
func NewContextWriteCloser(ctx context.Context, w io.WriteCloser) io.WriteCloser {
ctxw := ctxio.NewWriter(ctx, w)
return NewWriteCloser(ctxw, w)
}
// NewContextReadCloser as NewContextReader but with io.Closer interface.
func NewContextReadCloser(ctx context.Context, r io.ReadCloser) io.ReadCloser {
ctxr := ctxio.NewReader(ctx, r)
return NewReadCloser(ctxr, r)
}
type readerOnError struct {
io.Reader
notify func(error)
}
// NewReaderOnError returns a io.Reader that call the notify function when an
// unexpected (!io.EOF) error happens, after call Read function.
func NewReaderOnError(r io.Reader, notify func(error)) io.Reader {
return &readerOnError{r, notify}
}
// NewReadCloserOnError returns a io.ReadCloser that call the notify function
// when an unexpected (!io.EOF) error happens, after call Read function.
func NewReadCloserOnError(r io.ReadCloser, notify func(error)) io.ReadCloser {
return NewReadCloser(NewReaderOnError(r, notify), r)
}
func (r *readerOnError) Read(buf []byte) (n int, err error) {
n, err = r.Reader.Read(buf)
if err != nil && err != io.EOF {
r.notify(err)
}
return
}
type writerOnError struct {
io.Writer
notify func(error)
}
// NewWriterOnError returns a io.Writer that call the notify function when an
// unexpected (!io.EOF) error happens, after call Write function.
func NewWriterOnError(w io.Writer, notify func(error)) io.Writer {
return &writerOnError{w, notify}
}
// NewWriteCloserOnError returns a io.WriteCloser that call the notify function
// when an unexpected (!io.EOF) error happens, after call Write function.
func NewWriteCloserOnError(w io.WriteCloser, notify func(error)) io.WriteCloser {
return NewWriteCloser(NewWriterOnError(w, notify), w)
}
func (r *writerOnError) Write(p []byte) (n int, err error) {
n, err = r.Writer.Write(p)
if err != nil && err != io.EOF {
r.notify(err)
}
return
}
go-git-5.13.2/utils/ioutil/common_test.go 0000664 0000000 0000000 00000007067 14744245500 0020332 0 ustar 00root root 0000000 0000000 package ioutil
import (
"bytes"
"context"
"io"
"strings"
"testing"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type CommonSuite struct{}
var _ = Suite(&CommonSuite{})
type closer struct {
called int
}
func (c *closer) Close() error {
c.called++
return nil
}
func (s *CommonSuite) TestNonEmptyReader_Empty(c *C) {
var buf bytes.Buffer
r, err := NonEmptyReader(&buf)
c.Assert(err, Equals, ErrEmptyReader)
c.Assert(r, IsNil)
}
func (s *CommonSuite) TestNonEmptyReader_NonEmpty(c *C) {
buf := bytes.NewBuffer([]byte("1"))
r, err := NonEmptyReader(buf)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
read, err := io.ReadAll(r)
c.Assert(err, IsNil)
c.Assert(string(read), Equals, "1")
}
func (s *CommonSuite) TestNewReadCloser(c *C) {
buf := bytes.NewBuffer([]byte("1"))
closer := &closer{}
r := NewReadCloser(buf, closer)
read, err := io.ReadAll(r)
c.Assert(err, IsNil)
c.Assert(string(read), Equals, "1")
c.Assert(r.Close(), IsNil)
c.Assert(closer.called, Equals, 1)
}
func (s *CommonSuite) TestNewContextReader(c *C) {
buf := bytes.NewBuffer([]byte("12"))
ctx, close := context.WithCancel(context.Background())
r := NewContextReader(ctx, buf)
b := make([]byte, 1)
n, err := r.Read(b)
c.Assert(n, Equals, 1)
c.Assert(err, IsNil)
close()
n, err = r.Read(b)
c.Assert(n, Equals, 0)
c.Assert(err, NotNil)
}
func (s *CommonSuite) TestNewContextReadCloser(c *C) {
buf := NewReadCloser(bytes.NewBuffer([]byte("12")), &closer{})
ctx, close := context.WithCancel(context.Background())
r := NewContextReadCloser(ctx, buf)
b := make([]byte, 1)
n, err := r.Read(b)
c.Assert(n, Equals, 1)
c.Assert(err, IsNil)
close()
n, err = r.Read(b)
c.Assert(n, Equals, 0)
c.Assert(err, NotNil)
c.Assert(r.Close(), IsNil)
}
func (s *CommonSuite) TestNewContextWriter(c *C) {
buf := bytes.NewBuffer(nil)
ctx, close := context.WithCancel(context.Background())
r := NewContextWriter(ctx, buf)
n, err := r.Write([]byte("1"))
c.Assert(n, Equals, 1)
c.Assert(err, IsNil)
close()
n, err = r.Write([]byte("1"))
c.Assert(n, Equals, 0)
c.Assert(err, NotNil)
}
func (s *CommonSuite) TestNewContextWriteCloser(c *C) {
buf := NewWriteCloser(bytes.NewBuffer(nil), &closer{})
ctx, close := context.WithCancel(context.Background())
w := NewContextWriteCloser(ctx, buf)
n, err := w.Write([]byte("1"))
c.Assert(n, Equals, 1)
c.Assert(err, IsNil)
close()
n, err = w.Write([]byte("1"))
c.Assert(n, Equals, 0)
c.Assert(err, NotNil)
c.Assert(w.Close(), IsNil)
}
func (s *CommonSuite) TestNewWriteCloserOnError(c *C) {
buf := NewWriteCloser(bytes.NewBuffer(nil), &closer{})
ctx, close := context.WithCancel(context.Background())
var called error
w := NewWriteCloserOnError(NewContextWriteCloser(ctx, buf), func(err error) {
called = err
})
close()
w.Write(nil)
c.Assert(called, NotNil)
}
func (s *CommonSuite) TestNewReadCloserOnError(c *C) {
buf := NewReadCloser(bytes.NewBuffer(nil), &closer{})
ctx, close := context.WithCancel(context.Background())
var called error
w := NewReadCloserOnError(NewContextReadCloser(ctx, buf), func(err error) {
called = err
})
close()
w.Read(nil)
c.Assert(called, NotNil)
}
func ExampleCheckClose() {
// CheckClose is commonly used with named return values
f := func() (err error) {
// Get a io.ReadCloser
r := io.NopCloser(strings.NewReader("foo"))
// defer CheckClose call with an io.Closer and pointer to error
defer CheckClose(r, &err)
// ... work with r ...
// if err is not nil, CheckClose will assign any close errors to it
return err
}
err := f()
if err != nil {
panic(err)
}
}
go-git-5.13.2/utils/merkletrie/ 0000775 0000000 0000000 00000000000 14744245500 0016300 5 ustar 00root root 0000000 0000000 go-git-5.13.2/utils/merkletrie/change.go 0000664 0000000 0000000 00000006643 14744245500 0020065 0 ustar 00root root 0000000 0000000 package merkletrie
import (
"errors"
"fmt"
"io"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
var (
ErrEmptyFileName = errors.New("empty filename in tree entry")
)
// Action values represent the kind of things a Change can represent:
// insertion, deletions or modifications of files.
type Action int
// The set of possible actions in a change.
const (
_ Action = iota
Insert
Delete
Modify
)
// String returns the action as a human readable text.
func (a Action) String() string {
switch a {
case Insert:
return "Insert"
case Delete:
return "Delete"
case Modify:
return "Modify"
default:
panic(fmt.Sprintf("unsupported action: %d", a))
}
}
// A Change value represent how a noder has change between to merkletries.
type Change struct {
// The noder before the change or nil if it was inserted.
From noder.Path
// The noder after the change or nil if it was deleted.
To noder.Path
}
// Action is convenience method that returns what Action c represents.
func (c *Change) Action() (Action, error) {
if c.From == nil && c.To == nil {
return Action(0), fmt.Errorf("malformed change: nil from and to")
}
if c.From == nil {
return Insert, nil
}
if c.To == nil {
return Delete, nil
}
return Modify, nil
}
// NewInsert returns a new Change representing the insertion of n.
func NewInsert(n noder.Path) Change { return Change{To: n} }
// NewDelete returns a new Change representing the deletion of n.
func NewDelete(n noder.Path) Change { return Change{From: n} }
// NewModify returns a new Change representing that a has been modified and
// it is now b.
func NewModify(a, b noder.Path) Change {
return Change{
From: a,
To: b,
}
}
// String returns a single change in human readable form, using the
// format: '<' + action + space + path + '>'. The contents of the file
// before or after the change are not included in this format.
//
// Example: inserting a file at the path a/b/c.txt will return "".
func (c Change) String() string {
action, err := c.Action()
if err != nil {
panic(err)
}
var path string
if action == Delete {
path = c.From.String()
} else {
path = c.To.String()
}
return fmt.Sprintf("<%s %s>", action, path)
}
// Changes is a list of changes between to merkletries.
type Changes []Change
// NewChanges returns an empty list of changes.
func NewChanges() Changes {
return Changes{}
}
// Add adds the change c to the list of changes.
func (l *Changes) Add(c Change) {
*l = append(*l, c)
}
// AddRecursiveInsert adds the required changes to insert all the
// file-like noders found in root, recursively.
func (l *Changes) AddRecursiveInsert(root noder.Path) error {
return l.addRecursive(root, NewInsert)
}
// AddRecursiveDelete adds the required changes to delete all the
// file-like noders found in root, recursively.
func (l *Changes) AddRecursiveDelete(root noder.Path) error {
return l.addRecursive(root, NewDelete)
}
type noderToChangeFn func(noder.Path) Change // NewInsert or NewDelete
func (l *Changes) addRecursive(root noder.Path, ctor noderToChangeFn) error {
if root.String() == "" {
return ErrEmptyFileName
}
if !root.IsDir() {
l.Add(ctor(root))
return nil
}
i, err := NewIterFromPath(root)
if err != nil {
return err
}
var current noder.Path
for {
if current, err = i.Step(); err != nil {
if err == io.EOF {
break
}
return err
}
if current.IsDir() {
continue
}
l.Add(ctor(current))
}
return nil
}
go-git-5.13.2/utils/merkletrie/change_test.go 0000664 0000000 0000000 00000004554 14744245500 0021123 0 ustar 00root root 0000000 0000000 package merkletrie_test
import (
"github.com/go-git/go-git/v5/utils/merkletrie"
"github.com/go-git/go-git/v5/utils/merkletrie/internal/fsnoder"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
. "gopkg.in/check.v1"
)
type ChangeSuite struct{}
var _ = Suite(&ChangeSuite{})
func (s *ChangeSuite) TestActionString(c *C) {
action := merkletrie.Insert
c.Assert(action.String(), Equals, "Insert")
action = merkletrie.Delete
c.Assert(action.String(), Equals, "Delete")
action = merkletrie.Modify
c.Assert(action.String(), Equals, "Modify")
}
func (s *ChangeSuite) TestUnsupportedAction(c *C) {
a := merkletrie.Action(42)
c.Assert(a.String, PanicMatches, "unsupported action.*")
}
func (s ChangeSuite) TestEmptyChanges(c *C) {
ret := merkletrie.NewChanges()
p := noder.Path{}
err := ret.AddRecursiveInsert(p)
c.Assert(err, Equals, merkletrie.ErrEmptyFileName)
err = ret.AddRecursiveDelete(p)
c.Assert(err, Equals, merkletrie.ErrEmptyFileName)
}
func (s ChangeSuite) TestNewInsert(c *C) {
tree, err := fsnoder.New("(a(b(z<>)))")
c.Assert(err, IsNil)
path := find(c, tree, "z")
change := merkletrie.NewInsert(path)
c.Assert(change.String(), Equals, "")
shortPath := noder.Path([]noder.Noder{path.Last()})
change = merkletrie.NewInsert(shortPath)
c.Assert(change.String(), Equals, "")
}
func (s ChangeSuite) TestNewDelete(c *C) {
tree, err := fsnoder.New("(a(b(z<>)))")
c.Assert(err, IsNil)
path := find(c, tree, "z")
change := merkletrie.NewDelete(path)
c.Assert(change.String(), Equals, "")
shortPath := noder.Path([]noder.Noder{path.Last()})
change = merkletrie.NewDelete(shortPath)
c.Assert(change.String(), Equals, "")
}
func (s ChangeSuite) TestNewModify(c *C) {
tree1, err := fsnoder.New("(a(b(z<>)))")
c.Assert(err, IsNil)
path1 := find(c, tree1, "z")
tree2, err := fsnoder.New("(a(b(z<1>)))")
c.Assert(err, IsNil)
path2 := find(c, tree2, "z")
change := merkletrie.NewModify(path1, path2)
c.Assert(change.String(), Equals, "")
shortPath1 := noder.Path([]noder.Noder{path1.Last()})
shortPath2 := noder.Path([]noder.Noder{path2.Last()})
change = merkletrie.NewModify(shortPath1, shortPath2)
c.Assert(change.String(), Equals, "")
}
func (s ChangeSuite) TestMalformedChange(c *C) {
change := merkletrie.Change{}
c.Assert(change.String, PanicMatches, "malformed change.*")
}
go-git-5.13.2/utils/merkletrie/difftree.go 0000664 0000000 0000000 00000035274 14744245500 0020432 0 ustar 00root root 0000000 0000000 package merkletrie
// The focus of this difftree implementation is to save time by
// skipping whole directories if their hash is the same in both
// trees.
//
// The diff algorithm implemented here is based on the doubleiter
// type defined in this same package; we will iterate over both
// trees at the same time, while comparing the current noders in
// each iterator. Depending on how they differ we will output the
// corresponding changes and move the iterators further over both
// trees.
//
// The table below shows all the possible comparison results, along
// with what changes should we produce and how to advance the
// iterators.
//
// The table is implemented by the switches in this function,
// diffTwoNodes, diffTwoNodesSameName and diffTwoDirs.
//
// Many Bothans died to bring us this information, make sure you
// understand the table before modifying this code.
// # Cases
//
// When comparing noders in both trees you will find yourself in
// one of 169 possible cases, but if we ignore moves, we can
// simplify a lot the search space into the following table:
//
// - "-": nothing, no file or directory
// - a<>: an empty file named "a".
// - a<1>: a file named "a", with "1" as its contents.
// - a<2>: a file named "a", with "2" as its contents.
// - a(): an empty dir named "a".
// - a(...): a dir named "a", with some files and/or dirs inside (possibly
// empty).
// - a(;;;): a dir named "a", with some other files and/or dirs inside
// (possibly empty), which different from the ones in "a(...)".
//
// \ to - a<> a<1> a<2> a() a(...) a(;;;)
// from \
// - 00 01 02 03 04 05 06
// a<> 10 11 12 13 14 15 16
// a<1> 20 21 22 23 24 25 26
// a<2> 30 31 32 33 34 35 36
// a() 40 41 42 43 44 45 46
// a(...) 50 51 52 53 54 55 56
// a(;;;) 60 61 62 63 64 65 66
//
// Every (from, to) combination in the table is a special case, but
// some of them can be merged into some more general cases, for
// instance 11 and 22 can be merged into the general case: both
// noders are equal.
//
// Here is a full list of all the cases that are similar and how to
// merge them together into more general cases. Each general case
// is labeled with an uppercase letter for further reference, and it
// is followed by the pseudocode of the checks you have to perform
// on both noders to see if you are in such a case, the actions to
// perform (i.e. what changes to output) and how to advance the
// iterators of each tree to continue the comparison process.
//
// ## A. Impossible: 00
//
// ## B. Same thing on both sides: 11, 22, 33, 44, 55, 66
// - check: `SameName() && SameHash()`
// - action: do nothing.
// - advance: `FromNext(); ToNext()`
//
// ### C. To was created: 01, 02, 03, 04, 05, 06
// - check: `DifferentName() && ToBeforeFrom()`
// - action: insertRecursively(to)
// - advance: `ToNext()`
//
// ### D. From was deleted: 10, 20, 30, 40, 50, 60
// - check: `DifferentName() && FromBeforeTo()`
// - action: `DeleteRecursively(from)`
// - advance: `FromNext()`
//
// ### E. Empty file to file with contents: 12, 13
// - check: `SameName() && DifferentHash() && FromIsFile() &&
// ToIsFile() && FromIsEmpty()`
// - action: `modifyFile(from, to)`
// - advance: `FromNext()` or `FromStep()`
//
// ### E'. file with contents to empty file: 21, 31
// - check: `SameName() && DifferentHash() && FromIsFile() &&
// ToIsFile() && ToIsEmpty()`
// - action: `modifyFile(from, to)`
// - advance: `FromNext()` or `FromStep()`
//
// ### F. empty file to empty dir with the same name: 14
// - check: `SameName() && FromIsFile() && FromIsEmpty() &&
// ToIsDir() && ToIsEmpty()`
// - action: `DeleteFile(from); InsertEmptyDir(to)`
// - advance: `FromNext(); ToNext()`
//
// ### F'. empty dir to empty file of the same name: 41
// - check: `SameName() && FromIsDir() && FromIsEmpty &&
// ToIsFile() && ToIsEmpty()`
// - action: `DeleteEmptyDir(from); InsertFile(to)`
// - advance: `FromNext(); ToNext()` or step for any of them.
//
// ### G. empty file to non-empty dir of the same name: 15, 16
// - check: `SameName() && FromIsFile() && ToIsDir() &&
// FromIsEmpty() && ToIsNotEmpty()`
// - action: `DeleteFile(from); InsertDirRecursively(to)`
// - advance: `FromNext(); ToNext()`
//
// ### G'. non-empty dir to empty file of the same name: 51, 61
// - check: `SameName() && FromIsDir() && FromIsNotEmpty() &&
// ToIsFile() && FromIsEmpty()`
// - action: `DeleteDirRecursively(from); InsertFile(to)`
// - advance: `FromNext(); ToNext()`
//
// ### H. modify file contents: 23, 32
// - check: `SameName() && FromIsFile() && ToIsFile() &&
// FromIsNotEmpty() && ToIsNotEmpty()`
// - action: `ModifyFile(from, to)`
// - advance: `FromNext(); ToNext()`
//
// ### I. file with contents to empty dir: 24, 34
// - check: `SameName() && DifferentHash() && FromIsFile() &&
// FromIsNotEmpty() && ToIsDir() && ToIsEmpty()`
// - action: `DeleteFile(from); InsertEmptyDir(to)`
// - advance: `FromNext(); ToNext()`
//
// ### I'. empty dir to file with contents: 42, 43
// - check: `SameName() && DifferentHash() && FromIsDir() &&
// FromIsEmpty() && ToIsFile() && ToIsEmpty()`
// - action: `DeleteDir(from); InsertFile(to)`
// - advance: `FromNext(); ToNext()`
//
// ### J. file with contents to dir with contents: 25, 26, 35, 36
// - check: `SameName() && DifferentHash() && FromIsFile() &&
// FromIsNotEmpty() && ToIsDir() && ToIsNotEmpty()`
// - action: `DeleteFile(from); InsertDirRecursively(to)`
// - advance: `FromNext(); ToNext()`
//
// ### J'. dir with contents to file with contents: 52, 62, 53, 63
// - check: `SameName() && DifferentHash() && FromIsDir() &&
// FromIsNotEmpty() && ToIsFile() && ToIsNotEmpty()`
// - action: `DeleteDirRecursively(from); InsertFile(to)`
// - advance: `FromNext(); ToNext()`
//
// ### K. empty dir to dir with contents: 45, 46
// - check: `SameName() && DifferentHash() && FromIsDir() &&
// FromIsEmpty() && ToIsDir() && ToIsNotEmpty()`
// - action: `InsertChildrenRecursively(to)`
// - advance: `FromNext(); ToNext()`
//
// ### K'. dir with contents to empty dir: 54, 64
// - check: `SameName() && DifferentHash() && FromIsDir() &&
// FromIsEmpty() && ToIsDir() && ToIsNotEmpty()`
// - action: `DeleteChildrenRecursively(from)`
// - advance: `FromNext(); ToNext()`
//
// ### L. dir with contents to dir with different contents: 56, 65
// - check: `SameName() && DifferentHash() && FromIsDir() &&
// FromIsNotEmpty() && ToIsDir() && ToIsNotEmpty()`
// - action: nothing
// - advance: `FromStep(); ToStep()`
//
//
// All these cases can be further simplified by a truth table
// reduction process, in which we gather similar checks together to
// make the final code easier to read and understand.
//
// The first 6 columns are the outputs of the checks to perform on
// both noders. I have labeled them 1 to 6, this is what they mean:
//
// 1: SameName()
// 2: SameHash()
// 3: FromIsDir()
// 4: ToIsDir()
// 5: FromIsEmpty()
// 6: ToIsEmpty()
//
// The from and to columns are a fsnoder example of the elements
// that you will find on each tree under the specified comparison
// results (columns 1 to 6).
//
// The type column identifies the case we are into, from the list above.
//
// The type' column identifies the new set of reduced cases, using
// lowercase letters, and they are explained after the table.
//
// The last column is the set of actions and advances for each case.
//
// "---" means impossible except in case of hash collision.
//
// advance meaning:
// - NN: from.Next(); to.Next()
// - SS: from.Step(); to.Step()
//
// 1 2 3 4 5 6 | from | to |type|type'|action ; advance
// ------------+--------+--------+----+------------------------------------
// 0 0 0 0 0 0 | | | | | if !SameName() {
// . | | | | | if FromBeforeTo() {
// . | | | D | d | delete(from); from.Next()
// . | | | | | } else {
// . | | | C | c | insert(to); to.Next()
// . | | | | | }
// 0 1 1 1 1 1 | | | | | }
// 1 0 0 0 0 0 | a<1> | a<2> | H | e | modify(from, to); NN
// 1 0 0 0 0 1 | a<1> | a<> | E' | e | modify(from, to); NN
// 1 0 0 0 1 0 | a<> | a<1> | E | e | modify(from, to); NN
// 1 0 0 0 1 1 | ---- | ---- | | e |
// 1 0 0 1 0 0 | a<1> | a(...) | J | f | delete(from); insert(to); NN
// 1 0 0 1 0 1 | a<1> | a() | I | f | delete(from); insert(to); NN
// 1 0 0 1 1 0 | a<> | a(...) | G | f | delete(from); insert(to); NN
// 1 0 0 1 1 1 | a<> | a() | F | f | delete(from); insert(to); NN
// 1 0 1 0 0 0 | a(...) | a<1> | J' | f | delete(from); insert(to); NN
// 1 0 1 0 0 1 | a(...) | a<> | G' | f | delete(from); insert(to); NN
// 1 0 1 0 1 0 | a() | a<1> | I' | f | delete(from); insert(to); NN
// 1 0 1 0 1 1 | a() | a<> | F' | f | delete(from); insert(to); NN
// 1 0 1 1 0 0 | a(...) | a(;;;) | L | g | nothing; SS
// 1 0 1 1 0 1 | a(...) | a() | K' | h | deleteChildren(from); NN
// 1 0 1 1 1 0 | a() | a(...) | K | i | insertChildren(to); NN
// 1 0 1 1 1 1 | ---- | ---- | | |
// 1 1 0 0 0 0 | a<1> | a<1> | B | b | nothing; NN
// 1 1 0 0 0 1 | ---- | ---- | | b |
// 1 1 0 0 1 0 | ---- | ---- | | b |
// 1 1 0 0 1 1 | a<> | a<> | B | b | nothing; NN
// 1 1 0 1 0 0 | ---- | ---- | | b |
// 1 1 0 1 0 1 | ---- | ---- | | b |
// 1 1 0 1 1 0 | ---- | ---- | | b |
// 1 1 0 1 1 1 | ---- | ---- | | b |
// 1 1 1 0 0 0 | ---- | ---- | | b |
// 1 1 1 0 0 1 | ---- | ---- | | b |
// 1 1 1 0 1 0 | ---- | ---- | | b |
// 1 1 1 0 1 1 | ---- | ---- | | b |
// 1 1 1 1 0 0 | a(...) | a(...) | B | b | nothing; NN
// 1 1 1 1 0 1 | ---- | ---- | | b |
// 1 1 1 1 1 0 | ---- | ---- | | b |
// 1 1 1 1 1 1 | a() | a() | B | b | nothing; NN
//
// c and d:
// if !SameName()
// d if FromBeforeTo()
// c else
// b: SameName) && sameHash()
// e: SameName() && !sameHash() && BothAreFiles()
// f: SameName() && !sameHash() && FileAndDir()
// g: SameName() && !sameHash() && BothAreDirs() && NoneIsEmpty
// i: SameName() && !sameHash() && BothAreDirs() && FromIsEmpty
// h: else of i
import (
"context"
"errors"
"fmt"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
var (
// ErrCanceled is returned whenever the operation is canceled.
ErrCanceled = errors.New("operation canceled")
)
// DiffTree calculates the list of changes between two merkletries. It
// uses the provided hashEqual callback to compare noders.
func DiffTree(
fromTree,
toTree noder.Noder,
hashEqual noder.Equal,
) (Changes, error) {
return DiffTreeContext(context.Background(), fromTree, toTree, hashEqual)
}
// DiffTreeContext calculates the list of changes between two merkletries. It
// uses the provided hashEqual callback to compare noders.
// Error will be returned if context expires
// Provided context must be non nil
func DiffTreeContext(ctx context.Context, fromTree, toTree noder.Noder,
hashEqual noder.Equal) (Changes, error) {
ret := NewChanges()
ii, err := newDoubleIter(fromTree, toTree, hashEqual)
if err != nil {
return nil, err
}
for {
select {
case <-ctx.Done():
return nil, ErrCanceled
default:
}
from := ii.from.current
to := ii.to.current
switch r := ii.remaining(); r {
case noMoreNoders:
return ret, nil
case onlyFromRemains:
if err = ret.AddRecursiveDelete(from); err != nil {
return nil, err
}
if err = ii.nextFrom(); err != nil {
return nil, err
}
case onlyToRemains:
if to.Skip() {
if err = ret.AddRecursiveDelete(to); err != nil {
return nil, err
}
} else {
if err = ret.AddRecursiveInsert(to); err != nil {
return nil, err
}
}
if err = ii.nextTo(); err != nil {
return nil, err
}
case bothHaveNodes:
if from.Skip() {
if err = ret.AddRecursiveDelete(from); err != nil {
return nil, err
}
if err := ii.nextBoth(); err != nil {
return nil, err
}
break
}
if to.Skip() {
if err = ret.AddRecursiveDelete(to); err != nil {
return nil, err
}
if err := ii.nextBoth(); err != nil {
return nil, err
}
break
}
if err = diffNodes(&ret, ii); err != nil {
return nil, err
}
default:
panic(fmt.Sprintf("unknown remaining value: %d", r))
}
}
}
func diffNodes(changes *Changes, ii *doubleIter) error {
from := ii.from.current
to := ii.to.current
var err error
// compare their full paths as strings
switch from.Compare(to) {
case -1:
if err = changes.AddRecursiveDelete(from); err != nil {
return err
}
if err = ii.nextFrom(); err != nil {
return err
}
case 1:
if err = changes.AddRecursiveInsert(to); err != nil {
return err
}
if err = ii.nextTo(); err != nil {
return err
}
default:
if err := diffNodesSameName(changes, ii); err != nil {
return err
}
}
return nil
}
func diffNodesSameName(changes *Changes, ii *doubleIter) error {
from := ii.from.current
to := ii.to.current
status, err := ii.compare()
if err != nil {
return err
}
switch {
case status.sameHash:
// do nothing
if err = ii.nextBoth(); err != nil {
return err
}
case status.bothAreFiles:
changes.Add(NewModify(from, to))
if err = ii.nextBoth(); err != nil {
return err
}
case status.fileAndDir:
if err = changes.AddRecursiveDelete(from); err != nil {
return err
}
if err = changes.AddRecursiveInsert(to); err != nil {
return err
}
if err = ii.nextBoth(); err != nil {
return err
}
case status.bothAreDirs:
if err = diffDirs(changes, ii); err != nil {
return err
}
default:
return fmt.Errorf("bad status from double iterator")
}
return nil
}
func diffDirs(changes *Changes, ii *doubleIter) error {
from := ii.from.current
to := ii.to.current
status, err := ii.compare()
if err != nil {
return err
}
switch {
case status.fromIsEmptyDir:
if err = changes.AddRecursiveInsert(to); err != nil {
return err
}
if err = ii.nextBoth(); err != nil {
return err
}
case status.toIsEmptyDir:
if err = changes.AddRecursiveDelete(from); err != nil {
return err
}
if err = ii.nextBoth(); err != nil {
return err
}
case !status.fromIsEmptyDir && !status.toIsEmptyDir:
// do nothing
if err = ii.stepBoth(); err != nil {
return err
}
default:
return fmt.Errorf("both dirs are empty but has different hash")
}
return nil
}
go-git-5.13.2/utils/merkletrie/difftree_test.go 0000664 0000000 0000000 00000027766 14744245500 0021500 0 ustar 00root root 0000000 0000000 package merkletrie_test
import (
"bytes"
ctx "context"
"fmt"
"reflect"
"sort"
"strings"
"testing"
"unicode"
"github.com/go-git/go-git/v5/utils/merkletrie"
"github.com/go-git/go-git/v5/utils/merkletrie/internal/fsnoder"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type DiffTreeSuite struct{}
var _ = Suite(&DiffTreeSuite{})
type diffTreeTest struct {
from string
to string
expected string
}
func (t diffTreeTest) innerRun(c *C, context string, reverse bool) {
comment := Commentf("\n%s", context)
if reverse {
comment = Commentf("%s [REVERSED]", comment.CheckCommentString())
}
a, err := fsnoder.New(t.from)
c.Assert(err, IsNil, comment)
comment = Commentf("%s\n\t from = %s", comment.CheckCommentString(), a)
b, err := fsnoder.New(t.to)
c.Assert(err, IsNil, comment)
comment = Commentf("%s\n\t to = %s", comment.CheckCommentString(), b)
expected, err := newChangesFromString(t.expected)
c.Assert(err, IsNil, comment)
if reverse {
a, b = b, a
expected = expected.reverse()
}
comment = Commentf("%s\n\texpected = %s", comment.CheckCommentString(), expected)
results, err := merkletrie.DiffTree(a, b, fsnoder.HashEqual)
c.Assert(err, IsNil, comment)
obtained, err := newChanges(results)
c.Assert(err, IsNil, comment)
comment = Commentf("%s\n\tobtained = %s", comment.CheckCommentString(), obtained)
c.Assert(obtained, changesEquals, expected, comment)
}
func (t diffTreeTest) innerRunCtx(c *C, context string, reverse bool) {
comment := Commentf("\n%s", context)
if reverse {
comment = Commentf("%s [REVERSED]", comment.CheckCommentString())
}
a, err := fsnoder.New(t.from)
c.Assert(err, IsNil, comment)
comment = Commentf("%s\n\t from = %s", comment.CheckCommentString(), a)
b, err := fsnoder.New(t.to)
c.Assert(err, IsNil, comment)
comment = Commentf("%s\n\t to = %s", comment.CheckCommentString(), b)
expected, err := newChangesFromString(t.expected)
c.Assert(err, IsNil, comment)
if reverse {
a, b = b, a
expected = expected.reverse()
}
comment = Commentf("%s\n\texpected = %s", comment.CheckCommentString(), expected)
results, err := merkletrie.DiffTreeContext(ctx.Background(), a, b, fsnoder.HashEqual)
c.Assert(err, IsNil, comment)
obtained, err := newChanges(results)
c.Assert(err, IsNil, comment)
comment = Commentf("%s\n\tobtained = %s", comment.CheckCommentString(), obtained)
c.Assert(obtained, changesEquals, expected, comment)
}
func (t diffTreeTest) run(c *C, context string) {
t.innerRun(c, context, false)
t.innerRun(c, context, true)
t.innerRunCtx(c, context, false)
t.innerRunCtx(c, context, true)
}
type change struct {
merkletrie.Action
path string
}
func (c change) String() string {
return fmt.Sprintf("<%s %s>", c.Action, c.path)
}
func (c change) reverse() change {
ret := change{
path: c.path,
}
switch c.Action {
case merkletrie.Insert:
ret.Action = merkletrie.Delete
case merkletrie.Delete:
ret.Action = merkletrie.Insert
case merkletrie.Modify:
ret.Action = merkletrie.Modify
default:
panic(fmt.Sprintf("unknown action type: %d", c.Action))
}
return ret
}
type changes []change
func newChanges(original merkletrie.Changes) (changes, error) {
ret := make(changes, len(original))
for i, c := range original {
action, err := c.Action()
if err != nil {
return nil, err
}
switch action {
case merkletrie.Insert:
ret[i] = change{
Action: merkletrie.Insert,
path: c.To.String(),
}
case merkletrie.Delete:
ret[i] = change{
Action: merkletrie.Delete,
path: c.From.String(),
}
case merkletrie.Modify:
ret[i] = change{
Action: merkletrie.Modify,
path: c.From.String(),
}
default:
panic(fmt.Sprintf("unsupported action %d", action))
}
}
return ret, nil
}
func newChangesFromString(s string) (changes, error) {
ret := make([]change, 0)
s = strings.TrimSpace(s)
s = removeDuplicatedSpace(s)
s = turnSpaceIntoLiteralSpace(s)
if s == "" {
return ret, nil
}
for _, chunk := range strings.Split(s, " ") {
change := change{
path: chunk[1:],
}
switch chunk[0] {
case '+':
change.Action = merkletrie.Insert
case '-':
change.Action = merkletrie.Delete
case '*':
change.Action = merkletrie.Modify
default:
panic(fmt.Sprintf("unsupported action descriptor %q", chunk[0]))
}
ret = append(ret, change)
}
return ret, nil
}
func removeDuplicatedSpace(s string) string {
var buf bytes.Buffer
var lastWasSpace, currentIsSpace bool
for _, r := range s {
currentIsSpace = unicode.IsSpace(r)
if lastWasSpace && currentIsSpace {
continue
}
lastWasSpace = currentIsSpace
buf.WriteRune(r)
}
return buf.String()
}
func turnSpaceIntoLiteralSpace(s string) string {
return strings.Map(
func(r rune) rune {
if unicode.IsSpace(r) {
return ' '
}
return r
}, s)
}
func (cc changes) Len() int { return len(cc) }
func (cc changes) Swap(i, j int) { cc[i], cc[j] = cc[j], cc[i] }
func (cc changes) Less(i, j int) bool { return strings.Compare(cc[i].String(), cc[j].String()) < 0 }
func (cc changes) equals(other changes) bool {
sort.Sort(cc)
sort.Sort(other)
return reflect.DeepEqual(cc, other)
}
func (cc changes) String() string {
var buf bytes.Buffer
fmt.Fprintf(&buf, "len(%d) [", len(cc))
sep := ""
for _, c := range cc {
fmt.Fprintf(&buf, "%s%s", sep, c)
sep = ", "
}
buf.WriteByte(']')
return buf.String()
}
func (cc changes) reverse() changes {
ret := make(changes, len(cc))
for i, c := range cc {
ret[i] = c.reverse()
}
return ret
}
type changesEqualsChecker struct {
*CheckerInfo
}
var changesEquals Checker = &changesEqualsChecker{
&CheckerInfo{Name: "changesEquals", Params: []string{"obtained", "expected"}},
}
func (checker *changesEqualsChecker) Check(params []interface{}, names []string) (result bool, error string) {
a, ok := params[0].(changes)
if !ok {
return false, "first parameter must be a changes"
}
b, ok := params[1].(changes)
if !ok {
return false, "second parameter must be a changes"
}
return a.equals(b), ""
}
func do(c *C, list []diffTreeTest) {
for i, t := range list {
t.run(c, fmt.Sprintf("test #%d:", i))
}
}
func (s *DiffTreeSuite) TestEmptyVsEmpty(c *C) {
do(c, []diffTreeTest{
{"()", "()", ""},
{"A()", "A()", ""},
{"A()", "()", ""},
{"A()", "B()", ""},
})
}
func (s *DiffTreeSuite) TestBasicCases(c *C) {
do(c, []diffTreeTest{
{"()", "()", ""},
{"()", "(a<>)", "+a"},
{"()", "(a<1>)", "+a"},
{"()", "(a())", ""},
{"()", "(a(b()))", ""},
{"()", "(a(b<>))", "+a/b"},
{"()", "(a(b<1>))", "+a/b"},
{"(a<>)", "(a<>)", ""},
{"(a<>)", "(a<1>)", "*a"},
{"(a<>)", "(a())", "-a"},
{"(a<>)", "(a(b()))", "-a"},
{"(a<>)", "(a(b<>))", "-a +a/b"},
{"(a<>)", "(a(b<1>))", "-a +a/b"},
{"(a<>)", "(c())", "-a"},
{"(a<>)", "(c(b()))", "-a"},
{"(a<>)", "(c(b<>))", "-a +c/b"},
{"(a<>)", "(c(b<1>))", "-a +c/b"},
{"(a<>)", "(c(a()))", "-a"},
{"(a<>)", "(c(a<>))", "-a +c/a"},
{"(a<>)", "(c(a<1>))", "-a +c/a"},
{"(a<1>)", "(a<1>)", ""},
{"(a<1>)", "(a<2>)", "*a"},
{"(a<1>)", "(b<1>)", "-a +b"},
{"(a<1>)", "(b<2>)", "-a +b"},
{"(a<1>)", "(a())", "-a"},
{"(a<1>)", "(a(b()))", "-a"},
{"(a<1>)", "(a(b<>))", "-a +a/b"},
{"(a<1>)", "(a(b<1>))", "-a +a/b"},
{"(a<1>)", "(a(b<2>))", "-a +a/b"},
{"(a<1>)", "(c())", "-a"},
{"(a<1>)", "(c(b()))", "-a"},
{"(a<1>)", "(c(b<>))", "-a +c/b"},
{"(a<1>)", "(c(b<1>))", "-a +c/b"},
{"(a<1>)", "(c(b<2>))", "-a +c/b"},
{"(a<1>)", "(c())", "-a"},
{"(a<1>)", "(c(a()))", "-a"},
{"(a<1>)", "(c(a<>))", "-a +c/a"},
{"(a<1>)", "(c(a<1>))", "-a +c/a"},
{"(a<1>)", "(c(a<2>))", "-a +c/a"},
{"(a())", "(a())", ""},
{"(a())", "(b())", ""},
{"(a())", "(a(b()))", ""},
{"(a())", "(b(a()))", ""},
{"(a())", "(a(b<>))", "+a/b"},
{"(a())", "(a(b<1>))", "+a/b"},
{"(a())", "(b(a<>))", "+b/a"},
{"(a())", "(b(a<1>))", "+b/a"},
})
}
func (s *DiffTreeSuite) TestHorizontals(c *C) {
do(c, []diffTreeTest{
{"()", "(a<> b<>)", "+a +b"},
{"()", "(a<> b<1>)", "+a +b"},
{"()", "(a<> b())", "+a"},
{"()", "(a() b<>)", "+b"},
{"()", "(a<1> b<>)", "+a +b"},
{"()", "(a<1> b<1>)", "+a +b"},
{"()", "(a<1> b<2>)", "+a +b"},
{"()", "(a<1> b())", "+a"},
{"()", "(a() b<1>)", "+b"},
{"()", "(a() b())", ""},
{"()", "(a<> b<> c<> d<>)", "+a +b +c +d"},
{"()", "(a<> b<1> c() d<> e<2> f())", "+a +b +d +e"},
})
}
func (s *DiffTreeSuite) TestVerticals(c *C) {
do(c, []diffTreeTest{
{"()", "(z<>)", "+z"},
{"()", "(a(z<>))", "+a/z"},
{"()", "(a(b(z<>)))", "+a/b/z"},
{"()", "(a(b(c(z<>))))", "+a/b/c/z"},
{"()", "(a(b(c(d(z<>)))))", "+a/b/c/d/z"},
{"()", "(a(b(c(d(z<1>)))))", "+a/b/c/d/z"},
})
}
func (s *DiffTreeSuite) TestSingleInserts(c *C) {
do(c, []diffTreeTest{
{"()", "(z<>)", "+z"},
{"(a())", "(a(z<>))", "+a/z"},
{"(a())", "(a(b(z<>)))", "+a/b/z"},
{"(a(b(c())))", "(a(b(c(z<>))))", "+a/b/c/z"},
{"(a<> b<> c<>)", "(a<> b<> c<> z<>)", "+z"},
{"(a(b<> c<> d<>))", "(a(b<> c<> d<> z<>))", "+a/z"},
{"(a(b(c<> d<> e<>)))", "(a(b(c<> d<> e<> z<>)))", "+a/b/z"},
{"(a(b<>) f<>)", "(a(b<>) f<> z<>)", "+z"},
{"(a(b<>) f<>)", "(a(b<> z<>) f<>)", "+a/z"},
})
}
func (s *DiffTreeSuite) TestDebug(c *C) {
do(c, []diffTreeTest{
{"(a(b<>) f<>)", "(a(b<> z<>) f<>)", "+a/z"},
})
}
// root
// / | \
// / | ----
// f d h --------
// /\ / \ |
// e a j b/ g
// | / \ |
// l n k icm
// |
// o
// |
// p/
func (s *DiffTreeSuite) TestCrazy(c *C) {
crazy := "(f(e(l<1>) a(n(o(p())) k<1>)) d<1> h(j(i<1> c<2> m<>) b() g<>))"
do(c, []diffTreeTest{
{
crazy,
"()",
"-d -f/e/l -f/a/k -h/j/i -h/j/c -h/j/m -h/g",
}, {
crazy,
crazy,
"",
}, {
crazy,
"(d<1>)",
"-f/e/l -f/a/k -h/j/i -h/j/c -h/j/m -h/g",
}, {
crazy,
"(d<1> h(b() g<>))",
"-f/e/l -f/a/k -h/j/i -h/j/c -h/j/m",
}, {
crazy,
"(d<1> f(e(l()) a()) h(b() g<>))",
"-f/e/l -f/a/k -h/j/i -h/j/c -h/j/m",
}, {
crazy,
"(d<1> f(e(l<1>) a()) h(b() g<>))",
"-f/a/k -h/j/i -h/j/c -h/j/m",
}, {
crazy,
"(d<2> f(e(l<2>) a(s(t<1>))) h(b() g<> r<> j(i<> c<3> m<>)))",
"+f/a/s/t +h/r -f/a/k *d *f/e/l *h/j/c *h/j/i",
}, {
crazy,
"(f(e(l<2>) a(n(o(p<1>)) k<>)) h(j(i<1> c<2> m<>) b() g<>))",
"*f/e/l +f/a/n/o/p *f/a/k -d",
}, {
crazy,
"(f(e(l<1>) a(n(o(p(r<1>))) k<1>)) d<1> h(j(i<1> c<2> b() m<>) g<1>))",
"+f/a/n/o/p/r *h/g",
},
})
}
func (s *DiffTreeSuite) TestSameNames(c *C) {
do(c, []diffTreeTest{
{
"(a(a(a<>)))",
"(a(a(a<1>)))",
"*a/a/a",
}, {
"(a(b(a<>)))",
"(a(b(a<>)) b(a<>))",
"+b/a",
}, {
"(a(b(a<>)))",
"(a(b()) b(a<>))",
"-a/b/a +b/a",
},
})
}
func (s *DiffTreeSuite) TestIssue275(c *C) {
do(c, []diffTreeTest{
{
"(a(b(c.go<1>) b.go<2>))",
"(a(b(c.go<1> d.go<3>) b.go<2>))",
"+a/b/d.go",
},
})
}
func (s *DiffTreeSuite) TestIssue1057(c *C) {
p1 := "TestAppWithUnicodéPath"
p2 := "TestAppWithUnicodéPath"
c.Assert(p1 == p2, Equals, false)
do(c, []diffTreeTest{
{
fmt.Sprintf("(%s(x.go<1>))", p1),
fmt.Sprintf("(%s(x.go<1>) %s(x.go<1>))", p1, p2),
fmt.Sprintf("+%s/x.go", p2),
},
})
// swap p1 with p2
do(c, []diffTreeTest{
{
fmt.Sprintf("(%s(x.go<1>))", p2),
fmt.Sprintf("(%s(x.go<1>) %s(x.go<1>))", p1, p2),
fmt.Sprintf("+%s/x.go", p1),
},
})
}
func (s *DiffTreeSuite) TestCancel(c *C) {
t := diffTreeTest{"()", "(a<> b<1> c() d<> e<2> f())", "+a +b +d +e"}
comment := Commentf("\n%s", "test cancel:")
a, err := fsnoder.New(t.from)
c.Assert(err, IsNil, comment)
comment = Commentf("%s\n\t from = %s", comment.CheckCommentString(), a)
b, err := fsnoder.New(t.to)
c.Assert(err, IsNil, comment)
comment = Commentf("%s\n\t to = %s", comment.CheckCommentString(), b)
expected, err := newChangesFromString(t.expected)
c.Assert(err, IsNil, comment)
comment = Commentf("%s\n\texpected = %s", comment.CheckCommentString(), expected)
context, cancel := ctx.WithCancel(ctx.Background())
cancel()
results, err := merkletrie.DiffTreeContext(context, a, b, fsnoder.HashEqual)
c.Assert(results, IsNil, comment)
c.Assert(err, ErrorMatches, "operation canceled")
}
go-git-5.13.2/utils/merkletrie/doc.go 0000664 0000000 0000000 00000002606 14744245500 0017400 0 ustar 00root root 0000000 0000000 /*
Package merkletrie provides support for n-ary trees that are at the same
time Merkle trees and Radix trees (tries).
Git trees are Radix n-ary trees in virtue of the names of their
tree entries. At the same time, git trees are Merkle trees thanks to
their hashes.
This package defines Merkle tries as nodes that should have:
- a hash: the Merkle part of the Merkle trie
- a key: the Radix part of the Merkle trie
The Merkle hash condition is not enforced by this package though. This
means that the hash of a node doesn't have to take into account the hashes of
their children, which is good for testing purposes.
Nodes in the Merkle trie are abstracted by the Noder interface. The
intended use is that git trees implements this interface, either
directly or using a simple wrapper.
This package provides an iterator for merkletries that can skip whole
directory-like noders and an efficient merkletrie comparison algorithm.
When comparing git trees, the simple approach of alphabetically sorting
their elements and comparing the resulting lists is too slow as it
depends linearly on the number of files in the trees: When a directory
has lots of files but none of them has been modified, this approach is
very expensive. We can do better by prunning whole directories that
have not change, just by looking at their hashes. This package provides
the tools to do exactly that.
*/
package merkletrie
go-git-5.13.2/utils/merkletrie/doubleiter.go 0000664 0000000 0000000 00000011547 14744245500 0020775 0 ustar 00root root 0000000 0000000 package merkletrie
import (
"fmt"
"io"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
// A doubleIter is a convenience type to keep track of the current
// noders in two merkletries that are going to be iterated in parallel.
// It has methods for:
//
// - iterating over the merkletries, both at the same time or
// individually: nextFrom, nextTo, nextBoth, stepBoth
//
// - checking if there are noders left in one or both of them with the
// remaining method and its associated returned type.
//
// - comparing the current noders of both merkletries in several ways,
// with the compare method and its associated returned type.
type doubleIter struct {
from struct {
iter *Iter
current noder.Path // nil if no more nodes
}
to struct {
iter *Iter
current noder.Path // nil if no more nodes
}
hashEqual noder.Equal
}
// NewdoubleIter returns a new doubleIter for the merkletries "from" and
// "to". The hashEqual callback function will be used by the doubleIter
// to compare the hash of the noders in the merkletries. The doubleIter
// will be initialized to the first elements in each merkletrie if any.
func newDoubleIter(from, to noder.Noder, hashEqual noder.Equal) (
*doubleIter, error) {
var ii doubleIter
var err error
if ii.from.iter, err = NewIter(from); err != nil {
return nil, fmt.Errorf("from: %s", err)
}
if ii.from.current, err = ii.from.iter.Next(); turnEOFIntoNil(err) != nil {
return nil, fmt.Errorf("from: %s", err)
}
if ii.to.iter, err = NewIter(to); err != nil {
return nil, fmt.Errorf("to: %s", err)
}
if ii.to.current, err = ii.to.iter.Next(); turnEOFIntoNil(err) != nil {
return nil, fmt.Errorf("to: %s", err)
}
ii.hashEqual = hashEqual
return &ii, nil
}
func turnEOFIntoNil(e error) error {
if e != nil && e != io.EOF {
return e
}
return nil
}
// NextBoth makes d advance to the next noder in both merkletries. If
// any of them is a directory, it skips its contents.
func (d *doubleIter) nextBoth() error {
if err := d.nextFrom(); err != nil {
return err
}
if err := d.nextTo(); err != nil {
return err
}
return nil
}
// NextFrom makes d advance to the next noder in the "from" merkletrie,
// skipping its contents if it is a directory.
func (d *doubleIter) nextFrom() (err error) {
d.from.current, err = d.from.iter.Next()
return turnEOFIntoNil(err)
}
// NextTo makes d advance to the next noder in the "to" merkletrie,
// skipping its contents if it is a directory.
func (d *doubleIter) nextTo() (err error) {
d.to.current, err = d.to.iter.Next()
return turnEOFIntoNil(err)
}
// StepBoth makes d advance to the next noder in both merkletries,
// getting deeper into directories if that is the case.
func (d *doubleIter) stepBoth() (err error) {
if d.from.current, err = d.from.iter.Step(); turnEOFIntoNil(err) != nil {
return err
}
if d.to.current, err = d.to.iter.Step(); turnEOFIntoNil(err) != nil {
return err
}
return nil
}
// Remaining returns if there are no more noders in the tree, if both
// have noders or if one of them doesn't.
func (d *doubleIter) remaining() remaining {
if d.from.current == nil && d.to.current == nil {
return noMoreNoders
}
if d.from.current == nil && d.to.current != nil {
return onlyToRemains
}
if d.from.current != nil && d.to.current == nil {
return onlyFromRemains
}
return bothHaveNodes
}
// Remaining values tells you whether both trees still have noders, or
// only one of them or none of them.
type remaining int
const (
noMoreNoders remaining = iota
onlyToRemains
onlyFromRemains
bothHaveNodes
)
// Compare returns the comparison between the current elements in the
// merkletries.
func (d *doubleIter) compare() (s comparison, err error) {
s.sameHash = d.hashEqual(d.from.current, d.to.current)
fromIsDir := d.from.current.IsDir()
toIsDir := d.to.current.IsDir()
s.bothAreDirs = fromIsDir && toIsDir
s.bothAreFiles = !fromIsDir && !toIsDir
s.fileAndDir = !s.bothAreDirs && !s.bothAreFiles
fromNumChildren, err := d.from.current.NumChildren()
if err != nil {
return comparison{}, fmt.Errorf("from: %s", err)
}
toNumChildren, err := d.to.current.NumChildren()
if err != nil {
return comparison{}, fmt.Errorf("to: %s", err)
}
s.fromIsEmptyDir = fromIsDir && fromNumChildren == 0
s.toIsEmptyDir = toIsDir && toNumChildren == 0
return
}
// Answers to a lot of questions you can ask about how to noders are
// equal or different.
type comparison struct {
// the following are only valid if both nodes have the same name
// (i.e. nameComparison == 0)
// Do both nodes have the same hash?
sameHash bool
// Are both nodes files?
bothAreFiles bool
// the following are only valid if any of the noders are dirs,
// this is, if !bothAreFiles
// Is one a file and the other a dir?
fileAndDir bool
// Are both nodes dirs?
bothAreDirs bool
// Is the from node an empty dir?
fromIsEmptyDir bool
// Is the to Node an empty dir?
toIsEmptyDir bool
}
go-git-5.13.2/utils/merkletrie/filesystem/ 0000775 0000000 0000000 00000000000 14744245500 0020464 5 ustar 00root root 0000000 0000000 go-git-5.13.2/utils/merkletrie/filesystem/node.go 0000664 0000000 0000000 00000010240 14744245500 0021735 0 ustar 00root root 0000000 0000000 package filesystem
import (
"io"
"os"
"path"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
"github.com/go-git/go-billy/v5"
)
var ignore = map[string]bool{
".git": true,
}
// The node represents a file or a directory in a billy.Filesystem. It
// implements the interface noder.Noder of merkletrie package.
//
// This implementation implements a "standard" hash method being able to be
// compared with any other noder.Noder implementation inside of go-git.
type node struct {
fs billy.Filesystem
submodules map[string]plumbing.Hash
path string
hash []byte
children []noder.Noder
isDir bool
mode os.FileMode
size int64
}
// NewRootNode returns the root node based on a given billy.Filesystem.
//
// In order to provide the submodule hash status, a map[string]plumbing.Hash
// should be provided where the key is the path of the submodule and the commit
// of the submodule HEAD
func NewRootNode(
fs billy.Filesystem,
submodules map[string]plumbing.Hash,
) noder.Noder {
return &node{fs: fs, submodules: submodules, isDir: true}
}
// Hash the hash of a filesystem is the result of concatenating the computed
// plumbing.Hash of the file as a Blob and its plumbing.FileMode; that way the
// difftree algorithm will detect changes in the contents of files and also in
// their mode.
//
// Please note that the hash is calculated on first invocation of Hash(),
// meaning that it will not update when the underlying file changes
// between invocations.
//
// The hash of a directory is always a 24-bytes slice of zero values
func (n *node) Hash() []byte {
if n.hash == nil {
n.calculateHash()
}
return n.hash
}
func (n *node) Name() string {
return path.Base(n.path)
}
func (n *node) IsDir() bool {
return n.isDir
}
func (n *node) Skip() bool {
return false
}
func (n *node) Children() ([]noder.Noder, error) {
if err := n.calculateChildren(); err != nil {
return nil, err
}
return n.children, nil
}
func (n *node) NumChildren() (int, error) {
if err := n.calculateChildren(); err != nil {
return -1, err
}
return len(n.children), nil
}
func (n *node) calculateChildren() error {
if !n.IsDir() {
return nil
}
if len(n.children) != 0 {
return nil
}
files, err := n.fs.ReadDir(n.path)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
for _, file := range files {
if _, ok := ignore[file.Name()]; ok {
continue
}
if file.Mode()&os.ModeSocket != 0 {
continue
}
c, err := n.newChildNode(file)
if err != nil {
return err
}
n.children = append(n.children, c)
}
return nil
}
func (n *node) newChildNode(file os.FileInfo) (*node, error) {
path := path.Join(n.path, file.Name())
node := &node{
fs: n.fs,
submodules: n.submodules,
path: path,
isDir: file.IsDir(),
size: file.Size(),
mode: file.Mode(),
}
if _, isSubmodule := n.submodules[path]; isSubmodule {
node.isDir = false
}
return node, nil
}
func (n *node) calculateHash() {
if n.isDir {
n.hash = make([]byte, 24)
return
}
mode, err := filemode.NewFromOSFileMode(n.mode)
if err != nil {
n.hash = plumbing.ZeroHash[:]
return
}
if submoduleHash, isSubmodule := n.submodules[n.path]; isSubmodule {
n.hash = append(submoduleHash[:], filemode.Submodule.Bytes()...)
return
}
var hash plumbing.Hash
if n.mode&os.ModeSymlink != 0 {
hash = n.doCalculateHashForSymlink()
} else {
hash = n.doCalculateHashForRegular()
}
n.hash = append(hash[:], mode.Bytes()...)
}
func (n *node) doCalculateHashForRegular() plumbing.Hash {
f, err := n.fs.Open(n.path)
if err != nil {
return plumbing.ZeroHash
}
defer f.Close()
h := plumbing.NewHasher(plumbing.BlobObject, n.size)
if _, err := io.Copy(h, f); err != nil {
return plumbing.ZeroHash
}
return h.Sum()
}
func (n *node) doCalculateHashForSymlink() plumbing.Hash {
target, err := n.fs.Readlink(n.path)
if err != nil {
return plumbing.ZeroHash
}
h := plumbing.NewHasher(plumbing.BlobObject, n.size)
if _, err := h.Write([]byte(target)); err != nil {
return plumbing.ZeroHash
}
return h.Sum()
}
func (n *node) String() string {
return n.path
}
go-git-5.13.2/utils/merkletrie/filesystem/node_test.go 0000664 0000000 0000000 00000012210 14744245500 0022773 0 ustar 00root root 0000000 0000000 package filesystem
import (
"bytes"
"fmt"
"io"
"net"
"os"
"path"
"runtime"
"testing"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/utils/merkletrie"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-billy/v5/osfs"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type NoderSuite struct{}
var _ = Suite(&NoderSuite{})
func (s *NoderSuite) TestDiff(c *C) {
fsA := memfs.New()
WriteFile(fsA, "foo", []byte("foo"), 0644)
WriteFile(fsA, "qux/bar", []byte("foo"), 0644)
WriteFile(fsA, "qux/qux", []byte("foo"), 0644)
fsA.Symlink("foo", "bar")
fsB := memfs.New()
WriteFile(fsB, "foo", []byte("foo"), 0644)
WriteFile(fsB, "qux/bar", []byte("foo"), 0644)
WriteFile(fsB, "qux/qux", []byte("foo"), 0644)
fsB.Symlink("foo", "bar")
ch, err := merkletrie.DiffTree(
NewRootNode(fsA, nil),
NewRootNode(fsB, nil),
IsEquals,
)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 0)
}
func (s *NoderSuite) TestDiffChangeLink(c *C) {
fsA := memfs.New()
fsA.Symlink("qux", "foo")
fsB := memfs.New()
fsB.Symlink("bar", "foo")
ch, err := merkletrie.DiffTree(
NewRootNode(fsA, nil),
NewRootNode(fsB, nil),
IsEquals,
)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 1)
}
func (s *NoderSuite) TestDiffChangeContent(c *C) {
fsA := memfs.New()
WriteFile(fsA, "foo", []byte("foo"), 0644)
WriteFile(fsA, "qux/bar", []byte("foo"), 0644)
WriteFile(fsA, "qux/qux", []byte("foo"), 0644)
fsB := memfs.New()
WriteFile(fsB, "foo", []byte("foo"), 0644)
WriteFile(fsB, "qux/bar", []byte("bar"), 0644)
WriteFile(fsB, "qux/qux", []byte("foo"), 0644)
ch, err := merkletrie.DiffTree(
NewRootNode(fsA, nil),
NewRootNode(fsB, nil),
IsEquals,
)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 1)
}
func (s *NoderSuite) TestDiffSymlinkDirOnA(c *C) {
fsA := memfs.New()
WriteFile(fsA, "qux/qux", []byte("foo"), 0644)
fsB := memfs.New()
fsB.Symlink("qux", "foo")
WriteFile(fsB, "qux/qux", []byte("foo"), 0644)
ch, err := merkletrie.DiffTree(
NewRootNode(fsA, nil),
NewRootNode(fsB, nil),
IsEquals,
)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 1)
}
func (s *NoderSuite) TestDiffSymlinkDirOnB(c *C) {
fsA := memfs.New()
fsA.Symlink("qux", "foo")
WriteFile(fsA, "qux/qux", []byte("foo"), 0644)
fsB := memfs.New()
WriteFile(fsB, "qux/qux", []byte("foo"), 0644)
ch, err := merkletrie.DiffTree(
NewRootNode(fsA, nil),
NewRootNode(fsB, nil),
IsEquals,
)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 1)
}
func (s *NoderSuite) TestDiffChangeMissing(c *C) {
fsA := memfs.New()
WriteFile(fsA, "foo", []byte("foo"), 0644)
fsB := memfs.New()
WriteFile(fsB, "bar", []byte("bar"), 0644)
ch, err := merkletrie.DiffTree(
NewRootNode(fsA, nil),
NewRootNode(fsB, nil),
IsEquals,
)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 2)
}
func (s *NoderSuite) TestDiffChangeMode(c *C) {
fsA := memfs.New()
WriteFile(fsA, "foo", []byte("foo"), 0644)
fsB := memfs.New()
WriteFile(fsB, "foo", []byte("foo"), 0755)
ch, err := merkletrie.DiffTree(
NewRootNode(fsA, nil),
NewRootNode(fsB, nil),
IsEquals,
)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 1)
}
func (s *NoderSuite) TestDiffChangeModeNotRelevant(c *C) {
fsA := memfs.New()
WriteFile(fsA, "foo", []byte("foo"), 0644)
fsB := memfs.New()
WriteFile(fsB, "foo", []byte("foo"), 0655)
ch, err := merkletrie.DiffTree(
NewRootNode(fsA, nil),
NewRootNode(fsB, nil),
IsEquals,
)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 0)
}
func (s *NoderSuite) TestDiffDirectory(c *C) {
dir := path.Join("qux", "bar")
fsA := memfs.New()
fsA.MkdirAll(dir, 0644)
fsB := memfs.New()
fsB.MkdirAll(dir, 0644)
ch, err := merkletrie.DiffTree(
NewRootNode(fsA, map[string]plumbing.Hash{
dir: plumbing.NewHash("aa102815663d23f8b75a47e7a01965dcdc96468c"),
}),
NewRootNode(fsB, map[string]plumbing.Hash{
dir: plumbing.NewHash("19102815663d23f8b75a47e7a01965dcdc96468c"),
}),
IsEquals,
)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 1)
a, err := ch[0].Action()
c.Assert(err, IsNil)
c.Assert(a, Equals, merkletrie.Modify)
}
func (s *NoderSuite) TestSocket(c *C) {
if runtime.GOOS == "windows" {
c.Skip("socket files do not exist on windows")
}
td, err := os.MkdirTemp(c.MkDir(), "socket-test")
c.Assert(err, IsNil)
sock, err := net.ListenUnix("unix", &net.UnixAddr{Name: fmt.Sprintf("%s/socket", td), Net: "unix"})
c.Assert(err, IsNil)
defer sock.Close()
fsA := osfs.New(td)
WriteFile(fsA, "foo", []byte("foo"), 0644)
noder := NewRootNode(fsA, nil)
childs, err := noder.Children()
c.Assert(err, IsNil)
c.Assert(childs, HasLen, 1)
}
func WriteFile(fs billy.Filesystem, filename string, data []byte, perm os.FileMode) error {
f, err := fs.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
if err != nil {
return err
}
n, err := f.Write(data)
if err == nil && n < len(data) {
err = io.ErrShortWrite
}
if err1 := f.Close(); err == nil {
err = err1
}
return err
}
var empty = make([]byte, 24)
func IsEquals(a, b noder.Hasher) bool {
if bytes.Equal(a.Hash(), empty) || bytes.Equal(b.Hash(), empty) {
return false
}
return bytes.Equal(a.Hash(), b.Hash())
}
go-git-5.13.2/utils/merkletrie/index/ 0000775 0000000 0000000 00000000000 14744245500 0017407 5 ustar 00root root 0000000 0000000 go-git-5.13.2/utils/merkletrie/index/node.go 0000664 0000000 0000000 00000004146 14744245500 0020670 0 ustar 00root root 0000000 0000000 package index
import (
"path"
"strings"
"github.com/go-git/go-git/v5/plumbing/format/index"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
// The node represents a index.Entry or a directory inferred from the path
// of all entries. It implements the interface noder.Noder of merkletrie
// package.
//
// This implementation implements a "standard" hash method being able to be
// compared with any other noder.Noder implementation inside of go-git
type node struct {
path string
entry *index.Entry
children []noder.Noder
isDir bool
skip bool
}
// NewRootNode returns the root node of a computed tree from a index.Index,
func NewRootNode(idx *index.Index) noder.Noder {
const rootNode = ""
m := map[string]*node{rootNode: {isDir: true}}
for _, e := range idx.Entries {
parts := strings.Split(e.Name, string("/"))
var fullpath string
for _, part := range parts {
parent := fullpath
fullpath = path.Join(fullpath, part)
if _, ok := m[fullpath]; ok {
continue
}
n := &node{path: fullpath, skip: e.SkipWorktree}
if fullpath == e.Name {
n.entry = e
} else {
n.isDir = true
}
m[n.path] = n
m[parent].children = append(m[parent].children, n)
}
}
return m[rootNode]
}
func (n *node) String() string {
return n.path
}
func (n *node) Skip() bool {
return n.skip
}
// Hash the hash of a filesystem is a 24-byte slice, is the result of
// concatenating the computed plumbing.Hash of the file as a Blob and its
// plumbing.FileMode; that way the difftree algorithm will detect changes in the
// contents of files and also in their mode.
//
// If the node is computed and not based on a index.Entry the hash is equals
// to a 24-bytes slices of zero values.
func (n *node) Hash() []byte {
if n.entry == nil {
return make([]byte, 24)
}
return append(n.entry.Hash[:], n.entry.Mode.Bytes()...)
}
func (n *node) Name() string {
return path.Base(n.path)
}
func (n *node) IsDir() bool {
return n.isDir
}
func (n *node) Children() ([]noder.Noder, error) {
return n.children, nil
}
func (n *node) NumChildren() (int, error) {
return len(n.children), nil
}
go-git-5.13.2/utils/merkletrie/index/node_test.go 0000664 0000000 0000000 00000006326 14744245500 0021731 0 ustar 00root root 0000000 0000000 package index
import (
"bytes"
"path/filepath"
"testing"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/format/index"
"github.com/go-git/go-git/v5/utils/merkletrie"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type NoderSuite struct{}
var _ = Suite(&NoderSuite{})
func (s *NoderSuite) TestDiff(c *C) {
indexA := &index.Index{
Entries: []*index.Entry{
{Name: "foo", Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")},
{Name: "bar/foo", Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")},
{Name: "bar/qux", Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")},
{Name: "bar/baz/foo", Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")},
},
}
indexB := &index.Index{
Entries: []*index.Entry{
{Name: "foo", Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")},
{Name: "bar/foo", Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")},
{Name: "bar/qux", Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")},
{Name: "bar/baz/foo", Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")},
},
}
ch, err := merkletrie.DiffTree(NewRootNode(indexA), NewRootNode(indexB), isEquals)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 0)
}
func (s *NoderSuite) TestDiffChange(c *C) {
indexA := &index.Index{
Entries: []*index.Entry{{
Name: filepath.Join("bar", "baz", "bar"),
Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d"),
}},
}
indexB := &index.Index{
Entries: []*index.Entry{{
Name: filepath.Join("bar", "baz", "foo"),
Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d"),
}},
}
ch, err := merkletrie.DiffTree(NewRootNode(indexA), NewRootNode(indexB), isEquals)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 2)
}
func (s *NoderSuite) TestDiffDir(c *C) {
indexA := &index.Index{
Entries: []*index.Entry{{
Name: "foo",
Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d"),
}},
}
indexB := &index.Index{
Entries: []*index.Entry{{
Name: filepath.Join("foo", "bar"),
Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d"),
}},
}
ch, err := merkletrie.DiffTree(NewRootNode(indexA), NewRootNode(indexB), isEquals)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 2)
}
func (s *NoderSuite) TestDiffSameRoot(c *C) {
indexA := &index.Index{
Entries: []*index.Entry{
{Name: "foo.go", Hash: plumbing.NewHash("aab686eafeb1f44702738c8b0f24f2567c36da6d")},
{Name: "foo/bar", Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")},
},
}
indexB := &index.Index{
Entries: []*index.Entry{
{Name: "foo/bar", Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")},
{Name: "foo.go", Hash: plumbing.NewHash("8ab686eafeb1f44702738c8b0f24f2567c36da6d")},
},
}
ch, err := merkletrie.DiffTree(NewRootNode(indexA), NewRootNode(indexB), isEquals)
c.Assert(err, IsNil)
c.Assert(ch, HasLen, 1)
}
var empty = make([]byte, 24)
func isEquals(a, b noder.Hasher) bool {
if bytes.Equal(a.Hash(), empty) || bytes.Equal(b.Hash(), empty) {
return false
}
return bytes.Equal(a.Hash(), b.Hash())
}
go-git-5.13.2/utils/merkletrie/internal/ 0000775 0000000 0000000 00000000000 14744245500 0020114 5 ustar 00root root 0000000 0000000 go-git-5.13.2/utils/merkletrie/internal/frame/ 0000775 0000000 0000000 00000000000 14744245500 0021206 5 ustar 00root root 0000000 0000000 go-git-5.13.2/utils/merkletrie/internal/frame/frame.go 0000664 0000000 0000000 00000003637 14744245500 0022640 0 ustar 00root root 0000000 0000000 package frame
import (
"bytes"
"fmt"
"sort"
"strings"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
// A Frame is a collection of siblings in a trie, sorted alphabetically
// by name.
type Frame struct {
// siblings, sorted in reverse alphabetical order by name
stack []noder.Noder
}
type byName []noder.Noder
func (a byName) Len() int { return len(a) }
func (a byName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a byName) Less(i, j int) bool {
return strings.Compare(a[i].Name(), a[j].Name()) < 0
}
// New returns a frame with the children of the provided node.
func New(n noder.Noder) (*Frame, error) {
children, err := n.Children()
if err != nil {
return nil, err
}
sort.Sort(sort.Reverse(byName(children)))
return &Frame{
stack: children,
}, nil
}
// String returns the quoted names of the noders in the frame sorted in
// alphabetical order by name, surrounded by square brackets and
// separated by comas.
//
// Examples:
// []
// ["a", "b"]
func (f *Frame) String() string {
var buf bytes.Buffer
_ = buf.WriteByte('[')
sep := ""
for i := f.Len() - 1; i >= 0; i-- {
_, _ = buf.WriteString(sep)
sep = ", "
_, _ = buf.WriteString(fmt.Sprintf("%q", f.stack[i].Name()))
}
_ = buf.WriteByte(']')
return buf.String()
}
// First returns, but dont extract, the noder with the alphabetically
// smaller name in the frame and true if the frame was not empty.
// Otherwise it returns nil and false.
func (f *Frame) First() (noder.Noder, bool) {
if f.Len() == 0 {
return nil, false
}
top := f.Len() - 1
return f.stack[top], true
}
// Drop extracts the noder with the alphabetically smaller name in the
// frame or does nothing if the frame was empty.
func (f *Frame) Drop() {
if f.Len() == 0 {
return
}
top := f.Len() - 1
f.stack[top] = nil
f.stack = f.stack[:top]
}
// Len returns the number of noders in the frame.
func (f *Frame) Len() int {
return len(f.stack)
}
go-git-5.13.2/utils/merkletrie/internal/frame/frame_test.go 0000664 0000000 0000000 00000004206 14744245500 0023670 0 ustar 00root root 0000000 0000000 package frame
import (
"fmt"
"testing"
"github.com/go-git/go-git/v5/utils/merkletrie/internal/fsnoder"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type FrameSuite struct{}
var _ = Suite(&FrameSuite{})
func (s *FrameSuite) TestNewFrameFromEmptyDir(c *C) {
A, err := fsnoder.New("A()")
c.Assert(err, IsNil)
frame, err := New(A)
c.Assert(err, IsNil)
expectedString := `[]`
c.Assert(frame.String(), Equals, expectedString)
first, ok := frame.First()
c.Assert(first, IsNil)
c.Assert(ok, Equals, false)
first, ok = frame.First()
c.Assert(first, IsNil)
c.Assert(ok, Equals, false)
l := frame.Len()
c.Assert(l, Equals, 0)
}
func (s *FrameSuite) TestNewFrameFromNonEmpty(c *C) {
// _______A/________
// | / \ |
// x y B/ C/
// |
// z
root, err := fsnoder.New("A(x<> y<> B() C(z<>))")
c.Assert(err, IsNil)
frame, err := New(root)
c.Assert(err, IsNil)
expectedString := `["B", "C", "x", "y"]`
c.Assert(frame.String(), Equals, expectedString)
l := frame.Len()
c.Assert(l, Equals, 4)
checkFirstAndDrop(c, frame, "B", true)
l = frame.Len()
c.Assert(l, Equals, 3)
checkFirstAndDrop(c, frame, "C", true)
l = frame.Len()
c.Assert(l, Equals, 2)
checkFirstAndDrop(c, frame, "x", true)
l = frame.Len()
c.Assert(l, Equals, 1)
checkFirstAndDrop(c, frame, "y", true)
l = frame.Len()
c.Assert(l, Equals, 0)
checkFirstAndDrop(c, frame, "", false)
l = frame.Len()
c.Assert(l, Equals, 0)
checkFirstAndDrop(c, frame, "", false)
}
func checkFirstAndDrop(c *C, f *Frame, expectedNodeName string, expectedOK bool) {
first, ok := f.First()
c.Assert(ok, Equals, expectedOK)
if expectedOK {
c.Assert(first.Name(), Equals, expectedNodeName)
}
f.Drop()
}
// a mock noder that returns error when Children() is called
type errorNoder struct{ noder.Noder }
func (e *errorNoder) Children() ([]noder.Noder, error) {
return nil, fmt.Errorf("mock error")
}
func (s *FrameSuite) TestNewFrameErrors(c *C) {
_, err := New(&errorNoder{})
c.Assert(err, ErrorMatches, "mock error")
}
go-git-5.13.2/utils/merkletrie/internal/fsnoder/ 0000775 0000000 0000000 00000000000 14744245500 0021554 5 ustar 00root root 0000000 0000000 go-git-5.13.2/utils/merkletrie/internal/fsnoder/dir.go 0000664 0000000 0000000 00000005570 14744245500 0022670 0 ustar 00root root 0000000 0000000 package fsnoder
import (
"bytes"
"fmt"
"hash/fnv"
"sort"
"strings"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
// Dir values implement directory-like noders.
type dir struct {
name string // relative
children []noder.Noder // sorted by name
hash []byte // memoized
}
type byName []noder.Noder
func (a byName) Len() int { return len(a) }
func (a byName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a byName) Less(i, j int) bool {
return strings.Compare(a[i].Name(), a[j].Name()) < 0
}
// copies the children slice, so nobody can modify the order of its
// elements from the outside.
func newDir(name string, children []noder.Noder) (*dir, error) {
cloned := make([]noder.Noder, len(children))
_ = copy(cloned, children)
sort.Sort(byName(cloned))
if hasChildrenWithNoName(cloned) {
return nil, fmt.Errorf("non-root inner nodes cannot have empty names")
}
if hasDuplicatedNames(cloned) {
return nil, fmt.Errorf("children cannot have duplicated names")
}
return &dir{
name: name,
children: cloned,
}, nil
}
func hasChildrenWithNoName(children []noder.Noder) bool {
for _, c := range children {
if c.Name() == "" {
return true
}
}
return false
}
func hasDuplicatedNames(children []noder.Noder) bool {
if len(children) < 2 {
return false
}
for i := 1; i < len(children); i++ {
if children[i].Name() == children[i-1].Name() {
return true
}
}
return false
}
func (d *dir) Hash() []byte {
if d.hash == nil {
d.calculateHash()
}
return d.hash
}
// hash is calculated as the hash of "dir " plus the concatenation, for
// each child, of its name, a space and its hash. Children are sorted
// alphabetically before calculating the hash, so the result is unique.
func (d *dir) calculateHash() {
h := fnv.New64a()
h.Write([]byte("dir "))
for _, c := range d.children {
h.Write([]byte(c.Name()))
h.Write([]byte(" "))
h.Write(c.Hash())
}
d.hash = h.Sum([]byte{})
}
func (d *dir) Name() string {
return d.name
}
func (d *dir) IsDir() bool {
return true
}
// returns a copy so nobody can alter the order of its elements from the
// outside.
func (d *dir) Children() ([]noder.Noder, error) {
clon := make([]noder.Noder, len(d.children))
_ = copy(clon, d.children)
return clon, nil
}
func (d *dir) NumChildren() (int, error) {
return len(d.children), nil
}
func (d *dir) Skip() bool {
return false
}
const (
dirStartMark = '('
dirEndMark = ')'
dirElementSep = ' '
)
// The string generated by this method is unique for each tree, as the
// children of each node are sorted alphabetically by name when
// generating the string.
func (d *dir) String() string {
var buf bytes.Buffer
buf.WriteString(d.name)
buf.WriteRune(dirStartMark)
for i, c := range d.children {
if i != 0 {
buf.WriteRune(dirElementSep)
}
buf.WriteString(c.String())
}
buf.WriteRune(dirEndMark)
return buf.String()
}
go-git-5.13.2/utils/merkletrie/internal/fsnoder/dir_test.go 0000664 0000000 0000000 00000021753 14744245500 0023730 0 ustar 00root root 0000000 0000000 package fsnoder
import (
"reflect"
"sort"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
. "gopkg.in/check.v1"
)
type DirSuite struct{}
var _ = Suite(&DirSuite{})
func (s *DirSuite) TestIsDir(c *C) {
noName, err := newDir("", nil)
c.Assert(err, IsNil)
c.Assert(noName.IsDir(), Equals, true)
empty, err := newDir("empty", nil)
c.Assert(err, IsNil)
c.Assert(empty.IsDir(), Equals, true)
root, err := newDir("foo", []noder.Noder{empty})
c.Assert(err, IsNil)
c.Assert(root.IsDir(), Equals, true)
}
func assertChildren(c *C, n noder.Noder, expected []noder.Noder) {
numChildren, err := n.NumChildren()
c.Assert(err, IsNil)
c.Assert(numChildren, Equals, len(expected))
children, err := n.Children()
c.Assert(err, IsNil)
c.Assert(children, sortedSliceEquals, expected)
}
type sortedSliceEqualsChecker struct {
*CheckerInfo
}
var sortedSliceEquals Checker = &sortedSliceEqualsChecker{
&CheckerInfo{
Name: "sortedSliceEquals",
Params: []string{"obtained", "expected"},
},
}
func (checker *sortedSliceEqualsChecker) Check(
params []interface{}, names []string) (result bool, error string) {
a, ok := params[0].([]noder.Noder)
if !ok {
return false, "first parameter must be a []noder.Noder"
}
b, ok := params[1].([]noder.Noder)
if !ok {
return false, "second parameter must be a []noder.Noder"
}
sort.Sort(byName(a))
sort.Sort(byName(b))
return reflect.DeepEqual(a, b), ""
}
func (s *DirSuite) TestNewDirectoryNoNameAndEmpty(c *C) {
root, err := newDir("", nil)
c.Assert(err, IsNil)
c.Assert(root.Hash(), DeepEquals,
[]byte{0xca, 0x40, 0xf8, 0x67, 0x57, 0x8c, 0x32, 0x1c})
c.Assert(root.Name(), Equals, "")
assertChildren(c, root, noder.NoChildren)
c.Assert(root.String(), Equals, "()")
}
func (s *DirSuite) TestNewDirectoryEmpty(c *C) {
root, err := newDir("root", nil)
c.Assert(err, IsNil)
c.Assert(root.Hash(), DeepEquals,
[]byte{0xca, 0x40, 0xf8, 0x67, 0x57, 0x8c, 0x32, 0x1c})
c.Assert(root.Name(), Equals, "root")
assertChildren(c, root, noder.NoChildren)
c.Assert(root.String(), Equals, "root()")
}
func (s *DirSuite) TestEmptyDirsHaveSameHash(c *C) {
d1, err := newDir("foo", nil)
c.Assert(err, IsNil)
d2, err := newDir("bar", nil)
c.Assert(err, IsNil)
c.Assert(d1.Hash(), DeepEquals, d2.Hash())
}
func (s *DirSuite) TestNewDirWithEmptyDir(c *C) {
empty, err := newDir("empty", nil)
c.Assert(err, IsNil)
root, err := newDir("", []noder.Noder{empty})
c.Assert(err, IsNil)
c.Assert(root.Hash(), DeepEquals,
[]byte{0x39, 0x25, 0xa8, 0x99, 0x16, 0x47, 0x6a, 0x75})
c.Assert(root.Name(), Equals, "")
assertChildren(c, root, []noder.Noder{empty})
c.Assert(root.String(), Equals, "(empty())")
}
func (s *DirSuite) TestNewDirWithOneEmptyFile(c *C) {
empty, err := newFile("name", "")
c.Assert(err, IsNil)
root, err := newDir("", []noder.Noder{empty})
c.Assert(err, IsNil)
c.Assert(root.Hash(), DeepEquals,
[]byte{0xd, 0x4e, 0x23, 0x1d, 0xf5, 0x2e, 0xfa, 0xc2})
c.Assert(root.Name(), Equals, "")
assertChildren(c, root, []noder.Noder{empty})
c.Assert(root.String(), Equals, "(name<>)")
}
func (s *DirSuite) TestNewDirWithOneFile(c *C) {
a, err := newFile("a", "1")
c.Assert(err, IsNil)
root, err := newDir("", []noder.Noder{a})
c.Assert(err, IsNil)
c.Assert(root.Hash(), DeepEquals,
[]byte{0x96, 0xab, 0x29, 0x54, 0x2, 0x9e, 0x89, 0x28})
c.Assert(root.Name(), Equals, "")
assertChildren(c, root, []noder.Noder{a})
c.Assert(root.String(), Equals, "(a<1>)")
}
func (s *DirSuite) TestDirsWithSameFileHaveSameHash(c *C) {
f1, err := newFile("a", "1")
c.Assert(err, IsNil)
r1, err := newDir("", []noder.Noder{f1})
c.Assert(err, IsNil)
f2, err := newFile("a", "1")
c.Assert(err, IsNil)
r2, err := newDir("", []noder.Noder{f2})
c.Assert(err, IsNil)
c.Assert(r1.Hash(), DeepEquals, r2.Hash())
}
func (s *DirSuite) TestDirsWithDifferentFileContentHaveDifferentHash(c *C) {
f1, err := newFile("a", "1")
c.Assert(err, IsNil)
r1, err := newDir("", []noder.Noder{f1})
c.Assert(err, IsNil)
f2, err := newFile("a", "2")
c.Assert(err, IsNil)
r2, err := newDir("", []noder.Noder{f2})
c.Assert(err, IsNil)
c.Assert(r1.Hash(), Not(DeepEquals), r2.Hash())
}
func (s *DirSuite) TestDirsWithDifferentFileNameHaveDifferentHash(c *C) {
f1, err := newFile("a", "1")
c.Assert(err, IsNil)
r1, err := newDir("", []noder.Noder{f1})
c.Assert(err, IsNil)
f2, err := newFile("b", "1")
c.Assert(err, IsNil)
r2, err := newDir("", []noder.Noder{f2})
c.Assert(err, IsNil)
c.Assert(r1.Hash(), Not(DeepEquals), r2.Hash())
}
func (s *DirSuite) TestDirsWithDifferentFileHaveDifferentHash(c *C) {
f1, err := newFile("a", "1")
c.Assert(err, IsNil)
r1, err := newDir("", []noder.Noder{f1})
c.Assert(err, IsNil)
f2, err := newFile("b", "2")
c.Assert(err, IsNil)
r2, err := newDir("", []noder.Noder{f2})
c.Assert(err, IsNil)
c.Assert(r1.Hash(), Not(DeepEquals), r2.Hash())
}
func (s *DirSuite) TestDirWithEmptyDirHasDifferentHashThanEmptyDir(c *C) {
f, err := newFile("a", "")
c.Assert(err, IsNil)
r1, err := newDir("", []noder.Noder{f})
c.Assert(err, IsNil)
d, err := newDir("a", nil)
c.Assert(err, IsNil)
r2, err := newDir("", []noder.Noder{d})
c.Assert(err, IsNil)
c.Assert(r1.Hash(), Not(DeepEquals), r2.Hash())
}
func (s *DirSuite) TestNewDirWithTwoFilesSameContent(c *C) {
a1, err := newFile("a", "1")
c.Assert(err, IsNil)
b1, err := newFile("b", "1")
c.Assert(err, IsNil)
root, err := newDir("", []noder.Noder{a1, b1})
c.Assert(err, IsNil)
c.Assert(root.Hash(), DeepEquals,
[]byte{0xc7, 0xc4, 0xbf, 0x70, 0x33, 0xb9, 0x57, 0xdb})
c.Assert(root.Name(), Equals, "")
assertChildren(c, root, []noder.Noder{b1, a1})
c.Assert(root.String(), Equals, "(a<1> b<1>)")
}
func (s *DirSuite) TestNewDirWithTwoFilesDifferentContent(c *C) {
a1, err := newFile("a", "1")
c.Assert(err, IsNil)
b2, err := newFile("b", "2")
c.Assert(err, IsNil)
root, err := newDir("", []noder.Noder{a1, b2})
c.Assert(err, IsNil)
c.Assert(root.Hash(), DeepEquals,
[]byte{0x94, 0x8a, 0x9d, 0x8f, 0x6d, 0x98, 0x34, 0x55})
c.Assert(root.Name(), Equals, "")
assertChildren(c, root, []noder.Noder{b2, a1})
}
func (s *DirSuite) TestCrazy(c *C) {
// ""
// |
// -------------------------
// | | | | |
// a1 B c1 d2 E
// | |
// ------------- E
// | | | | |
// A B X c1 E
// | |
// a1 e1
e1, err := newFile("e", "1")
c.Assert(err, IsNil)
E, err := newDir("e", []noder.Noder{e1})
c.Assert(err, IsNil)
E, err = newDir("e", []noder.Noder{E})
c.Assert(err, IsNil)
E, err = newDir("e", []noder.Noder{E})
c.Assert(err, IsNil)
A, err := newDir("a", nil)
c.Assert(err, IsNil)
B, err := newDir("b", nil)
c.Assert(err, IsNil)
a1, err := newFile("a", "1")
c.Assert(err, IsNil)
X, err := newDir("x", []noder.Noder{a1})
c.Assert(err, IsNil)
c1, err := newFile("c", "1")
c.Assert(err, IsNil)
B, err = newDir("b", []noder.Noder{c1, B, X, A})
c.Assert(err, IsNil)
a1, err = newFile("a", "1")
c.Assert(err, IsNil)
c1, err = newFile("c", "1")
c.Assert(err, IsNil)
d2, err := newFile("d", "2")
c.Assert(err, IsNil)
root, err := newDir("", []noder.Noder{a1, d2, E, B, c1})
c.Assert(err, IsNil)
c.Assert(root.Hash(), DeepEquals,
[]byte{0xc3, 0x72, 0x9d, 0xf1, 0xcc, 0xec, 0x6d, 0xbb})
c.Assert(root.Name(), Equals, "")
assertChildren(c, root, []noder.Noder{E, c1, B, a1, d2})
c.Assert(root.String(), Equals,
"(a<1> b(a() b() c<1> x(a<1>)) c<1> d<2> e(e(e(e<1>))))")
}
func (s *DirSuite) TestDirCannotHaveDirWithNoName(c *C) {
noName, err := newDir("", nil)
c.Assert(err, IsNil)
_, err = newDir("", []noder.Noder{noName})
c.Assert(err, Not(IsNil))
}
func (s *DirSuite) TestDirCannotHaveDuplicatedFiles(c *C) {
f1, err := newFile("a", "1")
c.Assert(err, IsNil)
f2, err := newFile("a", "1")
c.Assert(err, IsNil)
_, err = newDir("", []noder.Noder{f1, f2})
c.Assert(err, Not(IsNil))
}
func (s *DirSuite) TestDirCannotHaveDuplicatedFileNames(c *C) {
a1, err := newFile("a", "1")
c.Assert(err, IsNil)
a2, err := newFile("a", "2")
c.Assert(err, IsNil)
_, err = newDir("", []noder.Noder{a1, a2})
c.Assert(err, Not(IsNil))
}
func (s *DirSuite) TestDirCannotHaveDuplicatedDirNames(c *C) {
d1, err := newDir("a", nil)
c.Assert(err, IsNil)
d2, err := newDir("a", nil)
c.Assert(err, IsNil)
_, err = newDir("", []noder.Noder{d1, d2})
c.Assert(err, Not(IsNil))
}
func (s *DirSuite) TestDirCannotHaveDirAndFileWithSameName(c *C) {
f, err := newFile("a", "")
c.Assert(err, IsNil)
d, err := newDir("a", nil)
c.Assert(err, IsNil)
_, err = newDir("", []noder.Noder{f, d})
c.Assert(err, Not(IsNil))
}
func (s *DirSuite) TestUnsortedString(c *C) {
b, err := newDir("b", nil)
c.Assert(err, IsNil)
z, err := newDir("z", nil)
c.Assert(err, IsNil)
a1, err := newFile("a", "1")
c.Assert(err, IsNil)
c2, err := newFile("c", "2")
c.Assert(err, IsNil)
d3, err := newFile("d", "3")
c.Assert(err, IsNil)
d, err := newDir("d", []noder.Noder{c2, z, d3, a1, b})
c.Assert(err, IsNil)
c.Assert(d.String(), Equals, "d(a<1> b() c<2> d<3> z())")
}
go-git-5.13.2/utils/merkletrie/internal/fsnoder/doc.go 0000664 0000000 0000000 00000003154 14744245500 0022653 0 ustar 00root root 0000000 0000000 /*
Package fsnoder allows to create merkletrie noders that resemble file
systems, from human readable string descriptions. Its intended use is
generating noders in tests in a readable way.
For example:
root, _ = New("(a<1> b<2>, B(c<3> d()))")
will create a noder as follows:
root - "root" is an unnamed dir containing "a", "b" and "B".
/ | \ - "a" is a file containing the string "1".
/ | \ - "b" is a file containing the string "2".
a b B - "B" is a directory containing "c" and "d".
/ \ - "c" is a file containing the string "3".
c d - "D" is an empty directory.
Files are expressed as:
- one or more letters and dots for the name of the file
- a single number, between angle brackets, for the contents of the file.
- examples: a<1>, foo.go<2>.
Directories are expressed as:
- one or more letters for the name of the directory.
- its elements between parents, separated with spaces, in any order.
- (optionally) the root directory can be unnamed, by skipping its name.
Examples:
- D(a<1> b<2>) : two files, "a" and "b", having "1" and "2" as their
respective contents, inside a directory called "D".
- A() : An empty directory called "A".
- A(b<>) : An directory called "A", with an empty file inside called "b":
- (b(c<1> d(e<2>)) f<>) : an unamed directory containing:
├── b --> directory
│ ├── c --> file containing "1"
│ └── d --> directory
│ └── e --> file containing "2"
└── f --> empty file
*/
package fsnoder
go-git-5.13.2/utils/merkletrie/internal/fsnoder/file.go 0000664 0000000 0000000 00000002600 14744245500 0023020 0 ustar 00root root 0000000 0000000 package fsnoder
import (
"bytes"
"fmt"
"hash/fnv"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
// file values represent file-like noders in a merkle trie.
type file struct {
name string // relative
contents string
hash []byte // memoized
}
// newFile returns a noder representing a file with the given contents.
func newFile(name, contents string) (*file, error) {
if name == "" {
return nil, fmt.Errorf("files cannot have empty names")
}
return &file{
name: name,
contents: contents,
}, nil
}
// The hash of a file is just its contents.
// Empty files will have the fnv64 basis offset as its hash.
func (f *file) Hash() []byte {
if f.hash == nil {
h := fnv.New64a()
h.Write([]byte(f.contents)) // it never returns an error.
f.hash = h.Sum(nil)
}
return f.hash
}
func (f *file) Name() string {
return f.name
}
func (f *file) IsDir() bool {
return false
}
func (f *file) Children() ([]noder.Noder, error) {
return noder.NoChildren, nil
}
func (f *file) NumChildren() (int, error) {
return 0, nil
}
func (f *file) Skip() bool {
return false
}
const (
fileStartMark = '<'
fileEndMark = '>'
)
// String returns a string formatted as: name.
func (f *file) String() string {
var buf bytes.Buffer
buf.WriteString(f.name)
buf.WriteRune(fileStartMark)
buf.WriteString(f.contents)
buf.WriteRune(fileEndMark)
return buf.String()
}
go-git-5.13.2/utils/merkletrie/internal/fsnoder/file_test.go 0000664 0000000 0000000 00000003141 14744245500 0024060 0 ustar 00root root 0000000 0000000 package fsnoder
import (
"testing"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type FileSuite struct{}
var _ = Suite(&FileSuite{})
var (
HashOfEmptyFile = []byte{0xcb, 0xf2, 0x9c, 0xe4, 0x84, 0x22, 0x23, 0x25} // fnv64 basis offset
HashOfContents = []byte{0xee, 0x7e, 0xf3, 0xd0, 0xc2, 0xb5, 0xef, 0x83} // hash of "contents"
)
func (s *FileSuite) TestNewFileEmpty(c *C) {
f, err := newFile("name", "")
c.Assert(err, IsNil)
c.Assert(f.Hash(), DeepEquals, HashOfEmptyFile)
c.Assert(f.Name(), Equals, "name")
c.Assert(f.IsDir(), Equals, false)
assertChildren(c, f, noder.NoChildren)
c.Assert(f.String(), Equals, "name<>")
}
func (s *FileSuite) TestNewFileWithContents(c *C) {
f, err := newFile("name", "contents")
c.Assert(err, IsNil)
c.Assert(f.Hash(), DeepEquals, HashOfContents)
c.Assert(f.Name(), Equals, "name")
c.Assert(f.IsDir(), Equals, false)
assertChildren(c, f, noder.NoChildren)
c.Assert(f.String(), Equals, "name")
}
func (s *FileSuite) TestNewfileErrorEmptyName(c *C) {
_, err := newFile("", "contents")
c.Assert(err, Not(IsNil))
}
func (s *FileSuite) TestDifferentContentsHaveDifferentHash(c *C) {
f1, err := newFile("name", "contents")
c.Assert(err, IsNil)
f2, err := newFile("name", "foo")
c.Assert(err, IsNil)
c.Assert(f1.Hash(), Not(DeepEquals), f2.Hash())
}
func (s *FileSuite) TestSameContentsHaveSameHash(c *C) {
f1, err := newFile("name1", "contents")
c.Assert(err, IsNil)
f2, err := newFile("name2", "contents")
c.Assert(err, IsNil)
c.Assert(f1.Hash(), DeepEquals, f2.Hash())
}
go-git-5.13.2/utils/merkletrie/internal/fsnoder/new.go 0000664 0000000 0000000 00000010770 14744245500 0022701 0 ustar 00root root 0000000 0000000 package fsnoder
import (
"bytes"
"fmt"
"io"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
// New function creates a full merkle trie from the string description of
// a filesystem tree. See examples of the string format in the package
// description.
func New(s string) (noder.Noder, error) {
return decodeDir([]byte(s), root)
}
const (
root = true
nonRoot = false
)
// Expected data: a fsnoder description, for example: A(foo bar qux ...).
// When isRoot is true, unnamed dirs are supported, for example: (foo
// bar qux ...)
func decodeDir(data []byte, isRoot bool) (*dir, error) {
data = bytes.TrimSpace(data)
if len(data) == 0 {
return nil, io.EOF
}
// get the name of the dir and remove it from the data. In case the
// there is no name and isRoot is true, just use "" as the name.
var name string
switch end := bytes.IndexRune(data, dirStartMark); end {
case -1:
return nil, fmt.Errorf("%c not found", dirStartMark)
case 0:
if isRoot {
name = ""
} else {
return nil, fmt.Errorf("inner unnamed dirs not allowed: %s", data)
}
default:
name = string(data[0:end])
data = data[end:]
}
// check data ends with the dirEndMark
if data[len(data)-1] != dirEndMark {
return nil, fmt.Errorf("malformed data: last %q not found",
dirEndMark)
}
data = data[1 : len(data)-1] // remove initial '(' and last ')'
children, err := decodeChildren(data)
if err != nil {
return nil, err
}
return newDir(name, children)
}
func isNumber(b rune) bool {
return '0' <= b && b <= '9'
}
func isLetter(b rune) bool {
return ('a' <= b && b <= 'z') || ('A' <= b && b <= 'Z')
}
func decodeChildren(data []byte) ([]noder.Noder, error) {
data = bytes.TrimSpace(data)
if len(data) == 0 {
return nil, nil
}
chunks := split(data)
ret := make([]noder.Noder, len(chunks))
var err error
for i, c := range chunks {
ret[i], err = decodeChild(c)
if err != nil {
return nil, fmt.Errorf("malformed element %d (%s): %s", i, c, err)
}
}
return ret, nil
}
// returns the description of the elements of a dir. It is just looking
// for spaces if they are not part of inner dirs.
func split(data []byte) [][]byte {
chunks := [][]byte{}
start := 0
dirDepth := 0
for i, b := range data {
switch b {
case dirStartMark:
dirDepth++
case dirEndMark:
dirDepth--
case dirElementSep:
if dirDepth == 0 {
chunks = append(chunks, data[start:i+1])
start = i + 1
}
}
}
chunks = append(chunks, data[start:])
return chunks
}
// A child can be a file or a dir.
func decodeChild(data []byte) (noder.Noder, error) {
clean := bytes.TrimSpace(data)
if len(data) < 3 {
return nil, fmt.Errorf("element too short: %s", clean)
}
fileNameEnd := bytes.IndexRune(data, fileStartMark)
dirNameEnd := bytes.IndexRune(data, dirStartMark)
switch {
case fileNameEnd == -1 && dirNameEnd == -1:
return nil, fmt.Errorf(
"malformed child, no file or dir start mark found")
case fileNameEnd == -1:
return decodeDir(clean, nonRoot)
case dirNameEnd == -1:
return decodeFile(clean)
case dirNameEnd < fileNameEnd:
return decodeDir(clean, nonRoot)
case dirNameEnd > fileNameEnd:
return decodeFile(clean)
}
return nil, fmt.Errorf("unreachable")
}
func decodeFile(data []byte) (noder.Noder, error) {
nameEnd := bytes.IndexRune(data, fileStartMark)
if nameEnd == -1 {
return nil, fmt.Errorf("malformed file, no %c found", fileStartMark)
}
contentStart := nameEnd + 1
contentEnd := bytes.IndexRune(data, fileEndMark)
if contentEnd == -1 {
return nil, fmt.Errorf("malformed file, no %c found", fileEndMark)
}
switch {
case nameEnd > contentEnd:
return nil, fmt.Errorf("malformed file, found %c before %c",
fileEndMark, fileStartMark)
case contentStart == contentEnd:
name := string(data[:nameEnd])
if !validFileName(name) {
return nil, fmt.Errorf("invalid file name")
}
return newFile(name, "")
default:
name := string(data[:nameEnd])
if !validFileName(name) {
return nil, fmt.Errorf("invalid file name")
}
contents := string(data[contentStart:contentEnd])
if !validFileContents(contents) {
return nil, fmt.Errorf("invalid file contents")
}
return newFile(name, contents)
}
}
func validFileName(s string) bool {
for _, c := range s {
if !isLetter(c) && c != '.' {
return false
}
}
return true
}
func validFileContents(s string) bool {
for _, c := range s {
if !isNumber(c) {
return false
}
}
return true
}
// HashEqual returns if a and b have the same hash.
func HashEqual(a, b noder.Hasher) bool {
return bytes.Equal(a.Hash(), b.Hash())
}
go-git-5.13.2/utils/merkletrie/internal/fsnoder/new_test.go 0000664 0000000 0000000 00000017721 14744245500 0023743 0 ustar 00root root 0000000 0000000 package fsnoder
import (
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
. "gopkg.in/check.v1"
)
type FSNoderSuite struct{}
var _ = Suite(&FSNoderSuite{})
func check(c *C, input string, expected *dir) {
obtained, err := New(input)
c.Assert(err, IsNil, Commentf("input = %s", input))
comment := Commentf("\n input = %s\n"+
"expected = %s\nobtained = %s",
input, expected, obtained)
c.Assert(obtained.Hash(), DeepEquals, expected.Hash(), comment)
}
func (s *FSNoderSuite) TestNoDataFails(c *C) {
_, err := New("")
c.Assert(err, Not(IsNil))
_, err = New(" ") // SPC + TAB
c.Assert(err, Not(IsNil))
}
func (s *FSNoderSuite) TestUnnamedRootFailsIfNotRoot(c *C) {
_, err := decodeDir([]byte("()"), false)
c.Assert(err, Not(IsNil))
}
func (s *FSNoderSuite) TestUnnamedInnerFails(c *C) {
_, err := New("(())")
c.Assert(err, Not(IsNil))
_, err = New("((a<>))")
c.Assert(err, Not(IsNil))
}
func (s *FSNoderSuite) TestMalformedFile(c *C) {
_, err := New("(4<>)")
c.Assert(err, Not(IsNil))
_, err = New("(4<1>)")
c.Assert(err, Not(IsNil))
_, err = New("(4?1>)")
c.Assert(err, Not(IsNil))
_, err = New("(4)")
c.Assert(err, Not(IsNil))
_, err = New("(4"))
c.Assert(err, Not(IsNil))
_, err = decodeFile([]byte("a"))
c.Assert(err, Not(IsNil))
_, err = decodeFile([]byte("a<1?"))
c.Assert(err, Not(IsNil))
_, err = decodeFile([]byte("a?>"))
c.Assert(err, Not(IsNil))
_, err = decodeFile([]byte("1<>"))
c.Assert(err, Not(IsNil))
_, err = decodeFile([]byte("a")
c.Assert(err, Not(IsNil))
_, err = New("a<>")
c.Assert(err, Not(IsNil))
}
func (s *FSNoderSuite) TestUnnamedEmptyRoot(c *C) {
input := "()"
expected, err := newDir("", nil)
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestNamedEmptyRoot(c *C) {
input := "a()"
expected, err := newDir("a", nil)
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestEmptyFile(c *C) {
input := "(a<>)"
a1, err := newFile("a", "")
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{a1})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestNonEmptyFile(c *C) {
input := "(a<1>)"
a1, err := newFile("a", "1")
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{a1})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestTwoFilesSameContents(c *C) {
input := "(b<1> a<1>)"
a1, err := newFile("a", "1")
c.Assert(err, IsNil)
b1, err := newFile("b", "1")
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{a1, b1})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestTwoFilesDifferentContents(c *C) {
input := "(b<2> a<1>)"
a1, err := newFile("a", "1")
c.Assert(err, IsNil)
b2, err := newFile("b", "2")
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{a1, b2})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestManyFiles(c *C) {
input := "(e<1> b<2> a<1> c<1> d<3> f<4>)"
a1, err := newFile("a", "1")
c.Assert(err, IsNil)
b2, err := newFile("b", "2")
c.Assert(err, IsNil)
c1, err := newFile("c", "1")
c.Assert(err, IsNil)
d3, err := newFile("d", "3")
c.Assert(err, IsNil)
e1, err := newFile("e", "1")
c.Assert(err, IsNil)
f4, err := newFile("f", "4")
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{e1, b2, a1, c1, d3, f4})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestEmptyDir(c *C) {
input := "(A())"
A, err := newDir("A", nil)
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{A})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestDirWithEmptyFile(c *C) {
input := "(A(a<>))"
a, err := newFile("a", "")
c.Assert(err, IsNil)
A, err := newDir("A", []noder.Noder{a})
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{A})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestDirWithEmptyFileSameName(c *C) {
input := "(A(A<>))"
f, err := newFile("A", "")
c.Assert(err, IsNil)
A, err := newDir("A", []noder.Noder{f})
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{A})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestDirWithFileLongContents(c *C) {
input := "(A(a<12>))"
a1, err := newFile("a", "12")
c.Assert(err, IsNil)
A, err := newDir("A", []noder.Noder{a1})
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{A})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestDirWithFileLongName(c *C) {
input := "(A(abc<12>))"
a1, err := newFile("abc", "12")
c.Assert(err, IsNil)
A, err := newDir("A", []noder.Noder{a1})
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{A})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestDirWithFile(c *C) {
input := "(A(a<1>))"
a1, err := newFile("a", "1")
c.Assert(err, IsNil)
A, err := newDir("A", []noder.Noder{a1})
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{A})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestDirWithEmptyDirSameName(c *C) {
input := "(A(A()))"
A2, err := newDir("A", nil)
c.Assert(err, IsNil)
A1, err := newDir("A", []noder.Noder{A2})
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{A1})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestDirWithEmptyDir(c *C) {
input := "(A(B()))"
B, err := newDir("B", nil)
c.Assert(err, IsNil)
A, err := newDir("A", []noder.Noder{B})
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{A})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestDirWithTwoFiles(c *C) {
input := "(A(a<1> b<2>))"
a1, err := newFile("a", "1")
c.Assert(err, IsNil)
b2, err := newFile("b", "2")
c.Assert(err, IsNil)
A, err := newDir("A", []noder.Noder{b2, a1})
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{A})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestCrazy(c *C) {
// ""
// |
// -------------------------
// | | | | |
// a1 B c1 d2 E
// | |
// ------------- E
// | | | | |
// A B X c1 E
// | |
// a1 e1
input := "(d<2> b(c<1> b() a() x(a<1>)) a<1> c<1> e(e(e(e<1>))))"
e1, err := newFile("e", "1")
c.Assert(err, IsNil)
E, err := newDir("e", []noder.Noder{e1})
c.Assert(err, IsNil)
E, err = newDir("e", []noder.Noder{E})
c.Assert(err, IsNil)
E, err = newDir("e", []noder.Noder{E})
c.Assert(err, IsNil)
A, err := newDir("a", nil)
c.Assert(err, IsNil)
B, err := newDir("b", nil)
c.Assert(err, IsNil)
a1, err := newFile("a", "1")
c.Assert(err, IsNil)
X, err := newDir("x", []noder.Noder{a1})
c.Assert(err, IsNil)
c1, err := newFile("c", "1")
c.Assert(err, IsNil)
B, err = newDir("b", []noder.Noder{c1, B, X, A})
c.Assert(err, IsNil)
a1, err = newFile("a", "1")
c.Assert(err, IsNil)
c1, err = newFile("c", "1")
c.Assert(err, IsNil)
d2, err := newFile("d", "2")
c.Assert(err, IsNil)
expected, err := newDir("", []noder.Noder{a1, d2, E, B, c1})
c.Assert(err, IsNil)
check(c, input, expected)
}
func (s *FSNoderSuite) TestHashEqual(c *C) {
input1 := "(A(a<1> b<2>))"
input2 := "(A(a<1> b<2>))"
input3 := "(A(a<> b<2>))"
t1, err := New(input1)
c.Assert(err, IsNil)
t2, err := New(input2)
c.Assert(err, IsNil)
t3, err := New(input3)
c.Assert(err, IsNil)
c.Assert(HashEqual(t1, t2), Equals, true)
c.Assert(HashEqual(t2, t1), Equals, true)
c.Assert(HashEqual(t2, t3), Equals, false)
c.Assert(HashEqual(t3, t2), Equals, false)
c.Assert(HashEqual(t3, t1), Equals, false)
c.Assert(HashEqual(t1, t3), Equals, false)
}
go-git-5.13.2/utils/merkletrie/iter.go 0000664 0000000 0000000 00000014115 14744245500 0017574 0 ustar 00root root 0000000 0000000 package merkletrie
import (
"fmt"
"io"
"github.com/go-git/go-git/v5/utils/merkletrie/internal/frame"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
// Iter is an iterator for merkletries (only the trie part of the
// merkletrie is relevant here, it does not use the Hasher interface).
//
// The iteration is performed in depth-first pre-order. Entries at each
// depth are traversed in (case-sensitive) alphabetical order.
//
// This is the kind of traversal you will expect when listing ordinary
// files and directories recursively, for example:
//
// Trie Traversal order
// ---- ---------------
// .
// / | \ c
// / | \ d/
// d c z ===> d/a
// / \ d/b
// b a z
//
//
// This iterator is somewhat especial as you can chose to skip whole
// "directories" when iterating:
//
// - The Step method will iterate normally.
//
// - the Next method will not descend deeper into the tree.
//
// For example, if the iterator is at `d/`, the Step method will return
// `d/a` while the Next would have returned `z` instead (skipping `d/`
// and its descendants). The name of the these two methods are based on
// the well known "next" and "step" operations, quite common in
// debuggers, like gdb.
//
// The paths returned by the iterator will be relative, if the iterator
// was created from a single node, or absolute, if the iterator was
// created from the path to the node (the path will be prefixed to all
// returned paths).
type Iter struct {
// Tells if the iteration has started.
hasStarted bool
// The top of this stack has the current node and its siblings. The
// rest of the stack keeps the ancestors of the current node and
// their corresponding siblings. The current element is always the
// top element of the top frame.
//
// When "step"ping into a node, its children are pushed as a new
// frame.
//
// When "next"ing pass a node, the current element is dropped by
// popping the top frame.
frameStack []*frame.Frame
// The base path used to turn the relative paths used internally by
// the iterator into absolute paths used by external applications.
// For relative iterator this will be nil.
base noder.Path
}
// NewIter returns a new relative iterator using the provider noder as
// its unnamed root. When iterating, all returned paths will be
// relative to node.
func NewIter(n noder.Noder) (*Iter, error) {
return newIter(n, nil)
}
// NewIterFromPath returns a new absolute iterator from the noder at the
// end of the path p. When iterating, all returned paths will be
// absolute, using the root of the path p as their root.
func NewIterFromPath(p noder.Path) (*Iter, error) {
return newIter(p, p) // Path implements Noder
}
func newIter(root noder.Noder, base noder.Path) (*Iter, error) {
ret := &Iter{
base: base,
}
if root == nil {
return ret, nil
}
frame, err := frame.New(root)
if err != nil {
return nil, err
}
ret.push(frame)
return ret, nil
}
func (iter *Iter) top() (*frame.Frame, bool) {
if len(iter.frameStack) == 0 {
return nil, false
}
top := len(iter.frameStack) - 1
return iter.frameStack[top], true
}
func (iter *Iter) push(f *frame.Frame) {
iter.frameStack = append(iter.frameStack, f)
}
const (
doDescend = true
dontDescend = false
)
// Next returns the path of the next node without descending deeper into
// the trie and nil. If there are no more entries in the trie it
// returns nil and io.EOF. In case of error, it will return nil and the
// error.
func (iter *Iter) Next() (noder.Path, error) {
return iter.advance(dontDescend)
}
// Step returns the path to the next node in the trie, descending deeper
// into it if needed, and nil. If there are no more nodes in the trie,
// it returns nil and io.EOF. In case of error, it will return nil and
// the error.
func (iter *Iter) Step() (noder.Path, error) {
return iter.advance(doDescend)
}
// Advances the iterator in the desired direction: descend or
// dontDescend.
//
// Returns the new current element and a nil error on success. If there
// are no more elements in the trie below the base, it returns nil, and
// io.EOF. Returns nil and an error in case of errors.
func (iter *Iter) advance(wantDescend bool) (noder.Path, error) {
current, err := iter.current()
if err != nil {
return nil, err
}
// The first time we just return the current node.
if !iter.hasStarted {
iter.hasStarted = true
return current, nil
}
// Advances means getting a next current node, either its first child or
// its next sibling, depending if we must descend or not.
numChildren, err := current.NumChildren()
if err != nil {
return nil, err
}
mustDescend := numChildren != 0 && wantDescend
if mustDescend {
// descend: add a new frame with the current's children.
frame, err := frame.New(current)
if err != nil {
return nil, err
}
iter.push(frame)
} else {
// don't descend: just drop the current node
iter.drop()
}
return iter.current()
}
// Returns the path to the current node, adding the base if there was
// one, and a nil error. If there were no noders left, it returns nil
// and io.EOF. If an error occurred, it returns nil and the error.
func (iter *Iter) current() (noder.Path, error) {
if topFrame, ok := iter.top(); !ok {
return nil, io.EOF
} else if _, ok := topFrame.First(); !ok {
return nil, io.EOF
}
ret := make(noder.Path, 0, len(iter.base)+len(iter.frameStack))
// concat the base...
ret = append(ret, iter.base...)
// ... and the current node and all its ancestors
for i, f := range iter.frameStack {
t, ok := f.First()
if !ok {
panic(fmt.Sprintf("frame %d is empty", i))
}
ret = append(ret, t)
}
return ret, nil
}
// removes the current node if any, and all the frames that become empty as a
// consequence of this action.
func (iter *Iter) drop() {
frame, ok := iter.top()
if !ok {
return
}
frame.Drop()
// if the frame is empty, remove it and its parent, recursively
if frame.Len() == 0 {
top := len(iter.frameStack) - 1
iter.frameStack[top] = nil
iter.frameStack = iter.frameStack[:top]
iter.drop()
}
}
go-git-5.13.2/utils/merkletrie/iter_test.go 0000664 0000000 0000000 00000027315 14744245500 0020641 0 ustar 00root root 0000000 0000000 package merkletrie_test
import (
"fmt"
"io"
"strings"
"github.com/go-git/go-git/v5/utils/merkletrie"
"github.com/go-git/go-git/v5/utils/merkletrie/internal/fsnoder"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
. "gopkg.in/check.v1"
)
type IterSuite struct{}
var _ = Suite(&IterSuite{})
// A test is a list of operations we want to perform on an iterator and
// their expected results.
//
// The operations are expressed as a sequence of `n` and `s`,
// representing the amount of next and step operations we want to call
// on the iterator and their order. For example, an operations value of
// "nns" means: call a `n`ext, then another `n`ext and finish with a
// `s`tep.
//
// The expected is the full path of the noders returned by the
// operations, separated by spaces.
//
// For instance:
//
// t := test{
// operations: "ns",
// expected: "a a/b"
// }
//
// means:
//
// - the first iterator operation has to be Next, and it must return a
// node called "a" with no ancestors.
//
// - the second operation has to be Step, and it must return a node
// called "b" with a single ancestor called "a".
type test struct {
operations string
expected string
}
// Runs a test on the provided iterator, checking that the names of the
// returned values are correct. If not, the treeDescription value is
// printed along with information about mismatch.
func (t test) run(c *C, iter *merkletrie.Iter,
treeDescription string, testNumber int) {
expectedChunks := strings.Split(t.expected, " ")
if t.expected == "" {
expectedChunks = []string{}
}
if len(t.operations) < len(expectedChunks) {
c.Fatalf("malformed test %d: not enough operations", testNumber)
return
}
var obtained noder.Path
var err error
for i, b := range t.operations {
comment := Commentf("\ntree: %q\ntest #%d (%q)\noperation #%d (%q)",
treeDescription, testNumber, t.operations, i, t.operations[i])
switch t.operations[i] {
case 'n':
obtained, err = iter.Next()
if err != io.EOF {
c.Assert(err, IsNil)
}
case 's':
obtained, err = iter.Step()
if err != io.EOF {
c.Assert(err, IsNil)
}
default:
c.Fatalf("unknown operation at test %d, operation %d (%c)\n",
testNumber, i, b)
}
if i >= len(expectedChunks) {
c.Assert(err, Equals, io.EOF, comment)
continue
}
c.Assert(err, IsNil, comment)
c.Assert(obtained.String(), Equals, expectedChunks[i], comment)
}
}
// A testsCollection value represents a tree and a collection of tests
// we want to perform on iterators of that tree.
//
// Example:
//
// .
// |
// ---------
// | | |
// a b c
// |
// z
//
// var foo testCollection = {
// tree: "(a<> b(z<>) c<>)"
// tests: []test{
// {operations: "nns", expected: "a b b/z"},
// {operations: "nnn", expected: "a b c"},
// },
// }
//
// A new iterator will be build for each test.
type testsCollection struct {
tree string // a fsnoder description of a tree.
tests []test // the collection of tests we want to run
}
// Executes all the tests in a testsCollection.
func (tc testsCollection) run(c *C) {
root, err := fsnoder.New(tc.tree)
c.Assert(err, IsNil)
for i, t := range tc.tests {
iter, err := merkletrie.NewIter(root)
c.Assert(err, IsNil)
t.run(c, iter, root.String(), i)
}
}
func (s *IterSuite) TestEmptyNamedDir(c *C) {
tc := testsCollection{
tree: "A()",
tests: []test{
{operations: "n", expected: ""},
{operations: "nn", expected: ""},
{operations: "nnn", expected: ""},
{operations: "nnns", expected: ""},
{operations: "nnnssnsnns", expected: ""},
{operations: "s", expected: ""},
{operations: "ss", expected: ""},
{operations: "sss", expected: ""},
{operations: "sssn", expected: ""},
{operations: "sssnnsnssn", expected: ""},
},
}
tc.run(c)
}
func (s *IterSuite) TestEmptyUnnamedDir(c *C) {
tc := testsCollection{
tree: "()",
tests: []test{
{operations: "n", expected: ""},
{operations: "nn", expected: ""},
{operations: "nnn", expected: ""},
{operations: "nnns", expected: ""},
{operations: "nnnssnsnns", expected: ""},
{operations: "s", expected: ""},
{operations: "ss", expected: ""},
{operations: "sss", expected: ""},
{operations: "sssn", expected: ""},
{operations: "sssnnsnssn", expected: ""},
},
}
tc.run(c)
}
func (s *IterSuite) TestOneFile(c *C) {
tc := testsCollection{
tree: "(a<>)",
tests: []test{
{operations: "n", expected: "a"},
{operations: "nn", expected: "a"},
{operations: "nnn", expected: "a"},
{operations: "nnns", expected: "a"},
{operations: "nnnssnsnns", expected: "a"},
{operations: "s", expected: "a"},
{operations: "ss", expected: "a"},
{operations: "sss", expected: "a"},
{operations: "sssn", expected: "a"},
{operations: "sssnnsnssn", expected: "a"},
},
}
tc.run(c)
}
// root
// / \
// a b
func (s *IterSuite) TestTwoFiles(c *C) {
tc := testsCollection{
tree: "(a<> b<>)",
tests: []test{
{operations: "nnn", expected: "a b"},
{operations: "nns", expected: "a b"},
{operations: "nsn", expected: "a b"},
{operations: "nss", expected: "a b"},
{operations: "snn", expected: "a b"},
{operations: "sns", expected: "a b"},
{operations: "ssn", expected: "a b"},
{operations: "sss", expected: "a b"},
},
}
tc.run(c)
}
// root
// |
// a
// |
// b
func (s *IterSuite) TestDirWithFile(c *C) {
tc := testsCollection{
tree: "(a(b<>))",
tests: []test{
{operations: "nnn", expected: "a"},
{operations: "nns", expected: "a"},
{operations: "nsn", expected: "a a/b"},
{operations: "nss", expected: "a a/b"},
{operations: "snn", expected: "a"},
{operations: "sns", expected: "a"},
{operations: "ssn", expected: "a a/b"},
{operations: "sss", expected: "a a/b"},
},
}
tc.run(c)
}
// root
// /|\
// c a b
func (s *IterSuite) TestThreeSiblings(c *C) {
tc := testsCollection{
tree: "(c<> a<> b<>)",
tests: []test{
{operations: "nnnn", expected: "a b c"},
{operations: "nnns", expected: "a b c"},
{operations: "nnsn", expected: "a b c"},
{operations: "nnss", expected: "a b c"},
{operations: "nsnn", expected: "a b c"},
{operations: "nsns", expected: "a b c"},
{operations: "nssn", expected: "a b c"},
{operations: "nsss", expected: "a b c"},
{operations: "snnn", expected: "a b c"},
{operations: "snns", expected: "a b c"},
{operations: "snsn", expected: "a b c"},
{operations: "snss", expected: "a b c"},
{operations: "ssnn", expected: "a b c"},
{operations: "ssns", expected: "a b c"},
{operations: "sssn", expected: "a b c"},
{operations: "ssss", expected: "a b c"},
},
}
tc.run(c)
}
// root
// |
// b
// |
// c
// |
// a
func (s *IterSuite) TestThreeVertical(c *C) {
tc := testsCollection{
tree: "(b(c(a())))",
tests: []test{
{operations: "nnnn", expected: "b"},
{operations: "nnns", expected: "b"},
{operations: "nnsn", expected: "b"},
{operations: "nnss", expected: "b"},
{operations: "nsnn", expected: "b b/c"},
{operations: "nsns", expected: "b b/c"},
{operations: "nssn", expected: "b b/c b/c/a"},
{operations: "nsss", expected: "b b/c b/c/a"},
{operations: "snnn", expected: "b"},
{operations: "snns", expected: "b"},
{operations: "snsn", expected: "b"},
{operations: "snss", expected: "b"},
{operations: "ssnn", expected: "b b/c"},
{operations: "ssns", expected: "b b/c"},
{operations: "sssn", expected: "b b/c b/c/a"},
{operations: "ssss", expected: "b b/c b/c/a"},
},
}
tc.run(c)
}
// root
// / \
// c a
// |
// b
func (s *IterSuite) TestThreeMix1(c *C) {
tc := testsCollection{
tree: "(c(b<>) a<>)",
tests: []test{
{operations: "nnnn", expected: "a c"},
{operations: "nnns", expected: "a c"},
{operations: "nnsn", expected: "a c c/b"},
{operations: "nnss", expected: "a c c/b"},
{operations: "nsnn", expected: "a c"},
{operations: "nsns", expected: "a c"},
{operations: "nssn", expected: "a c c/b"},
{operations: "nsss", expected: "a c c/b"},
{operations: "snnn", expected: "a c"},
{operations: "snns", expected: "a c"},
{operations: "snsn", expected: "a c c/b"},
{operations: "snss", expected: "a c c/b"},
{operations: "ssnn", expected: "a c"},
{operations: "ssns", expected: "a c"},
{operations: "sssn", expected: "a c c/b"},
{operations: "ssss", expected: "a c c/b"},
},
}
tc.run(c)
}
// root
// / \
// b a
// |
// c
func (s *IterSuite) TestThreeMix2(c *C) {
tc := testsCollection{
tree: "(b() a(c<>))",
tests: []test{
{operations: "nnnn", expected: "a b"},
{operations: "nnns", expected: "a b"},
{operations: "nnsn", expected: "a b"},
{operations: "nnss", expected: "a b"},
{operations: "nsnn", expected: "a a/c b"},
{operations: "nsns", expected: "a a/c b"},
{operations: "nssn", expected: "a a/c b"},
{operations: "nsss", expected: "a a/c b"},
{operations: "snnn", expected: "a b"},
{operations: "snns", expected: "a b"},
{operations: "snsn", expected: "a b"},
{operations: "snss", expected: "a b"},
{operations: "ssnn", expected: "a a/c b"},
{operations: "ssns", expected: "a a/c b"},
{operations: "sssn", expected: "a a/c b"},
{operations: "ssss", expected: "a a/c b"},
},
}
tc.run(c)
}
// root
// / | \
// / | ----
// f d h --------
// /\ / \ |
// e a j b/ g
// | / \ |
// l n k icm
// |
// o
// |
// p/
func (s *IterSuite) TestCrazy(c *C) {
tc := testsCollection{
tree: "(f(e(l<>) a(n(o(p())) k<>)) d<> h(j(i<> c<> m<>) b() g<>))",
tests: []test{
{operations: "nnnnn", expected: "d f h"},
{operations: "nnnns", expected: "d f h"},
{operations: "nnnsn", expected: "d f h h/b h/g"},
{operations: "nnnss", expected: "d f h h/b h/g"},
{operations: "nnsnn", expected: "d f f/a f/e h"},
{operations: "nnsns", expected: "d f f/a f/e f/e/l"},
{operations: "nnssn", expected: "d f f/a f/a/k f/a/n"},
{operations: "nnsss", expected: "d f f/a f/a/k f/a/n"},
{operations: "nsnnn", expected: "d f h"},
{operations: "nsnns", expected: "d f h"},
{operations: "nsnsn", expected: "d f h h/b h/g"},
{operations: "nsnss", expected: "d f h h/b h/g"},
{operations: "nssnn", expected: "d f f/a f/e h"},
},
}
tc.run(c)
}
// .
// |
// a
// |
// b
// / \
// z h
// / \
// d e
// |
// f
func (s *IterSuite) TestNewIterFromPath(c *C) {
tree, err := fsnoder.New("(a(b(z(d<> e(f<>)) h<>)))")
c.Assert(err, IsNil)
z := find(c, tree, "z")
iter, err := merkletrie.NewIterFromPath(z)
c.Assert(err, IsNil)
n, err := iter.Next()
c.Assert(err, IsNil)
c.Assert(n.String(), Equals, "a/b/z/d")
n, err = iter.Next()
c.Assert(err, IsNil)
c.Assert(n.String(), Equals, "a/b/z/e")
n, err = iter.Step()
c.Assert(err, IsNil)
c.Assert(n.String(), Equals, "a/b/z/e/f")
_, err = iter.Step()
c.Assert(err, Equals, io.EOF)
}
func find(c *C, tree noder.Noder, name string) noder.Path {
iter, err := merkletrie.NewIter(tree)
c.Assert(err, IsNil)
for {
current, err := iter.Step()
if err != io.EOF {
c.Assert(err, IsNil)
} else {
c.Fatalf("node %s not found in tree %s", name, tree)
}
if current.Name() == name {
return current
}
}
}
type errorNoder struct{ noder.Noder }
func (e *errorNoder) Children() ([]noder.Noder, error) {
return nil, fmt.Errorf("mock error")
}
func (s *IterSuite) TestNewIterNil(c *C) {
i, err := merkletrie.NewIter(nil)
c.Assert(err, IsNil)
_, err = i.Next()
c.Assert(err, Equals, io.EOF)
}
func (s *IterSuite) TestNewIterFailsOnChildrenErrors(c *C) {
_, err := merkletrie.NewIter(&errorNoder{})
c.Assert(err, ErrorMatches, "mock error")
}
go-git-5.13.2/utils/merkletrie/noder/ 0000775 0000000 0000000 00000000000 14744245500 0017407 5 ustar 00root root 0000000 0000000 go-git-5.13.2/utils/merkletrie/noder/noder.go 0000664 0000000 0000000 00000004141 14744245500 0021045 0 ustar 00root root 0000000 0000000 // Package noder provide an interface for defining nodes in a
// merkletrie, their hashes and their paths (a noders and its
// ancestors).
//
// The hasher interface is easy to implement naively by elements that
// already have a hash, like git blobs and trees. More sophisticated
// implementations can implement the Equal function in exotic ways
// though: for instance, comparing the modification time of directories
// in a filesystem.
package noder
import "fmt"
// Hasher interface is implemented by types that can tell you
// their hash.
type Hasher interface {
Hash() []byte
}
// Equal functions take two hashers and return if they are equal.
//
// These functions are expected to be faster than reflect.Equal or
// reflect.DeepEqual because they can compare just the hash of the
// objects, instead of their contents, so they are expected to be O(1).
type Equal func(a, b Hasher) bool
// The Noder interface is implemented by the elements of a Merkle Trie.
//
// There are two types of elements in a Merkle Trie:
//
// - file-like nodes: they cannot have children.
//
// - directory-like nodes: they can have 0 or more children and their
// hash is calculated by combining their children hashes.
type Noder interface {
Hasher
fmt.Stringer // for testing purposes
// Name returns the name of an element (relative, not its full
// path).
Name() string
// IsDir returns true if the element is a directory-like node or
// false if it is a file-like node.
IsDir() bool
// Children returns the children of the element. Note that empty
// directory-like noders and file-like noders will both return
// NoChildren.
Children() ([]Noder, error)
// NumChildren returns the number of children this element has.
//
// This method is an optimization: the number of children is easily
// calculated as the length of the value returned by the Children
// method (above); yet, some implementations will be able to
// implement NumChildren in O(1) while Children is usually more
// complex.
NumChildren() (int, error)
Skip() bool
}
// NoChildren represents the children of a noder without children.
var NoChildren = []Noder{}
go-git-5.13.2/utils/merkletrie/noder/noder_test.go 0000664 0000000 0000000 00000003731 14744245500 0022110 0 ustar 00root root 0000000 0000000 package noder
import (
"testing"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type NoderSuite struct{}
var _ = Suite(&NoderSuite{})
type noderMock struct {
name string
hash []byte
isDir bool
children []Noder
}
func (n noderMock) String() string { return n.Name() }
func (n noderMock) Hash() []byte { return n.hash }
func (n noderMock) Name() string { return n.name }
func (n noderMock) IsDir() bool { return n.isDir }
func (n noderMock) Children() ([]Noder, error) { return n.children, nil }
func (n noderMock) NumChildren() (int, error) { return len(n.children), nil }
func (n noderMock) Skip() bool { return false }
// Returns a sequence with the noders 3, 2, and 1 from the
// following diagram:
//
// 3
// |
// 2
// |
// 1
// / \
// c1 c2
//
// This is also the path of "1".
func nodersFixture() []Noder {
n1 := &noderMock{
name: "1",
hash: []byte{0x00, 0x01, 0x02},
isDir: true,
children: childrenFixture(),
}
n2 := &noderMock{name: "2"}
n3 := &noderMock{name: "3"}
return []Noder{n3, n2, n1}
}
// Returns a collection of 2 noders: c1, c2.
func childrenFixture() []Noder {
c1 := &noderMock{name: "c1"}
c2 := &noderMock{name: "c2"}
return []Noder{c1, c2}
}
// returns nodersFixture as the path of "1".
func pathFixture() Path {
return Path(nodersFixture())
}
func (s *NoderSuite) TestString(c *C) {
c.Assert(pathFixture().String(), Equals, "3/2/1")
}
func (s *NoderSuite) TestLast(c *C) {
c.Assert(pathFixture().Last().Name(), Equals, "1")
}
func (s *NoderSuite) TestPathImplementsNoder(c *C) {
p := pathFixture()
c.Assert(p.Name(), Equals, "1")
c.Assert(p.Hash(), DeepEquals, []byte{0x00, 0x01, 0x02})
c.Assert(p.IsDir(), Equals, true)
children, err := p.Children()
c.Assert(err, IsNil)
c.Assert(children, DeepEquals, childrenFixture())
numChildren, err := p.NumChildren()
c.Assert(err, IsNil)
c.Assert(numChildren, Equals, 2)
}
go-git-5.13.2/utils/merkletrie/noder/path.go 0000664 0000000 0000000 00000004133 14744245500 0020673 0 ustar 00root root 0000000 0000000 package noder
import (
"bytes"
"strings"
)
// Path values represent a noder and its ancestors. The root goes first
// and the actual final noder the path is referring to will be the last.
//
// A path implements the Noder interface, redirecting all the interface
// calls to its final noder.
//
// Paths build from an empty Noder slice are not valid paths and should
// not be used.
type Path []Noder
func (p Path) Skip() bool {
if len(p) > 0 {
return p.Last().Skip()
}
return false
}
// String returns the full path of the final noder as a string, using
// "/" as the separator.
func (p Path) String() string {
var buf bytes.Buffer
sep := ""
for _, e := range p {
_, _ = buf.WriteString(sep)
sep = "/"
_, _ = buf.WriteString(e.Name())
}
return buf.String()
}
// Last returns the final noder in the path.
func (p Path) Last() Noder {
return p[len(p)-1]
}
// Hash returns the hash of the final noder of the path.
func (p Path) Hash() []byte {
return p.Last().Hash()
}
// Name returns the name of the final noder of the path.
func (p Path) Name() string {
return p.Last().Name()
}
// IsDir returns if the final noder of the path is a directory-like
// noder.
func (p Path) IsDir() bool {
return p.Last().IsDir()
}
// Children returns the children of the final noder in the path.
func (p Path) Children() ([]Noder, error) {
return p.Last().Children()
}
// NumChildren returns the number of children the final noder of the
// path has.
func (p Path) NumChildren() (int, error) {
return p.Last().NumChildren()
}
// Compare returns -1, 0 or 1 if the path p is smaller, equal or bigger
// than other, in "directory order"; for example:
//
// "a" < "b"
// "a/b/c/d/z" < "b"
// "a/b/a" > "a/b"
func (p Path) Compare(other Path) int {
i := 0
for {
switch {
case len(other) == len(p) && i == len(p):
return 0
case i == len(other):
return 1
case i == len(p):
return -1
default:
// We do *not* normalize Unicode here. CGit doesn't.
// https://github.com/src-d/go-git/issues/1057
cmp := strings.Compare(p[i].Name(), other[i].Name())
if cmp != 0 {
return cmp
}
}
i++
}
}
go-git-5.13.2/utils/merkletrie/noder/path_test.go 0000664 0000000 0000000 00000007216 14744245500 0021737 0 ustar 00root root 0000000 0000000 package noder
import (
"golang.org/x/text/unicode/norm"
. "gopkg.in/check.v1"
)
type PathSuite struct{}
var _ = Suite(&PathSuite{})
func (s *PathSuite) TestShortFile(c *C) {
f := &noderMock{
name: "1",
isDir: false,
}
p := Path([]Noder{f})
c.Assert(p.String(), Equals, "1")
}
func (s *PathSuite) TestShortDir(c *C) {
d := &noderMock{
name: "1",
isDir: true,
children: NoChildren,
}
p := Path([]Noder{d})
c.Assert(p.String(), Equals, "1")
}
func (s *PathSuite) TestLongFile(c *C) {
n3 := &noderMock{
name: "3",
isDir: false,
}
n2 := &noderMock{
name: "2",
isDir: true,
children: []Noder{n3},
}
n1 := &noderMock{
name: "1",
isDir: true,
children: []Noder{n2},
}
p := Path([]Noder{n1, n2, n3})
c.Assert(p.String(), Equals, "1/2/3")
}
func (s *PathSuite) TestLongDir(c *C) {
n3 := &noderMock{
name: "3",
isDir: true,
children: NoChildren,
}
n2 := &noderMock{
name: "2",
isDir: true,
children: []Noder{n3},
}
n1 := &noderMock{
name: "1",
isDir: true,
children: []Noder{n2},
}
p := Path([]Noder{n1, n2, n3})
c.Assert(p.String(), Equals, "1/2/3")
}
func (s *PathSuite) TestCompareDepth1(c *C) {
p1 := Path([]Noder{&noderMock{name: "a"}})
p2 := Path([]Noder{&noderMock{name: "b"}})
c.Assert(p1.Compare(p2), Equals, -1)
c.Assert(p2.Compare(p1), Equals, 1)
p1 = Path([]Noder{&noderMock{name: "a"}})
p2 = Path([]Noder{&noderMock{name: "a"}})
c.Assert(p1.Compare(p2), Equals, 0)
c.Assert(p2.Compare(p1), Equals, 0)
p1 = Path([]Noder{&noderMock{name: "a.go"}})
p2 = Path([]Noder{&noderMock{name: "a"}})
c.Assert(p1.Compare(p2), Equals, 1)
c.Assert(p2.Compare(p1), Equals, -1)
}
func (s *PathSuite) TestCompareDepth2(c *C) {
p1 := Path([]Noder{
&noderMock{name: "a"},
&noderMock{name: "b"},
})
p2 := Path([]Noder{
&noderMock{name: "b"},
&noderMock{name: "a"},
})
c.Assert(p1.Compare(p2), Equals, -1)
c.Assert(p2.Compare(p1), Equals, 1)
p1 = Path([]Noder{
&noderMock{name: "a"},
&noderMock{name: "b"},
})
p2 = Path([]Noder{
&noderMock{name: "a"},
&noderMock{name: "b"},
})
c.Assert(p1.Compare(p2), Equals, 0)
c.Assert(p2.Compare(p1), Equals, 0)
p1 = Path([]Noder{
&noderMock{name: "a"},
&noderMock{name: "b"},
})
p2 = Path([]Noder{
&noderMock{name: "a"},
&noderMock{name: "a"},
})
c.Assert(p1.Compare(p2), Equals, 1)
c.Assert(p2.Compare(p1), Equals, -1)
}
func (s *PathSuite) TestCompareMixedDepths(c *C) {
p1 := Path([]Noder{
&noderMock{name: "a"},
&noderMock{name: "b"},
})
p2 := Path([]Noder{&noderMock{name: "b"}})
c.Assert(p1.Compare(p2), Equals, -1)
c.Assert(p2.Compare(p1), Equals, 1)
p1 = Path([]Noder{
&noderMock{name: "b"},
&noderMock{name: "b"},
})
p2 = Path([]Noder{&noderMock{name: "b"}})
c.Assert(p1.Compare(p2), Equals, 1)
c.Assert(p2.Compare(p1), Equals, -1)
p1 = Path([]Noder{&noderMock{name: "a.go"}})
p2 = Path([]Noder{
&noderMock{name: "a"},
&noderMock{name: "a.go"},
})
c.Assert(p1.Compare(p2), Equals, 1)
c.Assert(p2.Compare(p1), Equals, -1)
p1 = Path([]Noder{&noderMock{name: "b.go"}})
p2 = Path([]Noder{
&noderMock{name: "a"},
&noderMock{name: "a.go"},
})
c.Assert(p1.Compare(p2), Equals, 1)
c.Assert(p2.Compare(p1), Equals, -1)
}
func (s *PathSuite) TestCompareNormalization(c *C) {
p1 := Path([]Noder{&noderMock{name: norm.NFKC.String("페")}})
p2 := Path([]Noder{&noderMock{name: norm.NFKD.String("페")}})
c.Assert(p1.Compare(p2), Equals, 1)
c.Assert(p2.Compare(p1), Equals, -1)
p1 = Path([]Noder{&noderMock{name: "TestAppWithUnicodéPath"}})
p2 = Path([]Noder{&noderMock{name: "TestAppWithUnicodéPath"}})
c.Assert(p1.Compare(p2), Equals, -1)
c.Assert(p2.Compare(p1), Equals, 1)
}
go-git-5.13.2/utils/revlist2humantest.bash 0000775 0000000 0000000 00000001711 14744245500 0020502 0 ustar 00root root 0000000 0000000 #!/bin/bash
# you can run this over a whole repo with:
#
# for file in `find . -type f | sed 's/^\.\///' | egrep -v '^\.git\/.*$'` ; do revlist2humantest.bash $file ; done > /tmp/output
#
# be careful with files with spaces, though
set -e
repo=`git remote show origin | grep Fetch | cut -d' ' -f5`
branch=`git branch | egrep '^\* .*' | cut -d' ' -f2`
if [ "$#" -eq 1 ] ; then
commit=`git log | head -1 | cut -d' ' -f2`
path=$1
elif [ "$#" -eq 2 ] ; then
commit=$1
path=$2
else
echo "bad number of parameters" > /dev/stderr
echo > /dev/stderr
echo " try with: [commit] path" > /dev/stderr
exit
fi
hashes=`git rev-list --remove-empty --reverse $commit -- $path`
# some remotes have the .git, other don't,
# repoDot makes sure all have
repoDot="${repo%.git}.git"
echo -e "\t&humanTest{\"${repoDot}\", \"${branch}\", \"${commit}\", \"${path}\", []string{"
for i in $hashes ; do
echo -e "\t\t\"${i}\","
done
echo -e "\t}},"
go-git-5.13.2/utils/sync/ 0000775 0000000 0000000 00000000000 14744245500 0015111 5 ustar 00root root 0000000 0000000 go-git-5.13.2/utils/sync/bufio.go 0000664 0000000 0000000 00000001200 14744245500 0016535 0 ustar 00root root 0000000 0000000 package sync
import (
"bufio"
"io"
"sync"
)
var bufioReader = sync.Pool{
New: func() interface{} {
return bufio.NewReader(nil)
},
}
// GetBufioReader returns a *bufio.Reader that is managed by a sync.Pool.
// Returns a bufio.Reader that is reset with reader and ready for use.
//
// After use, the *bufio.Reader should be put back into the sync.Pool
// by calling PutBufioReader.
func GetBufioReader(reader io.Reader) *bufio.Reader {
r := bufioReader.Get().(*bufio.Reader)
r.Reset(reader)
return r
}
// PutBufioReader puts reader back into its sync.Pool.
func PutBufioReader(reader *bufio.Reader) {
bufioReader.Put(reader)
}
go-git-5.13.2/utils/sync/bufio_test.go 0000664 0000000 0000000 00000000663 14744245500 0017610 0 ustar 00root root 0000000 0000000 package sync
import (
"io"
"strings"
"testing"
)
func TestGetAndPutBufioReader(t *testing.T) {
wanted := "someinput"
r := GetBufioReader(strings.NewReader(wanted))
if r == nil {
t.Error("nil was not expected")
}
got, err := r.ReadString(0)
if err != nil && err != io.EOF {
t.Errorf("unexpected error reading string: %v", err)
}
if wanted != got {
t.Errorf("wanted %q got %q", wanted, got)
}
PutBufioReader(r)
}
go-git-5.13.2/utils/sync/bytes.go 0000664 0000000 0000000 00000002113 14744245500 0016563 0 ustar 00root root 0000000 0000000 package sync
import (
"bytes"
"sync"
)
var (
byteSlice = sync.Pool{
New: func() interface{} {
b := make([]byte, 16*1024)
return &b
},
}
bytesBuffer = sync.Pool{
New: func() interface{} {
return bytes.NewBuffer(nil)
},
}
)
// GetByteSlice returns a *[]byte that is managed by a sync.Pool.
// The initial slice length will be 16384 (16kb).
//
// After use, the *[]byte should be put back into the sync.Pool
// by calling PutByteSlice.
func GetByteSlice() *[]byte {
buf := byteSlice.Get().(*[]byte)
return buf
}
// PutByteSlice puts buf back into its sync.Pool.
func PutByteSlice(buf *[]byte) {
byteSlice.Put(buf)
}
// GetBytesBuffer returns a *bytes.Buffer that is managed by a sync.Pool.
// Returns a buffer that is reset and ready for use.
//
// After use, the *bytes.Buffer should be put back into the sync.Pool
// by calling PutBytesBuffer.
func GetBytesBuffer() *bytes.Buffer {
buf := bytesBuffer.Get().(*bytes.Buffer)
buf.Reset()
return buf
}
// PutBytesBuffer puts buf back into its sync.Pool.
func PutBytesBuffer(buf *bytes.Buffer) {
bytesBuffer.Put(buf)
}
go-git-5.13.2/utils/sync/bytes_test.go 0000664 0000000 0000000 00000001652 14744245500 0017631 0 ustar 00root root 0000000 0000000 package sync
import (
"testing"
)
func TestGetAndPutBytesBuffer(t *testing.T) {
buf := GetBytesBuffer()
if buf == nil {
t.Error("nil was not expected")
}
initialLen := buf.Len()
buf.Grow(initialLen * 2)
grownLen := buf.Len()
PutBytesBuffer(buf)
buf = GetBytesBuffer()
if buf.Len() != grownLen {
t.Error("bytes buffer was not reused")
}
buf2 := GetBytesBuffer()
if buf2.Len() != initialLen {
t.Errorf("new bytes buffer length: wanted %d got %d", initialLen, buf2.Len())
}
}
func TestGetAndPutByteSlice(t *testing.T) {
slice := GetByteSlice()
if slice == nil {
t.Error("nil was not expected")
}
wanted := 16 * 1024
got := len(*slice)
if wanted != got {
t.Errorf("byte slice length: wanted %d got %d", wanted, got)
}
newByteSlice := make([]byte, wanted*2)
PutByteSlice(&newByteSlice)
newSlice := GetByteSlice()
if len(*newSlice) != len(newByteSlice) {
t.Error("byte slice was not reused")
}
}
go-git-5.13.2/utils/sync/zlib.go 0000664 0000000 0000000 00000003235 14744245500 0016403 0 ustar 00root root 0000000 0000000 package sync
import (
"bytes"
"compress/zlib"
"io"
"sync"
)
var (
zlibInitBytes = []byte{0x78, 0x9c, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01}
zlibReader = sync.Pool{
New: func() interface{} {
r, _ := zlib.NewReader(bytes.NewReader(zlibInitBytes))
return ZLibReader{
Reader: r.(zlibReadCloser),
}
},
}
zlibWriter = sync.Pool{
New: func() interface{} {
return zlib.NewWriter(nil)
},
}
)
type zlibReadCloser interface {
io.ReadCloser
zlib.Resetter
}
type ZLibReader struct {
dict *[]byte
Reader zlibReadCloser
}
// GetZlibReader returns a ZLibReader that is managed by a sync.Pool.
// Returns a ZLibReader that is reset using a dictionary that is
// also managed by a sync.Pool.
//
// After use, the ZLibReader should be put back into the sync.Pool
// by calling PutZlibReader.
func GetZlibReader(r io.Reader) (ZLibReader, error) {
z := zlibReader.Get().(ZLibReader)
z.dict = GetByteSlice()
err := z.Reader.Reset(r, *z.dict)
return z, err
}
// PutZlibReader puts z back into its sync.Pool, first closing the reader.
// The Byte slice dictionary is also put back into its sync.Pool.
func PutZlibReader(z ZLibReader) {
z.Reader.Close()
PutByteSlice(z.dict)
zlibReader.Put(z)
}
// GetZlibWriter returns a *zlib.Writer that is managed by a sync.Pool.
// Returns a writer that is reset with w and ready for use.
//
// After use, the *zlib.Writer should be put back into the sync.Pool
// by calling PutZlibWriter.
func GetZlibWriter(w io.Writer) *zlib.Writer {
z := zlibWriter.Get().(*zlib.Writer)
z.Reset(w)
return z
}
// PutZlibWriter puts w back into its sync.Pool.
func PutZlibWriter(w *zlib.Writer) {
zlibWriter.Put(w)
}
go-git-5.13.2/utils/sync/zlib_test.go 0000664 0000000 0000000 00000002434 14744245500 0017442 0 ustar 00root root 0000000 0000000 package sync
import (
"bytes"
"compress/zlib"
"io"
"testing"
)
func TestGetAndPutZlibReader(t *testing.T) {
_, err := GetZlibReader(bytes.NewReader(zlibInitBytes))
if err != nil {
t.Errorf("unexpected error: %v", err)
}
dict := &[]byte{}
reader := FakeZLibReader{}
PutZlibReader(ZLibReader{dict: dict, Reader: &reader})
if !reader.wasClosed {
t.Errorf("reader was not closed")
}
z2, err := GetZlibReader(bytes.NewReader(zlibInitBytes))
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if dict != z2.dict {
t.Errorf("zlib dictionary was not reused")
}
if &reader != z2.Reader {
t.Errorf("zlib reader was not reused")
}
if !reader.wasReset {
t.Errorf("reader was not reset")
}
}
func TestGetAndPutZlibWriter(t *testing.T) {
w := GetZlibWriter(nil)
if w == nil {
t.Errorf("nil was not expected")
}
newW := zlib.NewWriter(nil)
PutZlibWriter(newW)
w2 := GetZlibWriter(nil)
if w2 != newW {
t.Errorf("zlib writer was not reused")
}
}
type FakeZLibReader struct {
wasClosed bool
wasReset bool
}
func (f *FakeZLibReader) Reset(r io.Reader, dict []byte) error {
f.wasReset = true
return nil
}
func (f *FakeZLibReader) Read(p []byte) (n int, err error) {
return 0, nil
}
func (f *FakeZLibReader) Close() error {
f.wasClosed = true
return nil
}
go-git-5.13.2/utils/trace/ 0000775 0000000 0000000 00000000000 14744245500 0015233 5 ustar 00root root 0000000 0000000 go-git-5.13.2/utils/trace/trace.go 0000664 0000000 0000000 00000002166 14744245500 0016665 0 ustar 00root root 0000000 0000000 package trace
import (
"fmt"
"log"
"os"
"sync/atomic"
)
var (
// logger is the logger to use for tracing.
logger = newLogger()
// current is the targets that are enabled for tracing.
current atomic.Int32
)
func newLogger() *log.Logger {
return log.New(os.Stderr, "", log.Ltime|log.Lmicroseconds|log.Lshortfile)
}
// Target is a tracing target.
type Target int32
const (
// General traces general operations.
General Target = 1 << iota
// Packet traces git packets.
Packet
)
// SetTarget sets the tracing targets.
func SetTarget(target Target) {
current.Store(int32(target))
}
// SetLogger sets the logger to use for tracing.
func SetLogger(l *log.Logger) {
logger = l
}
// Print prints the given message only if the target is enabled.
func (t Target) Print(args ...interface{}) {
if int32(t)¤t.Load() != 0 {
logger.Output(2, fmt.Sprint(args...)) // nolint: errcheck
}
}
// Printf prints the given message only if the target is enabled.
func (t Target) Printf(format string, args ...interface{}) {
if int32(t)¤t.Load() != 0 {
logger.Output(2, fmt.Sprintf(format, args...)) // nolint: errcheck
}
}
go-git-5.13.2/utils/trace/trace_test.go 0000664 0000000 0000000 00000003107 14744245500 0017720 0 ustar 00root root 0000000 0000000 package trace
import (
"bytes"
"io"
"log"
"testing"
)
func TestMain(m *testing.M) {
defer SetLogger(newLogger())
if code := m.Run(); code != 0 {
panic(code)
}
}
func setUpTest(t testing.TB, buf *bytes.Buffer) {
t.Cleanup(func() {
if buf != nil {
buf.Reset()
}
SetTarget(0)
})
w := io.Discard
if buf != nil {
w = buf
}
SetLogger(log.New(w, "", 0))
}
func TestEmpty(t *testing.T) {
var buf bytes.Buffer
setUpTest(t, &buf)
General.Print("test")
if buf.String() != "" {
t.Error("expected empty string")
}
}
func TestOneTarget(t *testing.T) {
var buf bytes.Buffer
setUpTest(t, &buf)
SetTarget(General)
General.Print("test")
if buf.String() != "test\n" {
t.Error("expected 'test'")
}
}
func TestMultipleTargets(t *testing.T) {
var buf bytes.Buffer
setUpTest(t, &buf)
SetTarget(General | Packet)
General.Print("a")
Packet.Print("b")
if buf.String() != "a\nb\n" {
t.Error("expected 'a\nb\n'")
}
}
func TestPrintf(t *testing.T) {
var buf bytes.Buffer
setUpTest(t, &buf)
SetTarget(General)
General.Printf("a %d", 1)
if buf.String() != "a 1\n" {
t.Error("expected 'a 1\n'")
}
}
func TestDisabledMultipleTargets(t *testing.T) {
var buf bytes.Buffer
setUpTest(t, &buf)
SetTarget(General)
General.Print("a")
Packet.Print("b")
if buf.String() != "a\n" {
t.Error("expected 'a\n'")
}
}
func BenchmarkDisabledTarget(b *testing.B) {
setUpTest(b, nil)
for i := 0; i < b.N; i++ {
General.Print("test")
}
}
func BenchmarkEnabledTarget(b *testing.B) {
setUpTest(b, nil)
SetTarget(General)
for i := 0; i < b.N; i++ {
General.Print("test")
}
}
go-git-5.13.2/worktree.go 0000664 0000000 0000000 00000065240 14744245500 0015175 0 ustar 00root root 0000000 0000000 package git
import (
"context"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"runtime"
"strings"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/util"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/format/gitignore"
"github.com/go-git/go-git/v5/plumbing/format/index"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-git/v5/utils/merkletrie"
"github.com/go-git/go-git/v5/utils/sync"
)
var (
ErrWorktreeNotClean = errors.New("worktree is not clean")
ErrSubmoduleNotFound = errors.New("submodule not found")
ErrUnstagedChanges = errors.New("worktree contains unstaged changes")
ErrGitModulesSymlink = errors.New(gitmodulesFile + " is a symlink")
ErrNonFastForwardUpdate = errors.New("non-fast-forward update")
ErrRestoreWorktreeOnlyNotSupported = errors.New("worktree only is not supported")
)
// Worktree represents a git worktree.
type Worktree struct {
// Filesystem underlying filesystem.
Filesystem billy.Filesystem
// External excludes not found in the repository .gitignore
Excludes []gitignore.Pattern
r *Repository
}
// Pull incorporates changes from a remote repository into the current branch.
// Returns nil if the operation is successful, NoErrAlreadyUpToDate if there are
// no changes to be fetched, or an error.
//
// Pull only supports merges where the can be resolved as a fast-forward.
func (w *Worktree) Pull(o *PullOptions) error {
return w.PullContext(context.Background(), o)
}
// PullContext incorporates changes from a remote repository into the current
// branch. Returns nil if the operation is successful, NoErrAlreadyUpToDate if
// there are no changes to be fetched, or an error.
//
// Pull only supports merges where the can be resolved as a fast-forward.
//
// The provided Context must be non-nil. If the context expires before the
// operation is complete, an error is returned. The context only affects the
// transport operations.
func (w *Worktree) PullContext(ctx context.Context, o *PullOptions) error {
if err := o.Validate(); err != nil {
return err
}
remote, err := w.r.Remote(o.RemoteName)
if err != nil {
return err
}
fetchHead, err := remote.fetch(ctx, &FetchOptions{
RemoteName: o.RemoteName,
RemoteURL: o.RemoteURL,
Depth: o.Depth,
Auth: o.Auth,
Progress: o.Progress,
Force: o.Force,
InsecureSkipTLS: o.InsecureSkipTLS,
CABundle: o.CABundle,
ProxyOptions: o.ProxyOptions,
})
updated := true
if err == NoErrAlreadyUpToDate {
updated = false
} else if err != nil {
return err
}
ref, err := storer.ResolveReference(fetchHead, o.ReferenceName)
if err != nil {
return err
}
head, err := w.r.Head()
if err == nil {
// if we don't have a shallows list, just ignore it
shallowList, _ := w.r.Storer.Shallow()
var earliestShallow *plumbing.Hash
if len(shallowList) > 0 {
earliestShallow = &shallowList[0]
}
headAheadOfRef, err := isFastForward(w.r.Storer, ref.Hash(), head.Hash(), earliestShallow)
if err != nil {
return err
}
if !updated && headAheadOfRef {
return NoErrAlreadyUpToDate
}
ff, err := isFastForward(w.r.Storer, head.Hash(), ref.Hash(), earliestShallow)
if err != nil {
return err
}
if !ff {
return ErrNonFastForwardUpdate
}
}
if err != nil && err != plumbing.ErrReferenceNotFound {
return err
}
if err := w.updateHEAD(ref.Hash()); err != nil {
return err
}
if err := w.Reset(&ResetOptions{
Mode: MergeReset,
Commit: ref.Hash(),
}); err != nil {
return err
}
if o.RecurseSubmodules != NoRecurseSubmodules {
return w.updateSubmodules(ctx, &SubmoduleUpdateOptions{
RecurseSubmodules: o.RecurseSubmodules,
Auth: o.Auth,
})
}
return nil
}
func (w *Worktree) updateSubmodules(ctx context.Context, o *SubmoduleUpdateOptions) error {
s, err := w.Submodules()
if err != nil {
return err
}
o.Init = true
return s.UpdateContext(ctx, o)
}
// Checkout switch branches or restore working tree files.
func (w *Worktree) Checkout(opts *CheckoutOptions) error {
if err := opts.Validate(); err != nil {
return err
}
if opts.Create {
if err := w.createBranch(opts); err != nil {
return err
}
}
c, err := w.getCommitFromCheckoutOptions(opts)
if err != nil {
return err
}
ro := &ResetOptions{Commit: c, Mode: MergeReset}
if opts.Force {
ro.Mode = HardReset
} else if opts.Keep {
ro.Mode = SoftReset
}
if !opts.Hash.IsZero() && !opts.Create {
err = w.setHEADToCommit(opts.Hash)
} else {
err = w.setHEADToBranch(opts.Branch, c)
}
if err != nil {
return err
}
if len(opts.SparseCheckoutDirectories) > 0 {
return w.ResetSparsely(ro, opts.SparseCheckoutDirectories)
}
return w.Reset(ro)
}
func (w *Worktree) createBranch(opts *CheckoutOptions) error {
if err := opts.Branch.Validate(); err != nil {
return err
}
_, err := w.r.Storer.Reference(opts.Branch)
if err == nil {
return fmt.Errorf("a branch named %q already exists", opts.Branch)
}
if err != plumbing.ErrReferenceNotFound {
return err
}
if opts.Hash.IsZero() {
ref, err := w.r.Head()
if err != nil {
return err
}
opts.Hash = ref.Hash()
}
return w.r.Storer.SetReference(
plumbing.NewHashReference(opts.Branch, opts.Hash),
)
}
func (w *Worktree) getCommitFromCheckoutOptions(opts *CheckoutOptions) (plumbing.Hash, error) {
hash := opts.Hash
if hash.IsZero() {
b, err := w.r.Reference(opts.Branch, true)
if err != nil {
return plumbing.ZeroHash, err
}
hash = b.Hash()
}
o, err := w.r.Object(plumbing.AnyObject, hash)
if err != nil {
return plumbing.ZeroHash, err
}
switch o := o.(type) {
case *object.Tag:
if o.TargetType != plumbing.CommitObject {
return plumbing.ZeroHash, fmt.Errorf("%w: tag target %q", object.ErrUnsupportedObject, o.TargetType)
}
return o.Target, nil
case *object.Commit:
return o.Hash, nil
}
return plumbing.ZeroHash, fmt.Errorf("%w: %q", object.ErrUnsupportedObject, o.Type())
}
func (w *Worktree) setHEADToCommit(commit plumbing.Hash) error {
head := plumbing.NewHashReference(plumbing.HEAD, commit)
return w.r.Storer.SetReference(head)
}
func (w *Worktree) setHEADToBranch(branch plumbing.ReferenceName, commit plumbing.Hash) error {
target, err := w.r.Storer.Reference(branch)
if err != nil {
return err
}
var head *plumbing.Reference
if target.Name().IsBranch() {
head = plumbing.NewSymbolicReference(plumbing.HEAD, target.Name())
} else {
head = plumbing.NewHashReference(plumbing.HEAD, commit)
}
return w.r.Storer.SetReference(head)
}
func (w *Worktree) ResetSparsely(opts *ResetOptions, dirs []string) error {
if err := opts.Validate(w.r); err != nil {
return err
}
if opts.Mode == MergeReset {
unstaged, err := w.containsUnstagedChanges()
if err != nil {
return err
}
if unstaged {
return ErrUnstagedChanges
}
}
if err := w.setHEADCommit(opts.Commit); err != nil {
return err
}
if opts.Mode == SoftReset {
return nil
}
t, err := w.r.getTreeFromCommitHash(opts.Commit)
if err != nil {
return err
}
if opts.Mode == MixedReset || opts.Mode == MergeReset || opts.Mode == HardReset {
if err := w.resetIndex(t, dirs, opts.Files); err != nil {
return err
}
}
if opts.Mode == MergeReset || opts.Mode == HardReset {
if err := w.resetWorktree(t, opts.Files); err != nil {
return err
}
}
return nil
}
// Restore restores specified files in the working tree or stage with contents from
// a restore source. If a path is tracked but does not exist in the restore,
// source, it will be removed to match the source.
//
// If Staged and Worktree are true, then the restore source will be the index.
// If only Staged is true, then the restore source will be HEAD.
// If only Worktree is true or neither Staged nor Worktree are true, will
// result in ErrRestoreWorktreeOnlyNotSupported because restoring the working
// tree while leaving the stage untouched is not currently supported.
//
// Restore with no files specified will return ErrNoRestorePaths.
func (w *Worktree) Restore(o *RestoreOptions) error {
if err := o.Validate(); err != nil {
return err
}
if o.Staged {
opts := &ResetOptions{
Files: o.Files,
}
if o.Worktree {
// If we are doing both Worktree and Staging then it is a hard reset
opts.Mode = HardReset
} else {
// If we are doing just staging then it is a mixed reset
opts.Mode = MixedReset
}
return w.Reset(opts)
}
return ErrRestoreWorktreeOnlyNotSupported
}
// Reset the worktree to a specified state.
func (w *Worktree) Reset(opts *ResetOptions) error {
return w.ResetSparsely(opts, nil)
}
func (w *Worktree) resetIndex(t *object.Tree, dirs []string, files []string) error {
idx, err := w.r.Storer.Index()
if err != nil {
return err
}
b := newIndexBuilder(idx)
changes, err := w.diffTreeWithStaging(t, true)
if err != nil {
return err
}
for _, ch := range changes {
a, err := ch.Action()
if err != nil {
return err
}
var name string
var e *object.TreeEntry
switch a {
case merkletrie.Modify, merkletrie.Insert:
name = ch.To.String()
e, err = t.FindEntry(name)
if err != nil {
return err
}
case merkletrie.Delete:
name = ch.From.String()
}
if len(files) > 0 {
contains := inFiles(files, name)
if !contains {
continue
}
}
b.Remove(name)
if e == nil {
continue
}
b.Add(&index.Entry{
Name: name,
Hash: e.Hash,
Mode: e.Mode,
})
}
b.Write(idx)
if len(dirs) > 0 {
idx.SkipUnless(dirs)
}
return w.r.Storer.SetIndex(idx)
}
func inFiles(files []string, v string) bool {
v = filepath.Clean(v)
for _, s := range files {
if filepath.Clean(s) == v {
return true
}
}
return false
}
func (w *Worktree) resetWorktree(t *object.Tree, files []string) error {
changes, err := w.diffStagingWithWorktree(true, false)
if err != nil {
return err
}
idx, err := w.r.Storer.Index()
if err != nil {
return err
}
b := newIndexBuilder(idx)
for _, ch := range changes {
if err := w.validChange(ch); err != nil {
return err
}
if len(files) > 0 {
file := ""
if ch.From != nil {
file = ch.From.String()
} else if ch.To != nil {
file = ch.To.String()
}
if file == "" {
continue
}
contains := inFiles(files, file)
if !contains {
continue
}
}
if err := w.checkoutChange(ch, t, b); err != nil {
return err
}
}
b.Write(idx)
return w.r.Storer.SetIndex(idx)
}
// worktreeDeny is a list of paths that are not allowed
// to be used when resetting the worktree.
var worktreeDeny = map[string]struct{}{
// .git
GitDirName: {},
// For other historical reasons, file names that do not conform to the 8.3
// format (up to eight characters for the basename, three for the file
// extension, certain characters not allowed such as `+`, etc) are associated
// with a so-called "short name", at least on the `C:` drive by default.
// Which means that `git~1/` is a valid way to refer to `.git/`.
"git~1": {},
}
// validPath checks whether paths are valid.
// The rules around invalid paths could differ from upstream based on how
// filesystems are managed within go-git, but they are largely the same.
//
// For upstream rules:
// https://github.com/git/git/blob/564d0252ca632e0264ed670534a51d18a689ef5d/read-cache.c#L946
// https://github.com/git/git/blob/564d0252ca632e0264ed670534a51d18a689ef5d/path.c#L1383
func validPath(paths ...string) error {
for _, p := range paths {
parts := strings.FieldsFunc(p, func(r rune) bool { return (r == '\\' || r == '/') })
if len(parts) == 0 {
return fmt.Errorf("invalid path: %q", p)
}
if _, denied := worktreeDeny[strings.ToLower(parts[0])]; denied {
return fmt.Errorf("invalid path prefix: %q", p)
}
if runtime.GOOS == "windows" {
// Volume names are not supported, in both formats: \\ and :.
if vol := filepath.VolumeName(p); vol != "" {
return fmt.Errorf("invalid path: %q", p)
}
if !windowsValidPath(parts[0]) {
return fmt.Errorf("invalid path: %q", p)
}
}
for _, part := range parts {
if part == ".." {
return fmt.Errorf("invalid path %q: cannot use '..'", p)
}
}
}
return nil
}
// windowsPathReplacer defines the chars that need to be replaced
// as part of windowsValidPath.
var windowsPathReplacer *strings.Replacer
func init() {
windowsPathReplacer = strings.NewReplacer(" ", "", ".", "")
}
func windowsValidPath(part string) bool {
if len(part) > 3 && strings.EqualFold(part[:4], GitDirName) {
// For historical reasons, file names that end in spaces or periods are
// automatically trimmed. Therefore, `.git . . ./` is a valid way to refer
// to `.git/`.
if windowsPathReplacer.Replace(part[4:]) == "" {
return false
}
// For yet other historical reasons, NTFS supports so-called "Alternate Data
// Streams", i.e. metadata associated with a given file, referred to via
// `::`. There exists a default stream
// type for directories, allowing `.git/` to be accessed via
// `.git::$INDEX_ALLOCATION/`.
//
// For performance reasons, _all_ Alternate Data Streams of `.git/` are
// forbidden, not just `::$INDEX_ALLOCATION`.
if len(part) > 4 && part[4:5] == ":" {
return false
}
}
return true
}
func (w *Worktree) validChange(ch merkletrie.Change) error {
action, err := ch.Action()
if err != nil {
return nil
}
switch action {
case merkletrie.Delete:
return validPath(ch.From.String())
case merkletrie.Insert:
return validPath(ch.To.String())
case merkletrie.Modify:
return validPath(ch.From.String(), ch.To.String())
}
return nil
}
func (w *Worktree) checkoutChange(ch merkletrie.Change, t *object.Tree, idx *indexBuilder) error {
a, err := ch.Action()
if err != nil {
return err
}
var e *object.TreeEntry
var name string
var isSubmodule bool
switch a {
case merkletrie.Modify, merkletrie.Insert:
name = ch.To.String()
e, err = t.FindEntry(name)
if err != nil {
return err
}
isSubmodule = e.Mode == filemode.Submodule
case merkletrie.Delete:
return rmFileAndDirsIfEmpty(w.Filesystem, ch.From.String())
}
if isSubmodule {
return w.checkoutChangeSubmodule(name, a, e, idx)
}
return w.checkoutChangeRegularFile(name, a, t, e, idx)
}
func (w *Worktree) containsUnstagedChanges() (bool, error) {
ch, err := w.diffStagingWithWorktree(false, true)
if err != nil {
return false, err
}
for _, c := range ch {
a, err := c.Action()
if err != nil {
return false, err
}
if a == merkletrie.Insert {
continue
}
return true, nil
}
return false, nil
}
func (w *Worktree) setHEADCommit(commit plumbing.Hash) error {
head, err := w.r.Reference(plumbing.HEAD, false)
if err != nil {
return err
}
if head.Type() == plumbing.HashReference {
head = plumbing.NewHashReference(plumbing.HEAD, commit)
return w.r.Storer.SetReference(head)
}
branch, err := w.r.Reference(head.Target(), false)
if err != nil {
return err
}
if !branch.Name().IsBranch() {
return fmt.Errorf("invalid HEAD target should be a branch, found %s", branch.Type())
}
branch = plumbing.NewHashReference(branch.Name(), commit)
return w.r.Storer.SetReference(branch)
}
func (w *Worktree) checkoutChangeSubmodule(name string,
a merkletrie.Action,
e *object.TreeEntry,
idx *indexBuilder,
) error {
switch a {
case merkletrie.Modify:
sub, err := w.Submodule(name)
if err != nil {
return err
}
if !sub.initialized {
return nil
}
return w.addIndexFromTreeEntry(name, e, idx)
case merkletrie.Insert:
mode, err := e.Mode.ToOSFileMode()
if err != nil {
return err
}
if err := w.Filesystem.MkdirAll(name, mode); err != nil {
return err
}
return w.addIndexFromTreeEntry(name, e, idx)
}
return nil
}
func (w *Worktree) checkoutChangeRegularFile(name string,
a merkletrie.Action,
t *object.Tree,
e *object.TreeEntry,
idx *indexBuilder,
) error {
switch a {
case merkletrie.Modify:
idx.Remove(name)
// to apply perm changes the file is deleted, billy doesn't implement
// chmod
if err := w.Filesystem.Remove(name); err != nil {
return err
}
fallthrough
case merkletrie.Insert:
f, err := t.File(name)
if err != nil {
return err
}
if err := w.checkoutFile(f); err != nil {
return err
}
return w.addIndexFromFile(name, e.Hash, f.Mode, idx)
}
return nil
}
func (w *Worktree) checkoutFile(f *object.File) (err error) {
mode, err := f.Mode.ToOSFileMode()
if err != nil {
return
}
if mode&os.ModeSymlink != 0 {
return w.checkoutFileSymlink(f)
}
from, err := f.Reader()
if err != nil {
return
}
defer ioutil.CheckClose(from, &err)
to, err := w.Filesystem.OpenFile(f.Name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, mode.Perm())
if err != nil {
return
}
defer ioutil.CheckClose(to, &err)
buf := sync.GetByteSlice()
_, err = io.CopyBuffer(to, from, *buf)
sync.PutByteSlice(buf)
return
}
func (w *Worktree) checkoutFileSymlink(f *object.File) (err error) {
// https://github.com/git/git/commit/10ecfa76491e4923988337b2e2243b05376b40de
if strings.EqualFold(f.Name, gitmodulesFile) {
return ErrGitModulesSymlink
}
from, err := f.Reader()
if err != nil {
return
}
defer ioutil.CheckClose(from, &err)
bytes, err := io.ReadAll(from)
if err != nil {
return
}
err = w.Filesystem.Symlink(string(bytes), f.Name)
// On windows, this might fail.
// Follow Git on Windows behavior by writing the link as it is.
if err != nil && isSymlinkWindowsNonAdmin(err) {
mode, _ := f.Mode.ToOSFileMode()
to, err := w.Filesystem.OpenFile(f.Name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, mode.Perm())
if err != nil {
return err
}
defer ioutil.CheckClose(to, &err)
_, err = to.Write(bytes)
return err
}
return
}
func (w *Worktree) addIndexFromTreeEntry(name string, f *object.TreeEntry, idx *indexBuilder) error {
idx.Remove(name)
idx.Add(&index.Entry{
Hash: f.Hash,
Name: name,
Mode: filemode.Submodule,
})
return nil
}
func (w *Worktree) addIndexFromFile(name string, h plumbing.Hash, mode filemode.FileMode, idx *indexBuilder) error {
idx.Remove(name)
fi, err := w.Filesystem.Lstat(name)
if err != nil {
return err
}
e := &index.Entry{
Hash: h,
Name: name,
Mode: mode,
ModifiedAt: fi.ModTime(),
Size: uint32(fi.Size()),
}
// if the FileInfo.Sys() comes from os the ctime, dev, inode, uid and gid
// can be retrieved, otherwise this doesn't apply
if fillSystemInfo != nil {
fillSystemInfo(e, fi.Sys())
}
idx.Add(e)
return nil
}
func (r *Repository) getTreeFromCommitHash(commit plumbing.Hash) (*object.Tree, error) {
c, err := r.CommitObject(commit)
if err != nil {
return nil, err
}
return c.Tree()
}
var fillSystemInfo func(e *index.Entry, sys interface{})
const gitmodulesFile = ".gitmodules"
// Submodule returns the submodule with the given name
func (w *Worktree) Submodule(name string) (*Submodule, error) {
l, err := w.Submodules()
if err != nil {
return nil, err
}
for _, m := range l {
if m.Config().Name == name {
return m, nil
}
}
return nil, ErrSubmoduleNotFound
}
// Submodules returns all the available submodules
func (w *Worktree) Submodules() (Submodules, error) {
l := make(Submodules, 0)
m, err := w.readGitmodulesFile()
if err != nil || m == nil {
return l, err
}
c, err := w.r.Config()
if err != nil {
return nil, err
}
for _, s := range m.Submodules {
l = append(l, w.newSubmodule(s, c.Submodules[s.Name]))
}
return l, nil
}
func (w *Worktree) newSubmodule(fromModules, fromConfig *config.Submodule) *Submodule {
m := &Submodule{w: w}
m.initialized = fromConfig != nil
if !m.initialized {
m.c = fromModules
return m
}
m.c = fromConfig
m.c.Path = fromModules.Path
return m
}
func (w *Worktree) isSymlink(path string) bool {
if s, err := w.Filesystem.Lstat(path); err == nil {
return s.Mode()&os.ModeSymlink != 0
}
return false
}
func (w *Worktree) readGitmodulesFile() (*config.Modules, error) {
if w.isSymlink(gitmodulesFile) {
return nil, ErrGitModulesSymlink
}
f, err := w.Filesystem.Open(gitmodulesFile)
if err != nil {
if os.IsNotExist(err) {
return nil, nil
}
return nil, err
}
defer f.Close()
input, err := io.ReadAll(f)
if err != nil {
return nil, err
}
m := config.NewModules()
if err := m.Unmarshal(input); err != nil {
return m, err
}
return m, nil
}
// Clean the worktree by removing untracked files.
// An empty dir could be removed - this is what `git clean -f -d .` does.
func (w *Worktree) Clean(opts *CleanOptions) error {
s, err := w.Status()
if err != nil {
return err
}
root := ""
files, err := w.Filesystem.ReadDir(root)
if err != nil {
return err
}
return w.doClean(s, opts, root, files)
}
func (w *Worktree) doClean(status Status, opts *CleanOptions, dir string, files []os.FileInfo) error {
for _, fi := range files {
if fi.Name() == GitDirName {
continue
}
// relative path under the root
path := filepath.Join(dir, fi.Name())
if fi.IsDir() {
if !opts.Dir {
continue
}
subfiles, err := w.Filesystem.ReadDir(path)
if err != nil {
return err
}
err = w.doClean(status, opts, path, subfiles)
if err != nil {
return err
}
} else {
if status.IsUntracked(path) {
if err := w.Filesystem.Remove(path); err != nil {
return err
}
}
}
}
if opts.Dir && dir != "" {
_, err := removeDirIfEmpty(w.Filesystem, dir)
return err
}
return nil
}
// GrepResult is structure of a grep result.
type GrepResult struct {
// FileName is the name of file which contains match.
FileName string
// LineNumber is the line number of a file at which a match was found.
LineNumber int
// Content is the content of the file at the matching line.
Content string
// TreeName is the name of the tree (reference name/commit hash) at
// which the match was performed.
TreeName string
}
func (gr GrepResult) String() string {
return fmt.Sprintf("%s:%s:%d:%s", gr.TreeName, gr.FileName, gr.LineNumber, gr.Content)
}
// Grep performs grep on a repository.
func (r *Repository) Grep(opts *GrepOptions) ([]GrepResult, error) {
if err := opts.validate(r); err != nil {
return nil, err
}
// Obtain commit hash from options (CommitHash or ReferenceName).
var commitHash plumbing.Hash
// treeName contains the value of TreeName in GrepResult.
var treeName string
if opts.ReferenceName != "" {
ref, err := r.Reference(opts.ReferenceName, true)
if err != nil {
return nil, err
}
commitHash = ref.Hash()
treeName = opts.ReferenceName.String()
} else if !opts.CommitHash.IsZero() {
commitHash = opts.CommitHash
treeName = opts.CommitHash.String()
}
// Obtain a tree from the commit hash and get a tracked files iterator from
// the tree.
tree, err := r.getTreeFromCommitHash(commitHash)
if err != nil {
return nil, err
}
fileiter := tree.Files()
return findMatchInFiles(fileiter, treeName, opts)
}
// Grep performs grep on a worktree.
func (w *Worktree) Grep(opts *GrepOptions) ([]GrepResult, error) {
return w.r.Grep(opts)
}
// findMatchInFiles takes a FileIter, worktree name and GrepOptions, and
// returns a slice of GrepResult containing the result of regex pattern matching
// in content of all the files.
func findMatchInFiles(fileiter *object.FileIter, treeName string, opts *GrepOptions) ([]GrepResult, error) {
var results []GrepResult
err := fileiter.ForEach(func(file *object.File) error {
var fileInPathSpec bool
// When no pathspecs are provided, search all the files.
if len(opts.PathSpecs) == 0 {
fileInPathSpec = true
}
// Check if the file name matches with the pathspec. Break out of the
// loop once a match is found.
for _, pathSpec := range opts.PathSpecs {
if pathSpec != nil && pathSpec.MatchString(file.Name) {
fileInPathSpec = true
break
}
}
// If the file does not match with any of the pathspec, skip it.
if !fileInPathSpec {
return nil
}
grepResults, err := findMatchInFile(file, treeName, opts)
if err != nil {
return err
}
results = append(results, grepResults...)
return nil
})
return results, err
}
// findMatchInFile takes a single File, worktree name and GrepOptions,
// and returns a slice of GrepResult containing the result of regex pattern
// matching in the given file.
func findMatchInFile(file *object.File, treeName string, opts *GrepOptions) ([]GrepResult, error) {
var grepResults []GrepResult
content, err := file.Contents()
if err != nil {
return grepResults, err
}
// Split the file content and parse line-by-line.
contentByLine := strings.Split(content, "\n")
for lineNum, cnt := range contentByLine {
addToResult := false
// Match the patterns and content. Break out of the loop once a
// match is found.
for _, pattern := range opts.Patterns {
if pattern != nil && pattern.MatchString(cnt) {
// Add to result only if invert match is not enabled.
if !opts.InvertMatch {
addToResult = true
break
}
} else if opts.InvertMatch {
// If matching fails, and invert match is enabled, add to
// results.
addToResult = true
break
}
}
if addToResult {
grepResults = append(grepResults, GrepResult{
FileName: file.Name,
LineNumber: lineNum + 1,
Content: cnt,
TreeName: treeName,
})
}
}
return grepResults, nil
}
// will walk up the directory tree removing all encountered empty
// directories, not just the one containing this file
func rmFileAndDirsIfEmpty(fs billy.Filesystem, name string) error {
if err := util.RemoveAll(fs, name); err != nil {
return err
}
dir := filepath.Dir(name)
for {
removed, err := removeDirIfEmpty(fs, dir)
if err != nil && !os.IsNotExist(err) {
return err
}
if !removed {
// directory was not empty and not removed,
// stop checking parents
break
}
// move to parent directory
dir = filepath.Dir(dir)
}
return nil
}
// removeDirIfEmpty will remove the supplied directory `dir` if
// `dir` is empty
// returns true if the directory was removed
func removeDirIfEmpty(fs billy.Filesystem, dir string) (bool, error) {
files, err := fs.ReadDir(dir)
if err != nil {
return false, err
}
if len(files) > 0 {
return false, nil
}
err = fs.Remove(dir)
if err != nil {
return false, err
}
return true, nil
}
type indexBuilder struct {
entries map[string]*index.Entry
}
func newIndexBuilder(idx *index.Index) *indexBuilder {
entries := make(map[string]*index.Entry, len(idx.Entries))
for _, e := range idx.Entries {
entries[e.Name] = e
}
return &indexBuilder{
entries: entries,
}
}
func (b *indexBuilder) Write(idx *index.Index) {
idx.Entries = idx.Entries[:0]
for _, e := range b.entries {
idx.Entries = append(idx.Entries, e)
}
}
func (b *indexBuilder) Add(e *index.Entry) {
b.entries[e.Name] = e
}
func (b *indexBuilder) Remove(name string) {
delete(b.entries, filepath.ToSlash(name))
}
go-git-5.13.2/worktree_bsd.go 0000664 0000000 0000000 00000000712 14744245500 0016016 0 ustar 00root root 0000000 0000000 // +build darwin freebsd netbsd
package git
import (
"syscall"
"time"
"github.com/go-git/go-git/v5/plumbing/format/index"
)
func init() {
fillSystemInfo = func(e *index.Entry, sys interface{}) {
if os, ok := sys.(*syscall.Stat_t); ok {
e.CreatedAt = time.Unix(os.Atimespec.Unix())
e.Dev = uint32(os.Dev)
e.Inode = uint32(os.Ino)
e.GID = os.Gid
e.UID = os.Uid
}
}
}
func isSymlinkWindowsNonAdmin(err error) bool {
return false
}
go-git-5.13.2/worktree_commit.go 0000664 0000000 0000000 00000016211 14744245500 0016537 0 ustar 00root root 0000000 0000000 package git
import (
"bytes"
"errors"
"io"
"path"
"regexp"
"sort"
"strings"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/format/index"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/storage"
"github.com/ProtonMail/go-crypto/openpgp"
"github.com/ProtonMail/go-crypto/openpgp/packet"
"github.com/go-git/go-billy/v5"
)
var (
// ErrEmptyCommit occurs when a commit is attempted using a clean
// working tree, with no changes to be committed.
ErrEmptyCommit = errors.New("cannot create empty commit: clean working tree")
// characters to be removed from user name and/or email before using them to build a commit object
// See https://git-scm.com/docs/git-commit#_commit_information
invalidCharactersRe = regexp.MustCompile(`[<>\n]`)
)
// Commit stores the current contents of the index in a new commit along with
// a log message from the user describing the changes.
func (w *Worktree) Commit(msg string, opts *CommitOptions) (plumbing.Hash, error) {
if err := opts.Validate(w.r); err != nil {
return plumbing.ZeroHash, err
}
if opts.All {
if err := w.autoAddModifiedAndDeleted(); err != nil {
return plumbing.ZeroHash, err
}
}
if opts.Amend {
head, err := w.r.Head()
if err != nil {
return plumbing.ZeroHash, err
}
headCommit, err := w.r.CommitObject(head.Hash())
if err != nil {
return plumbing.ZeroHash, err
}
opts.Parents = nil
if len(headCommit.ParentHashes) != 0 {
opts.Parents = []plumbing.Hash{headCommit.ParentHashes[0]}
}
}
idx, err := w.r.Storer.Index()
if err != nil {
return plumbing.ZeroHash, err
}
// First handle the case of the first commit in the repository being empty.
if len(opts.Parents) == 0 && len(idx.Entries) == 0 && !opts.AllowEmptyCommits {
return plumbing.ZeroHash, ErrEmptyCommit
}
h := &buildTreeHelper{
fs: w.Filesystem,
s: w.r.Storer,
}
treeHash, err := h.BuildTree(idx, opts)
if err != nil {
return plumbing.ZeroHash, err
}
previousTree := plumbing.ZeroHash
if len(opts.Parents) > 0 {
parentCommit, err := w.r.CommitObject(opts.Parents[0])
if err != nil {
return plumbing.ZeroHash, err
}
previousTree = parentCommit.TreeHash
}
if treeHash == previousTree && !opts.AllowEmptyCommits {
return plumbing.ZeroHash, ErrEmptyCommit
}
commit, err := w.buildCommitObject(msg, opts, treeHash)
if err != nil {
return plumbing.ZeroHash, err
}
return commit, w.updateHEAD(commit)
}
func (w *Worktree) autoAddModifiedAndDeleted() error {
s, err := w.Status()
if err != nil {
return err
}
idx, err := w.r.Storer.Index()
if err != nil {
return err
}
for path, fs := range s {
if fs.Worktree != Modified && fs.Worktree != Deleted {
continue
}
if _, _, err := w.doAddFile(idx, s, path, nil); err != nil {
return err
}
}
return w.r.Storer.SetIndex(idx)
}
func (w *Worktree) updateHEAD(commit plumbing.Hash) error {
head, err := w.r.Storer.Reference(plumbing.HEAD)
if err != nil {
return err
}
name := plumbing.HEAD
if head.Type() != plumbing.HashReference {
name = head.Target()
}
ref := plumbing.NewHashReference(name, commit)
return w.r.Storer.SetReference(ref)
}
func (w *Worktree) buildCommitObject(msg string, opts *CommitOptions, tree plumbing.Hash) (plumbing.Hash, error) {
commit := &object.Commit{
Author: w.sanitize(*opts.Author),
Committer: w.sanitize(*opts.Committer),
Message: msg,
TreeHash: tree,
ParentHashes: opts.Parents,
}
// Convert SignKey into a Signer if set. Existing Signer should take priority.
signer := opts.Signer
if signer == nil && opts.SignKey != nil {
signer = &gpgSigner{key: opts.SignKey}
}
if signer != nil {
sig, err := signObject(signer, commit)
if err != nil {
return plumbing.ZeroHash, err
}
commit.PGPSignature = string(sig)
}
obj := w.r.Storer.NewEncodedObject()
if err := commit.Encode(obj); err != nil {
return plumbing.ZeroHash, err
}
return w.r.Storer.SetEncodedObject(obj)
}
func (w *Worktree) sanitize(signature object.Signature) object.Signature {
return object.Signature{
Name: invalidCharactersRe.ReplaceAllString(signature.Name, ""),
Email: invalidCharactersRe.ReplaceAllString(signature.Email, ""),
When: signature.When,
}
}
type gpgSigner struct {
key *openpgp.Entity
cfg *packet.Config
}
func (s *gpgSigner) Sign(message io.Reader) ([]byte, error) {
var b bytes.Buffer
if err := openpgp.ArmoredDetachSign(&b, s.key, message, s.cfg); err != nil {
return nil, err
}
return b.Bytes(), nil
}
// buildTreeHelper converts a given index.Index file into multiple git objects
// reading the blobs from the given filesystem and creating the trees from the
// index structure. The created objects are pushed to a given Storer.
type buildTreeHelper struct {
fs billy.Filesystem
s storage.Storer
trees map[string]*object.Tree
entries map[string]*object.TreeEntry
}
// BuildTree builds the tree objects and push its to the storer, the hash
// of the root tree is returned.
func (h *buildTreeHelper) BuildTree(idx *index.Index, opts *CommitOptions) (plumbing.Hash, error) {
const rootNode = ""
h.trees = map[string]*object.Tree{rootNode: {}}
h.entries = map[string]*object.TreeEntry{}
for _, e := range idx.Entries {
if err := h.commitIndexEntry(e); err != nil {
return plumbing.ZeroHash, err
}
}
return h.copyTreeToStorageRecursive(rootNode, h.trees[rootNode])
}
func (h *buildTreeHelper) commitIndexEntry(e *index.Entry) error {
parts := strings.Split(e.Name, "/")
var fullpath string
for _, part := range parts {
parent := fullpath
fullpath = path.Join(fullpath, part)
h.doBuildTree(e, parent, fullpath)
}
return nil
}
func (h *buildTreeHelper) doBuildTree(e *index.Entry, parent, fullpath string) {
if _, ok := h.trees[fullpath]; ok {
return
}
if _, ok := h.entries[fullpath]; ok {
return
}
te := object.TreeEntry{Name: path.Base(fullpath)}
if fullpath == e.Name {
te.Mode = e.Mode
te.Hash = e.Hash
} else {
te.Mode = filemode.Dir
h.trees[fullpath] = &object.Tree{}
}
h.trees[parent].Entries = append(h.trees[parent].Entries, te)
}
type sortableEntries []object.TreeEntry
func (sortableEntries) sortName(te object.TreeEntry) string {
if te.Mode == filemode.Dir {
return te.Name + "/"
}
return te.Name
}
func (se sortableEntries) Len() int { return len(se) }
func (se sortableEntries) Less(i int, j int) bool { return se.sortName(se[i]) < se.sortName(se[j]) }
func (se sortableEntries) Swap(i int, j int) { se[i], se[j] = se[j], se[i] }
func (h *buildTreeHelper) copyTreeToStorageRecursive(parent string, t *object.Tree) (plumbing.Hash, error) {
sort.Sort(sortableEntries(t.Entries))
for i, e := range t.Entries {
if e.Mode != filemode.Dir && !e.Hash.IsZero() {
continue
}
path := path.Join(parent, e.Name)
var err error
e.Hash, err = h.copyTreeToStorageRecursive(path, h.trees[path])
if err != nil {
return plumbing.ZeroHash, err
}
t.Entries[i] = e
}
o := h.s.NewEncodedObject()
if err := t.Encode(o); err != nil {
return plumbing.ZeroHash, err
}
hash := o.Hash()
if h.s.HasEncodedObject(hash) == nil {
return hash, nil
}
return h.s.SetEncodedObject(o)
}
go-git-5.13.2/worktree_commit_test.go 0000664 0000000 0000000 00000053566 14744245500 0017614 0 ustar 00root root 0000000 0000000 package git
import (
"bytes"
"log"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"time"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/plumbing/storer"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-git/v5/storage/memory"
"github.com/ProtonMail/go-crypto/openpgp"
"github.com/ProtonMail/go-crypto/openpgp/armor"
"github.com/ProtonMail/go-crypto/openpgp/errors"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-billy/v5/util"
. "gopkg.in/check.v1"
)
func (s *WorktreeSuite) TestCommitEmptyOptions(c *C) {
fs := memfs.New()
r, err := Init(memory.NewStorage(), fs)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
util.WriteFile(fs, "foo", []byte("foo"), 0644)
_, err = w.Add("foo")
c.Assert(err, IsNil)
hash, err := w.Commit("foo", &CommitOptions{})
c.Assert(err, IsNil)
c.Assert(hash.IsZero(), Equals, false)
commit, err := r.CommitObject(hash)
c.Assert(err, IsNil)
c.Assert(commit.Author.Name, Not(Equals), "")
}
func (s *WorktreeSuite) TestCommitInitial(c *C) {
expected := plumbing.NewHash("98c4ac7c29c913f7461eae06e024dc18e80d23a4")
fs := memfs.New()
storage := memory.NewStorage()
r, err := Init(storage, fs)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
util.WriteFile(fs, "foo", []byte("foo"), 0644)
_, err = w.Add("foo")
c.Assert(err, IsNil)
hash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature()})
c.Assert(hash, Equals, expected)
c.Assert(err, IsNil)
assertStorageStatus(c, r, 1, 1, 1, expected)
}
func (s *WorktreeSuite) TestNothingToCommit(c *C) {
expected := plumbing.NewHash("838ea833ce893e8555907e5ef224aa076f5e274a")
r, err := Init(memory.NewStorage(), memfs.New())
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
hash, err := w.Commit("failed empty commit\n", &CommitOptions{Author: defaultSignature()})
c.Assert(hash, Equals, plumbing.ZeroHash)
c.Assert(err, Equals, ErrEmptyCommit)
hash, err = w.Commit("enable empty commits\n", &CommitOptions{Author: defaultSignature(), AllowEmptyCommits: true})
c.Assert(hash, Equals, expected)
c.Assert(err, IsNil)
}
func (s *WorktreeSuite) TestNothingToCommitNonEmptyRepo(c *C) {
fs := memfs.New()
r, err := Init(memory.NewStorage(), fs)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
err = util.WriteFile(fs, "foo", []byte("foo"), 0644)
c.Assert(err, IsNil)
w.Add("foo")
_, err = w.Commit("previous commit\n", &CommitOptions{Author: defaultSignature()})
c.Assert(err, IsNil)
hash, err := w.Commit("failed empty commit\n", &CommitOptions{Author: defaultSignature()})
c.Assert(hash, Equals, plumbing.ZeroHash)
c.Assert(err, Equals, ErrEmptyCommit)
_, err = w.Commit("enable empty commits\n", &CommitOptions{Author: defaultSignature(), AllowEmptyCommits: true})
c.Assert(err, IsNil)
}
func (s *WorktreeSuite) TestRemoveAndCommitToMakeEmptyRepo(c *C) {
fs := memfs.New()
r, err := Init(memory.NewStorage(), fs)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
err = util.WriteFile(fs, "foo", []byte("foo"), 0644)
c.Assert(err, IsNil)
_, err = w.Add("foo")
c.Assert(err, IsNil)
_, err = w.Commit("Add in Repo\n", &CommitOptions{Author: defaultSignature()})
c.Assert(err, IsNil)
err = fs.Remove("foo")
c.Assert(err, IsNil)
_, err = w.Add("foo")
c.Assert(err, IsNil)
_, err = w.Commit("Remove foo\n", &CommitOptions{Author: defaultSignature()})
c.Assert(err, IsNil)
}
func (s *WorktreeSuite) TestCommitParent(c *C) {
expected := plumbing.NewHash("ef3ca05477530b37f48564be33ddd48063fc7a22")
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
err = util.WriteFile(fs, "foo", []byte("foo"), 0644)
c.Assert(err, IsNil)
_, err = w.Add("foo")
c.Assert(err, IsNil)
hash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature()})
c.Assert(hash, Equals, expected)
c.Assert(err, IsNil)
assertStorageStatus(c, s.Repository, 13, 11, 10, expected)
}
func (s *WorktreeSuite) TestCommitAmendWithoutChanges(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
err = util.WriteFile(fs, "foo", []byte("foo"), 0644)
c.Assert(err, IsNil)
_, err = w.Add("foo")
c.Assert(err, IsNil)
prevHash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature()})
c.Assert(err, IsNil)
amendedHash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature(), Amend: true})
c.Assert(err, IsNil)
headRef, err := w.r.Head()
c.Assert(err, IsNil)
c.Assert(amendedHash, Equals, headRef.Hash())
c.Assert(amendedHash, Equals, prevHash)
commit, err := w.r.CommitObject(headRef.Hash())
c.Assert(err, IsNil)
c.Assert(commit.Message, Equals, "foo\n")
assertStorageStatus(c, s.Repository, 13, 11, 10, amendedHash)
}
func (s *WorktreeSuite) TestCommitAmendWithChanges(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
util.WriteFile(fs, "foo", []byte("foo"), 0644)
_, err = w.Add("foo")
c.Assert(err, IsNil)
_, err = w.Commit("foo\n", &CommitOptions{Author: defaultSignature()})
c.Assert(err, IsNil)
util.WriteFile(fs, "bar", []byte("bar"), 0644)
_, err = w.Add("bar")
c.Assert(err, IsNil)
amendedHash, err := w.Commit("bar\n", &CommitOptions{Amend: true})
c.Assert(err, IsNil)
headRef, err := w.r.Head()
c.Assert(err, IsNil)
c.Assert(amendedHash, Equals, headRef.Hash())
commit, err := w.r.CommitObject(headRef.Hash())
c.Assert(err, IsNil)
c.Assert(commit.Message, Equals, "bar\n")
c.Assert(commit.NumParents(), Equals, 1)
stats, err := commit.Stats()
c.Assert(err, IsNil)
c.Assert(stats, HasLen, 2)
c.Assert(stats[0], Equals, object.FileStat{
Name: "bar",
Addition: 1,
})
c.Assert(stats[1], Equals, object.FileStat{
Name: "foo",
Addition: 1,
})
assertStorageStatus(c, s.Repository, 14, 12, 11, amendedHash)
}
func (s *WorktreeSuite) TestCommitAmendNothingToCommit(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
err = util.WriteFile(fs, "foo", []byte("foo"), 0644)
c.Assert(err, IsNil)
_, err = w.Add("foo")
c.Assert(err, IsNil)
prevHash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature()})
c.Assert(err, IsNil)
_, err = w.Commit("bar\n", &CommitOptions{Author: defaultSignature(), AllowEmptyCommits: true})
c.Assert(err, IsNil)
amendedHash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature(), Amend: true})
c.Log(prevHash, amendedHash)
c.Assert(err, Equals, ErrEmptyCommit)
c.Assert(amendedHash, Equals, plumbing.ZeroHash)
}
func (s *WorktreeSuite) TestAddAndCommitWithSkipStatus(c *C) {
expected := plumbing.NewHash("375a3808ffde7f129cdd3c8c252fd0fe37cfd13b")
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
util.WriteFile(fs, "LICENSE", []byte("foo"), 0644)
util.WriteFile(fs, "foo", []byte("foo"), 0644)
err = w.AddWithOptions(&AddOptions{
Path: "foo",
SkipStatus: true,
})
c.Assert(err, IsNil)
hash, err := w.Commit("commit foo only\n", &CommitOptions{
Author: defaultSignature(),
})
c.Assert(hash, Equals, expected)
c.Assert(err, IsNil)
assertStorageStatus(c, s.Repository, 13, 11, 10, expected)
}
func (s *WorktreeSuite) TestAddAndCommitWithSkipStatusPathNotModified(c *C) {
expected := plumbing.NewHash("375a3808ffde7f129cdd3c8c252fd0fe37cfd13b")
expected2 := plumbing.NewHash("8691273baf8f6ee2cccfc05e910552c04d02d472")
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
util.WriteFile(fs, "foo", []byte("foo"), 0644)
status, err := w.Status()
c.Assert(err, IsNil)
foo := status.File("foo")
c.Assert(foo.Staging, Equals, Untracked)
c.Assert(foo.Worktree, Equals, Untracked)
err = w.AddWithOptions(&AddOptions{
Path: "foo",
SkipStatus: true,
})
c.Assert(err, IsNil)
status, err = w.Status()
c.Assert(err, IsNil)
foo = status.File("foo")
c.Assert(foo.Staging, Equals, Added)
c.Assert(foo.Worktree, Equals, Unmodified)
hash, err := w.Commit("commit foo only\n", &CommitOptions{All: true,
Author: defaultSignature(),
})
c.Assert(hash, Equals, expected)
c.Assert(err, IsNil)
commit1, err := w.r.CommitObject(hash)
c.Assert(err, IsNil)
status, err = w.Status()
c.Assert(err, IsNil)
foo = status.File("foo")
c.Assert(foo.Staging, Equals, Untracked)
c.Assert(foo.Worktree, Equals, Untracked)
assertStorageStatus(c, s.Repository, 13, 11, 10, expected)
err = w.AddWithOptions(&AddOptions{
Path: "foo",
SkipStatus: true,
})
c.Assert(err, IsNil)
status, err = w.Status()
c.Assert(err, IsNil)
foo = status.File("foo")
c.Assert(foo.Staging, Equals, Untracked)
c.Assert(foo.Worktree, Equals, Untracked)
hash, err = w.Commit("commit with no changes\n", &CommitOptions{
Author: defaultSignature(),
AllowEmptyCommits: true,
})
c.Assert(hash, Equals, expected2)
c.Assert(err, IsNil)
commit2, err := w.r.CommitObject(hash)
c.Assert(err, IsNil)
status, err = w.Status()
c.Assert(err, IsNil)
foo = status.File("foo")
c.Assert(foo.Staging, Equals, Untracked)
c.Assert(foo.Worktree, Equals, Untracked)
patch, err := commit2.Patch(commit1)
c.Assert(err, IsNil)
files := patch.FilePatches()
c.Assert(files, IsNil)
assertStorageStatus(c, s.Repository, 13, 11, 11, expected2)
}
func (s *WorktreeSuite) TestCommitAll(c *C) {
expected := plumbing.NewHash("aede6f8c9c1c7ec9ca8d287c64b8ed151276fa28")
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
util.WriteFile(fs, "LICENSE", []byte("foo"), 0644)
util.WriteFile(fs, "foo", []byte("foo"), 0644)
hash, err := w.Commit("foo\n", &CommitOptions{
All: true,
Author: defaultSignature(),
})
c.Assert(hash, Equals, expected)
c.Assert(err, IsNil)
assertStorageStatus(c, s.Repository, 13, 11, 10, expected)
}
func (s *WorktreeSuite) TestRemoveAndCommitAll(c *C) {
expected := plumbing.NewHash("907cd576c6ced2ecd3dab34a72bf9cf65944b9a9")
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
util.WriteFile(fs, "foo", []byte("foo"), 0644)
_, err = w.Add("foo")
c.Assert(err, IsNil)
_, errFirst := w.Commit("Add in Repo\n", &CommitOptions{
Author: defaultSignature(),
})
c.Assert(errFirst, IsNil)
errRemove := fs.Remove("foo")
c.Assert(errRemove, IsNil)
hash, errSecond := w.Commit("Remove foo\n", &CommitOptions{
All: true,
Author: defaultSignature(),
})
c.Assert(errSecond, IsNil)
c.Assert(hash, Equals, expected)
c.Assert(err, IsNil)
assertStorageStatus(c, s.Repository, 13, 11, 11, expected)
}
func (s *WorktreeSuite) TestCommitSign(c *C) {
fs := memfs.New()
storage := memory.NewStorage()
r, err := Init(storage, fs)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
util.WriteFile(fs, "foo", []byte("foo"), 0644)
_, err = w.Add("foo")
c.Assert(err, IsNil)
key := commitSignKey(c, true)
hash, err := w.Commit("foo\n", &CommitOptions{Author: defaultSignature(), SignKey: key})
c.Assert(err, IsNil)
// Verify the commit.
pks := new(bytes.Buffer)
pkw, err := armor.Encode(pks, openpgp.PublicKeyType, nil)
c.Assert(err, IsNil)
err = key.Serialize(pkw)
c.Assert(err, IsNil)
err = pkw.Close()
c.Assert(err, IsNil)
expectedCommit, err := r.CommitObject(hash)
c.Assert(err, IsNil)
actual, err := expectedCommit.Verify(pks.String())
c.Assert(err, IsNil)
c.Assert(actual.PrimaryKey, DeepEquals, key.PrimaryKey)
}
func (s *WorktreeSuite) TestCommitSignBadKey(c *C) {
fs := memfs.New()
storage := memory.NewStorage()
r, err := Init(storage, fs)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
util.WriteFile(fs, "foo", []byte("foo"), 0644)
_, err = w.Add("foo")
c.Assert(err, IsNil)
key := commitSignKey(c, false)
_, err = w.Commit("foo\n", &CommitOptions{Author: defaultSignature(), SignKey: key})
c.Assert(err, Equals, errors.InvalidArgumentError("signing key is encrypted"))
}
func (s *WorktreeSuite) TestCommitTreeSort(c *C) {
fs := s.TemporalFilesystem(c)
st := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
_, err := Init(st, nil)
c.Assert(err, IsNil)
r, _ := Clone(memory.NewStorage(), memfs.New(), &CloneOptions{
URL: fs.Root(),
})
w, err := r.Worktree()
c.Assert(err, IsNil)
mfs := w.Filesystem
err = mfs.MkdirAll("delta", 0755)
c.Assert(err, IsNil)
for _, p := range []string{"delta_last", "Gamma", "delta/middle", "Beta", "delta-first", "alpha"} {
util.WriteFile(mfs, p, []byte("foo"), 0644)
_, err = w.Add(p)
c.Assert(err, IsNil)
}
_, err = w.Commit("foo\n", &CommitOptions{
All: true,
Author: defaultSignature(),
})
c.Assert(err, IsNil)
err = r.Push(&PushOptions{})
c.Assert(err, IsNil)
cmd := exec.Command("git", "fsck")
cmd.Dir = fs.Root()
cmd.Env = os.Environ()
buf := &bytes.Buffer{}
cmd.Stderr = buf
cmd.Stdout = buf
err = cmd.Run()
c.Assert(err, IsNil, Commentf("%s", buf.Bytes()))
}
// https://github.com/go-git/go-git/pull/224
func (s *WorktreeSuite) TestJustStoreObjectsNotAlreadyStored(c *C) {
fs := s.TemporalFilesystem(c)
fsDotgit, err := fs.Chroot(".git") // real fs to get modified timestamps
c.Assert(err, IsNil)
storage := filesystem.NewStorage(fsDotgit, cache.NewObjectLRUDefault())
r, err := Init(storage, fs)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
// Step 1: Write LICENSE
util.WriteFile(fs, "LICENSE", []byte("license"), 0644)
hLicense, err := w.Add("LICENSE")
c.Assert(err, IsNil)
c.Assert(hLicense, Equals, plumbing.NewHash("0484eba0d41636ba71fa612c78559cd6c3006cde"))
hash, err := w.Commit("commit 1\n", &CommitOptions{
All: true,
Author: defaultSignature(),
})
c.Assert(err, IsNil)
c.Assert(hash, Equals, plumbing.NewHash("7a7faee4630d2664a6869677cc8ab614f3fd4a18"))
infoLicense, err := fsDotgit.Stat(filepath.Join("objects", "04", "84eba0d41636ba71fa612c78559cd6c3006cde"))
c.Assert(err, IsNil) // checking objects file exists
// Step 2: Write foo.
time.Sleep(5 * time.Millisecond) // uncool, but we need to get different timestamps...
util.WriteFile(fs, "foo", []byte("foo"), 0644)
hFoo, err := w.Add("foo")
c.Assert(err, IsNil)
c.Assert(hFoo, Equals, plumbing.NewHash("19102815663d23f8b75a47e7a01965dcdc96468c"))
hash, err = w.Commit("commit 2\n", &CommitOptions{
All: true,
Author: defaultSignature(),
})
c.Assert(err, IsNil)
c.Assert(hash, Equals, plumbing.NewHash("97c0c5177e6ac57d10e8ea0017f2d39b91e2b364"))
// Step 3: Check
// There is no need to overwrite the object of LICENSE, because its content
// was not changed. Just a write on the object of foo is required. This behaviour
// is fixed by #224 and tested by comparing the timestamps of the stored objects.
infoFoo, err := fsDotgit.Stat(filepath.Join("objects", "19", "102815663d23f8b75a47e7a01965dcdc96468c"))
c.Assert(err, IsNil) // checking objects file exists
c.Assert(infoLicense.ModTime().Before(infoFoo.ModTime()), Equals, true) // object of foo has another/greaterThan timestamp than LICENSE
infoLicenseSecond, err := fsDotgit.Stat(filepath.Join("objects", "04", "84eba0d41636ba71fa612c78559cd6c3006cde"))
c.Assert(err, IsNil)
log.Printf("comparing mod time: %v == %v on %v (%v)", infoLicenseSecond.ModTime(), infoLicense.ModTime(), runtime.GOOS, runtime.GOARCH)
c.Assert(infoLicenseSecond.ModTime(), Equals, infoLicense.ModTime()) // object of LICENSE should have the same timestamp because no additional write operation was performed
}
func (s *WorktreeSuite) TestCommitInvalidCharactersInAuthorInfos(c *C) {
f := fixtures.Basic().One()
s.Repository = s.NewRepositoryWithEmptyWorktree(f)
expected := plumbing.NewHash("e8eecef2524c3a37cf0f0996603162f81e0373f1")
fs := memfs.New()
storage := memory.NewStorage()
r, err := Init(storage, fs)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
util.WriteFile(fs, "foo", []byte("foo"), 0644)
_, err = w.Add("foo")
c.Assert(err, IsNil)
hash, err := w.Commit("foo\n", &CommitOptions{Author: invalidSignature()})
c.Assert(hash, Equals, expected)
c.Assert(err, IsNil)
assertStorageStatus(c, r, 1, 1, 1, expected)
// Check HEAD commit contains author informations with '<', '>' and '\n' stripped
lr, err := r.Log(&LogOptions{})
c.Assert(err, IsNil)
commit, err := lr.Next()
c.Assert(err, IsNil)
c.Assert(commit.Author.Name, Equals, "foo bad")
c.Assert(commit.Author.Email, Equals, "badfoo@foo.foo")
}
func assertStorageStatus(
c *C, r *Repository,
treesCount, blobCount, commitCount int, head plumbing.Hash,
) {
trees, err := r.Storer.IterEncodedObjects(plumbing.TreeObject)
c.Assert(err, IsNil)
blobs, err := r.Storer.IterEncodedObjects(plumbing.BlobObject)
c.Assert(err, IsNil)
commits, err := r.Storer.IterEncodedObjects(plumbing.CommitObject)
c.Assert(err, IsNil)
c.Assert(lenIterEncodedObjects(trees), Equals, treesCount)
c.Assert(lenIterEncodedObjects(blobs), Equals, blobCount)
c.Assert(lenIterEncodedObjects(commits), Equals, commitCount)
ref, err := r.Head()
c.Assert(err, IsNil)
c.Assert(ref.Hash(), Equals, head)
}
func lenIterEncodedObjects(iter storer.EncodedObjectIter) int {
count := 0
iter.ForEach(func(plumbing.EncodedObject) error {
count++
return nil
})
return count
}
func defaultSignature() *object.Signature {
when, _ := time.Parse(object.DateFormat, "Thu May 04 00:03:43 2017 +0200")
return &object.Signature{
Name: "foo",
Email: "foo@foo.foo",
When: when,
}
}
func invalidSignature() *object.Signature {
when, _ := time.Parse(object.DateFormat, "Thu May 04 00:03:43 2017 +0200")
return &object.Signature{
Name: "foo \n",
Email: "\nfoo@foo.foo",
When: when,
}
}
func commitSignKey(c *C, decrypt bool) *openpgp.Entity {
s := strings.NewReader(armoredKeyRing)
es, err := openpgp.ReadArmoredKeyRing(s)
c.Assert(err, IsNil)
c.Assert(es, HasLen, 1)
c.Assert(es[0].Identities, HasLen, 1)
_, ok := es[0].Identities["foo bar "]
c.Assert(ok, Equals, true)
key := es[0]
if decrypt {
err = key.PrivateKey.Decrypt([]byte(keyPassphrase))
c.Assert(err, IsNil)
}
return key
}
const armoredKeyRing = `
-----BEGIN PGP PRIVATE KEY BLOCK-----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=gIM9
-----END PGP PRIVATE KEY BLOCK-----
`
const keyPassphrase = "abcdef0123456789"
go-git-5.13.2/worktree_js.go 0000664 0000000 0000000 00000000710 14744245500 0015660 0 ustar 00root root 0000000 0000000 // +build js
package git
import (
"syscall"
"time"
"github.com/go-git/go-git/v5/plumbing/format/index"
)
func init() {
fillSystemInfo = func(e *index.Entry, sys interface{}) {
if os, ok := sys.(*syscall.Stat_t); ok {
e.CreatedAt = time.Unix(int64(os.Ctime), int64(os.CtimeNsec))
e.Dev = uint32(os.Dev)
e.Inode = uint32(os.Ino)
e.GID = os.Gid
e.UID = os.Uid
}
}
}
func isSymlinkWindowsNonAdmin(err error) bool {
return false
}
go-git-5.13.2/worktree_linux.go 0000664 0000000 0000000 00000000704 14744245500 0016406 0 ustar 00root root 0000000 0000000 //go:build linux
// +build linux
package git
import (
"syscall"
"time"
"github.com/go-git/go-git/v5/plumbing/format/index"
)
func init() {
fillSystemInfo = func(e *index.Entry, sys interface{}) {
if os, ok := sys.(*syscall.Stat_t); ok {
e.CreatedAt = time.Unix(os.Ctim.Unix())
e.Dev = uint32(os.Dev)
e.Inode = uint32(os.Ino)
e.GID = os.Gid
e.UID = os.Uid
}
}
}
func isSymlinkWindowsNonAdmin(_ error) bool {
return false
}
go-git-5.13.2/worktree_plan9.go 0000664 0000000 0000000 00000001077 14744245500 0016276 0 ustar 00root root 0000000 0000000 package git
import (
"syscall"
"time"
"github.com/go-git/go-git/v5/plumbing/format/index"
)
func init() {
fillSystemInfo = func(e *index.Entry, sys interface{}) {
if os, ok := sys.(*syscall.Dir); ok {
// Plan 9 doesn't have a CreatedAt field.
e.CreatedAt = time.Unix(int64(os.Mtime), 0)
e.Dev = uint32(os.Dev)
// Plan 9 has no Inode.
// ext2srv(4) appears to store Inode in Qid.Path.
e.Inode = uint32(os.Qid.Path)
// Plan 9 has string UID/GID
e.GID = 0
e.UID = 0
}
}
}
func isSymlinkWindowsNonAdmin(err error) bool {
return true
}
go-git-5.13.2/worktree_status.go 0000664 0000000 0000000 00000041244 14744245500 0016576 0 ustar 00root root 0000000 0000000 package git
import (
"bytes"
"errors"
"io"
"os"
"path"
"path/filepath"
"strings"
"github.com/go-git/go-billy/v5/util"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/format/gitignore"
"github.com/go-git/go-git/v5/plumbing/format/index"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/utils/ioutil"
"github.com/go-git/go-git/v5/utils/merkletrie"
"github.com/go-git/go-git/v5/utils/merkletrie/filesystem"
mindex "github.com/go-git/go-git/v5/utils/merkletrie/index"
"github.com/go-git/go-git/v5/utils/merkletrie/noder"
)
var (
// ErrDestinationExists in an Move operation means that the target exists on
// the worktree.
ErrDestinationExists = errors.New("destination exists")
// ErrGlobNoMatches in an AddGlob if the glob pattern does not match any
// files in the worktree.
ErrGlobNoMatches = errors.New("glob pattern did not match any files")
// ErrUnsupportedStatusStrategy occurs when an invalid StatusStrategy is used
// when processing the Worktree status.
ErrUnsupportedStatusStrategy = errors.New("unsupported status strategy")
)
// Status returns the working tree status.
func (w *Worktree) Status() (Status, error) {
return w.StatusWithOptions(StatusOptions{Strategy: defaultStatusStrategy})
}
// StatusOptions defines the options for Worktree.StatusWithOptions().
type StatusOptions struct {
Strategy StatusStrategy
}
// StatusWithOptions returns the working tree status.
func (w *Worktree) StatusWithOptions(o StatusOptions) (Status, error) {
var hash plumbing.Hash
ref, err := w.r.Head()
if err != nil && err != plumbing.ErrReferenceNotFound {
return nil, err
}
if err == nil {
hash = ref.Hash()
}
return w.status(o.Strategy, hash)
}
func (w *Worktree) status(ss StatusStrategy, commit plumbing.Hash) (Status, error) {
s, err := ss.new(w)
if err != nil {
return nil, err
}
left, err := w.diffCommitWithStaging(commit, false)
if err != nil {
return nil, err
}
for _, ch := range left {
a, err := ch.Action()
if err != nil {
return nil, err
}
fs := s.File(nameFromAction(&ch))
fs.Worktree = Unmodified
switch a {
case merkletrie.Delete:
s.File(ch.From.String()).Staging = Deleted
case merkletrie.Insert:
s.File(ch.To.String()).Staging = Added
case merkletrie.Modify:
s.File(ch.To.String()).Staging = Modified
}
}
right, err := w.diffStagingWithWorktree(false, true)
if err != nil {
return nil, err
}
for _, ch := range right {
a, err := ch.Action()
if err != nil {
return nil, err
}
fs := s.File(nameFromAction(&ch))
if fs.Staging == Untracked {
fs.Staging = Unmodified
}
switch a {
case merkletrie.Delete:
fs.Worktree = Deleted
case merkletrie.Insert:
fs.Worktree = Untracked
fs.Staging = Untracked
case merkletrie.Modify:
fs.Worktree = Modified
}
}
return s, nil
}
func nameFromAction(ch *merkletrie.Change) string {
name := ch.To.String()
if name == "" {
return ch.From.String()
}
return name
}
func (w *Worktree) diffStagingWithWorktree(reverse, excludeIgnoredChanges bool) (merkletrie.Changes, error) {
idx, err := w.r.Storer.Index()
if err != nil {
return nil, err
}
from := mindex.NewRootNode(idx)
submodules, err := w.getSubmodulesStatus()
if err != nil {
return nil, err
}
to := filesystem.NewRootNode(w.Filesystem, submodules)
var c merkletrie.Changes
if reverse {
c, err = merkletrie.DiffTree(to, from, diffTreeIsEquals)
} else {
c, err = merkletrie.DiffTree(from, to, diffTreeIsEquals)
}
if err != nil {
return nil, err
}
if excludeIgnoredChanges {
return w.excludeIgnoredChanges(c), nil
}
return c, nil
}
func (w *Worktree) excludeIgnoredChanges(changes merkletrie.Changes) merkletrie.Changes {
patterns, err := gitignore.ReadPatterns(w.Filesystem, nil)
if err != nil {
return changes
}
patterns = append(patterns, w.Excludes...)
if len(patterns) == 0 {
return changes
}
m := gitignore.NewMatcher(patterns)
var res merkletrie.Changes
for _, ch := range changes {
var path []string
for _, n := range ch.To {
path = append(path, n.Name())
}
if len(path) == 0 {
for _, n := range ch.From {
path = append(path, n.Name())
}
}
if len(path) != 0 {
isDir := (len(ch.To) > 0 && ch.To.IsDir()) || (len(ch.From) > 0 && ch.From.IsDir())
if m.Match(path, isDir) {
if len(ch.From) == 0 {
continue
}
}
}
res = append(res, ch)
}
return res
}
func (w *Worktree) getSubmodulesStatus() (map[string]plumbing.Hash, error) {
o := map[string]plumbing.Hash{}
sub, err := w.Submodules()
if err != nil {
return nil, err
}
status, err := sub.Status()
if err != nil {
return nil, err
}
for _, s := range status {
if s.Current.IsZero() {
o[s.Path] = s.Expected
continue
}
o[s.Path] = s.Current
}
return o, nil
}
func (w *Worktree) diffCommitWithStaging(commit plumbing.Hash, reverse bool) (merkletrie.Changes, error) {
var t *object.Tree
if !commit.IsZero() {
c, err := w.r.CommitObject(commit)
if err != nil {
return nil, err
}
t, err = c.Tree()
if err != nil {
return nil, err
}
}
return w.diffTreeWithStaging(t, reverse)
}
func (w *Worktree) diffTreeWithStaging(t *object.Tree, reverse bool) (merkletrie.Changes, error) {
var from noder.Noder
if t != nil {
from = object.NewTreeRootNode(t)
}
idx, err := w.r.Storer.Index()
if err != nil {
return nil, err
}
to := mindex.NewRootNode(idx)
if reverse {
return merkletrie.DiffTree(to, from, diffTreeIsEquals)
}
return merkletrie.DiffTree(from, to, diffTreeIsEquals)
}
var emptyNoderHash = make([]byte, 24)
// diffTreeIsEquals is a implementation of noder.Equals, used to compare
// noder.Noder, it compare the content and the length of the hashes.
//
// Since some of the noder.Noder implementations doesn't compute a hash for
// some directories, if any of the hashes is a 24-byte slice of zero values
// the comparison is not done and the hashes are take as different.
func diffTreeIsEquals(a, b noder.Hasher) bool {
hashA := a.Hash()
hashB := b.Hash()
if bytes.Equal(hashA, emptyNoderHash) || bytes.Equal(hashB, emptyNoderHash) {
return false
}
return bytes.Equal(hashA, hashB)
}
// Add adds the file contents of a file in the worktree to the index. if the
// file is already staged in the index no error is returned. If a file deleted
// from the Workspace is given, the file is removed from the index. If a
// directory given, adds the files and all his sub-directories recursively in
// the worktree to the index. If any of the files is already staged in the index
// no error is returned. When path is a file, the blob.Hash is returned.
func (w *Worktree) Add(path string) (plumbing.Hash, error) {
// TODO(mcuadros): deprecate in favor of AddWithOption in v6.
return w.doAdd(path, make([]gitignore.Pattern, 0), false)
}
func (w *Worktree) doAddDirectory(idx *index.Index, s Status, directory string, ignorePattern []gitignore.Pattern) (added bool, err error) {
if len(ignorePattern) > 0 {
m := gitignore.NewMatcher(ignorePattern)
matchPath := strings.Split(directory, string(os.PathSeparator))
if m.Match(matchPath, true) {
// ignore
return false, nil
}
}
directory = filepath.ToSlash(filepath.Clean(directory))
for name := range s {
if !isPathInDirectory(name, directory) {
continue
}
var a bool
a, _, err = w.doAddFile(idx, s, name, ignorePattern)
if err != nil {
return
}
added = added || a
}
return
}
func isPathInDirectory(path, directory string) bool {
return directory == "." || strings.HasPrefix(path, directory+"/")
}
// AddWithOptions file contents to the index, updates the index using the
// current content found in the working tree, to prepare the content staged for
// the next commit.
//
// It typically adds the current content of existing paths as a whole, but with
// some options it can also be used to add content with only part of the changes
// made to the working tree files applied, or remove paths that do not exist in
// the working tree anymore.
func (w *Worktree) AddWithOptions(opts *AddOptions) error {
if err := opts.Validate(w.r); err != nil {
return err
}
if opts.All {
_, err := w.doAdd(".", w.Excludes, false)
return err
}
if opts.Glob != "" {
return w.AddGlob(opts.Glob)
}
_, err := w.doAdd(opts.Path, make([]gitignore.Pattern, 0), opts.SkipStatus)
return err
}
func (w *Worktree) doAdd(path string, ignorePattern []gitignore.Pattern, skipStatus bool) (plumbing.Hash, error) {
idx, err := w.r.Storer.Index()
if err != nil {
return plumbing.ZeroHash, err
}
var h plumbing.Hash
var added bool
fi, err := w.Filesystem.Lstat(path)
// status is required for doAddDirectory
var s Status
var err2 error
if !skipStatus || fi == nil || fi.IsDir() {
s, err2 = w.Status()
if err2 != nil {
return plumbing.ZeroHash, err2
}
}
path = filepath.Clean(path)
if err != nil || !fi.IsDir() {
added, h, err = w.doAddFile(idx, s, path, ignorePattern)
} else {
added, err = w.doAddDirectory(idx, s, path, ignorePattern)
}
if err != nil {
return h, err
}
if !added {
return h, nil
}
return h, w.r.Storer.SetIndex(idx)
}
// AddGlob adds all paths, matching pattern, to the index. If pattern matches a
// directory path, all directory contents are added to the index recursively. No
// error is returned if all matching paths are already staged in index.
func (w *Worktree) AddGlob(pattern string) error {
// TODO(mcuadros): deprecate in favor of AddWithOption in v6.
files, err := util.Glob(w.Filesystem, pattern)
if err != nil {
return err
}
if len(files) == 0 {
return ErrGlobNoMatches
}
s, err := w.Status()
if err != nil {
return err
}
idx, err := w.r.Storer.Index()
if err != nil {
return err
}
var saveIndex bool
for _, file := range files {
fi, err := w.Filesystem.Lstat(file)
if err != nil {
return err
}
var added bool
if fi.IsDir() {
added, err = w.doAddDirectory(idx, s, file, make([]gitignore.Pattern, 0))
} else {
added, _, err = w.doAddFile(idx, s, file, make([]gitignore.Pattern, 0))
}
if err != nil {
return err
}
if !saveIndex && added {
saveIndex = true
}
}
if saveIndex {
return w.r.Storer.SetIndex(idx)
}
return nil
}
// doAddFile create a new blob from path and update the index, added is true if
// the file added is different from the index.
// if s status is nil will skip the status check and update the index anyway
func (w *Worktree) doAddFile(idx *index.Index, s Status, path string, ignorePattern []gitignore.Pattern) (added bool, h plumbing.Hash, err error) {
if s != nil && s.File(path).Worktree == Unmodified {
return false, h, nil
}
if len(ignorePattern) > 0 {
m := gitignore.NewMatcher(ignorePattern)
matchPath := strings.Split(path, string(os.PathSeparator))
if m.Match(matchPath, true) {
// ignore
return false, h, nil
}
}
h, err = w.copyFileToStorage(path)
if err != nil {
if os.IsNotExist(err) {
added = true
h, err = w.deleteFromIndex(idx, path)
}
return
}
if err := w.addOrUpdateFileToIndex(idx, path, h); err != nil {
return false, h, err
}
return true, h, err
}
func (w *Worktree) copyFileToStorage(path string) (hash plumbing.Hash, err error) {
fi, err := w.Filesystem.Lstat(path)
if err != nil {
return plumbing.ZeroHash, err
}
obj := w.r.Storer.NewEncodedObject()
obj.SetType(plumbing.BlobObject)
obj.SetSize(fi.Size())
writer, err := obj.Writer()
if err != nil {
return plumbing.ZeroHash, err
}
defer ioutil.CheckClose(writer, &err)
if fi.Mode()&os.ModeSymlink != 0 {
err = w.fillEncodedObjectFromSymlink(writer, path, fi)
} else {
err = w.fillEncodedObjectFromFile(writer, path, fi)
}
if err != nil {
return plumbing.ZeroHash, err
}
return w.r.Storer.SetEncodedObject(obj)
}
func (w *Worktree) fillEncodedObjectFromFile(dst io.Writer, path string, _ os.FileInfo) (err error) {
src, err := w.Filesystem.Open(path)
if err != nil {
return err
}
defer ioutil.CheckClose(src, &err)
if _, err := io.Copy(dst, src); err != nil {
return err
}
return err
}
func (w *Worktree) fillEncodedObjectFromSymlink(dst io.Writer, path string, _ os.FileInfo) error {
target, err := w.Filesystem.Readlink(path)
if err != nil {
return err
}
_, err = dst.Write([]byte(target))
return err
}
func (w *Worktree) addOrUpdateFileToIndex(idx *index.Index, filename string, h plumbing.Hash) error {
e, err := idx.Entry(filename)
if err != nil && err != index.ErrEntryNotFound {
return err
}
if err == index.ErrEntryNotFound {
return w.doAddFileToIndex(idx, filename, h)
}
return w.doUpdateFileToIndex(e, filename, h)
}
func (w *Worktree) doAddFileToIndex(idx *index.Index, filename string, h plumbing.Hash) error {
return w.doUpdateFileToIndex(idx.Add(filename), filename, h)
}
func (w *Worktree) doUpdateFileToIndex(e *index.Entry, filename string, h plumbing.Hash) error {
info, err := w.Filesystem.Lstat(filename)
if err != nil {
return err
}
e.Hash = h
e.ModifiedAt = info.ModTime()
e.Mode, err = filemode.NewFromOSFileMode(info.Mode())
if err != nil {
return err
}
// The entry size must always reflect the current state, otherwise
// it will cause go-git's Worktree.Status() to divert from "git status".
// The size of a symlink is the length of the path to the target.
// The size of Regular and Executable files is the size of the files.
e.Size = uint32(info.Size())
fillSystemInfo(e, info.Sys())
return nil
}
// Remove removes files from the working tree and from the index.
func (w *Worktree) Remove(path string) (plumbing.Hash, error) {
// TODO(mcuadros): remove plumbing.Hash from signature at v5.
idx, err := w.r.Storer.Index()
if err != nil {
return plumbing.ZeroHash, err
}
var h plumbing.Hash
fi, err := w.Filesystem.Lstat(path)
if err != nil || !fi.IsDir() {
h, err = w.doRemoveFile(idx, path)
} else {
_, err = w.doRemoveDirectory(idx, path)
}
if err != nil {
return h, err
}
return h, w.r.Storer.SetIndex(idx)
}
func (w *Worktree) doRemoveDirectory(idx *index.Index, directory string) (removed bool, err error) {
files, err := w.Filesystem.ReadDir(directory)
if err != nil {
return false, err
}
for _, file := range files {
name := path.Join(directory, file.Name())
var r bool
if file.IsDir() {
r, err = w.doRemoveDirectory(idx, name)
} else {
_, err = w.doRemoveFile(idx, name)
if err == index.ErrEntryNotFound {
err = nil
}
}
if err != nil {
return
}
if !removed && r {
removed = true
}
}
err = w.removeEmptyDirectory(directory)
return
}
func (w *Worktree) removeEmptyDirectory(path string) error {
files, err := w.Filesystem.ReadDir(path)
if err != nil {
return err
}
if len(files) != 0 {
return nil
}
return w.Filesystem.Remove(path)
}
func (w *Worktree) doRemoveFile(idx *index.Index, path string) (plumbing.Hash, error) {
hash, err := w.deleteFromIndex(idx, path)
if err != nil {
return plumbing.ZeroHash, err
}
return hash, w.deleteFromFilesystem(path)
}
func (w *Worktree) deleteFromIndex(idx *index.Index, path string) (plumbing.Hash, error) {
e, err := idx.Remove(path)
if err != nil {
return plumbing.ZeroHash, err
}
return e.Hash, nil
}
func (w *Worktree) deleteFromFilesystem(path string) error {
err := w.Filesystem.Remove(path)
if os.IsNotExist(err) {
return nil
}
return err
}
// RemoveGlob removes all paths, matching pattern, from the index. If pattern
// matches a directory path, all directory contents are removed from the index
// recursively.
func (w *Worktree) RemoveGlob(pattern string) error {
idx, err := w.r.Storer.Index()
if err != nil {
return err
}
entries, err := idx.Glob(pattern)
if err != nil {
return err
}
for _, e := range entries {
file := filepath.FromSlash(e.Name)
if _, err := w.Filesystem.Lstat(file); err != nil && !os.IsNotExist(err) {
return err
}
if _, err := w.doRemoveFile(idx, file); err != nil {
return err
}
dir, _ := filepath.Split(file)
if err := w.removeEmptyDirectory(dir); err != nil {
return err
}
}
return w.r.Storer.SetIndex(idx)
}
// Move moves or rename a file in the worktree and the index, directories are
// not supported.
func (w *Worktree) Move(from, to string) (plumbing.Hash, error) {
// TODO(mcuadros): support directories and/or implement support for glob
if _, err := w.Filesystem.Lstat(from); err != nil {
return plumbing.ZeroHash, err
}
if _, err := w.Filesystem.Lstat(to); err == nil {
return plumbing.ZeroHash, ErrDestinationExists
}
idx, err := w.r.Storer.Index()
if err != nil {
return plumbing.ZeroHash, err
}
hash, err := w.deleteFromIndex(idx, from)
if err != nil {
return plumbing.ZeroHash, err
}
if err := w.Filesystem.Rename(from, to); err != nil {
return hash, err
}
if err := w.addOrUpdateFileToIndex(idx, to, hash); err != nil {
return hash, err
}
return hash, w.r.Storer.SetIndex(idx)
}
go-git-5.13.2/worktree_status_test.go 0000664 0000000 0000000 00000004611 14744245500 0017632 0 ustar 00root root 0000000 0000000 package git
import (
"os"
"path/filepath"
"strings"
"testing"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// For additional context: #1159.
func TestIndexEntrySizeUpdatedForNonRegularFiles(t *testing.T) {
w := osfs.New(t.TempDir(), osfs.WithBoundOS())
dot, err := w.Chroot(GitDirName)
require.NoError(t, err)
s := filesystem.NewStorage(dot, cache.NewObjectLRUDefault())
r, err := Init(s, w)
require.NoError(t, err)
require.NotNil(t, r)
wt, err := r.Worktree()
require.NoError(t, err)
require.NotNil(t, wt)
file := "LICENSE"
f, err := w.OpenFile(file, os.O_CREATE|os.O_WRONLY, 0o666)
require.NoError(t, err)
require.NotNil(t, f)
content := []byte(strings.Repeat("a\n", 1000))
_, err = f.Write(content)
require.NoError(t, err)
err = f.Close()
require.NoError(t, err)
_, err = wt.Add(file)
require.NoError(t, err)
_, err = wt.Commit("add file", &CommitOptions{})
require.NoError(t, err)
st, err := wt.StatusWithOptions(StatusOptions{Strategy: Preload})
require.NoError(t, err)
assert.Equal(t,
&FileStatus{Worktree: Unmodified, Staging: Unmodified},
st.File(file))
// Make the file not regular. The same would apply to a transition
// from regular file to symlink.
err = os.Chmod(filepath.Join(w.Root(), file), 0o777)
require.NoError(t, err)
f, err = w.OpenFile(file, os.O_APPEND|os.O_RDWR, 0o777)
require.NoError(t, err)
require.NotNil(t, f)
_, err = f.Write([]byte("\n\n"))
require.NoError(t, err)
err = f.Close()
require.NoError(t, err)
_, err = wt.Add(file)
assert.NoError(t, err)
// go-git's Status diverges from "git status", so this check does not
// fail, even when the issue is present. As at this point "git status"
// reports the unstaged file was modified while "git diff" would return
// empty, as the files are the same but the index has the incorrect file
// size.
st, err = wt.StatusWithOptions(StatusOptions{Strategy: Preload})
assert.NoError(t, err)
assert.Equal(t,
&FileStatus{Worktree: Unmodified, Staging: Modified},
st.File(file))
idx, err := wt.r.Storer.Index()
assert.NoError(t, err)
require.NotNil(t, idx)
require.Len(t, idx.Entries, 1)
// Check whether the index was updated with the two new line breaks.
assert.Equal(t, uint32(len(content)+2), idx.Entries[0].Size)
}
go-git-5.13.2/worktree_test.go 0000664 0000000 0000000 00000245364 14744245500 0016243 0 ustar 00root root 0000000 0000000 package git
import (
"bytes"
"context"
"errors"
"io"
"os"
"path/filepath"
"regexp"
"runtime"
"strings"
"testing"
"time"
fixtures "github.com/go-git/go-git-fixtures/v4"
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/cache"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/plumbing/format/gitignore"
"github.com/go-git/go-git/v5/plumbing/format/index"
"github.com/go-git/go-git/v5/plumbing/object"
"github.com/go-git/go-git/v5/storage/filesystem"
"github.com/go-git/go-git/v5/storage/memory"
"github.com/stretchr/testify/assert"
"github.com/go-git/go-billy/v5"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-billy/v5/osfs"
"github.com/go-git/go-billy/v5/util"
"golang.org/x/text/unicode/norm"
. "gopkg.in/check.v1"
)
func defaultTestCommitOptions() *CommitOptions {
return &CommitOptions{
Author: &object.Signature{Name: "testuser", Email: "testemail"},
}
}
type WorktreeSuite struct {
BaseSuite
}
var _ = Suite(&WorktreeSuite{})
func (s *WorktreeSuite) SetUpTest(c *C) {
f := fixtures.Basic().One()
s.Repository = s.NewRepositoryWithEmptyWorktree(f)
}
func (s *WorktreeSuite) TestPullCheckout(c *C) {
fs := memfs.New()
r, _ := Init(memory.NewStorage(), fs)
r.CreateRemote(&config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{s.GetBasicLocalRepositoryURL()},
})
w, err := r.Worktree()
c.Assert(err, IsNil)
err = w.Pull(&PullOptions{})
c.Assert(err, IsNil)
fi, err := fs.ReadDir("")
c.Assert(err, IsNil)
c.Assert(fi, HasLen, 8)
}
func (s *WorktreeSuite) TestPullFastForward(c *C) {
url := c.MkDir()
path := fixtures.Basic().ByTag("worktree").One().Worktree().Root()
server, err := PlainClone(url, false, &CloneOptions{
URL: path,
})
c.Assert(err, IsNil)
dir := c.MkDir()
r, err := PlainClone(dir, false, &CloneOptions{
URL: url,
})
c.Assert(err, IsNil)
w, err := server.Worktree()
c.Assert(err, IsNil)
err = os.WriteFile(filepath.Join(url, "foo"), []byte("foo"), 0755)
c.Assert(err, IsNil)
w.Add("foo")
hash, err := w.Commit("foo", &CommitOptions{Author: defaultSignature()})
c.Assert(err, IsNil)
w, err = r.Worktree()
c.Assert(err, IsNil)
err = w.Pull(&PullOptions{})
c.Assert(err, IsNil)
head, err := r.Head()
c.Assert(err, IsNil)
c.Assert(head.Hash(), Equals, hash)
}
func (s *WorktreeSuite) TestPullNonFastForward(c *C) {
url := c.MkDir()
path := fixtures.Basic().ByTag("worktree").One().Worktree().Root()
server, err := PlainClone(url, false, &CloneOptions{
URL: path,
})
c.Assert(err, IsNil)
dir := c.MkDir()
r, err := PlainClone(dir, false, &CloneOptions{
URL: url,
})
c.Assert(err, IsNil)
w, err := server.Worktree()
c.Assert(err, IsNil)
err = os.WriteFile(filepath.Join(url, "foo"), []byte("foo"), 0755)
c.Assert(err, IsNil)
w.Add("foo")
_, err = w.Commit("foo", &CommitOptions{Author: defaultSignature()})
c.Assert(err, IsNil)
w, err = r.Worktree()
c.Assert(err, IsNil)
err = os.WriteFile(filepath.Join(dir, "bar"), []byte("bar"), 0755)
c.Assert(err, IsNil)
w.Add("bar")
_, err = w.Commit("bar", &CommitOptions{Author: defaultSignature()})
c.Assert(err, IsNil)
err = w.Pull(&PullOptions{})
c.Assert(err, Equals, ErrNonFastForwardUpdate)
}
func (s *WorktreeSuite) TestPullUpdateReferencesIfNeeded(c *C) {
r, _ := Init(memory.NewStorage(), memfs.New())
r.CreateRemote(&config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{s.GetBasicLocalRepositoryURL()},
})
err := r.Fetch(&FetchOptions{})
c.Assert(err, IsNil)
_, err = r.Reference("refs/heads/master", false)
c.Assert(err, NotNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
err = w.Pull(&PullOptions{})
c.Assert(err, IsNil)
head, err := r.Reference(plumbing.HEAD, true)
c.Assert(err, IsNil)
c.Assert(head.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
branch, err := r.Reference("refs/heads/master", false)
c.Assert(err, IsNil)
c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
err = w.Pull(&PullOptions{})
c.Assert(err, Equals, NoErrAlreadyUpToDate)
}
func (s *WorktreeSuite) TestPullInSingleBranch(c *C) {
r, _ := Init(memory.NewStorage(), memfs.New())
err := r.clone(context.Background(), &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
SingleBranch: true,
})
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
err = w.Pull(&PullOptions{})
c.Assert(err, Equals, NoErrAlreadyUpToDate)
branch, err := r.Reference("refs/heads/master", false)
c.Assert(err, IsNil)
c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
_, err = r.Reference("refs/remotes/foo/branch", false)
c.Assert(err, NotNil)
storage := r.Storer.(*memory.Storage)
c.Assert(storage.Objects, HasLen, 28)
}
func (s *WorktreeSuite) TestPullProgress(c *C) {
r, _ := Init(memory.NewStorage(), memfs.New())
r.CreateRemote(&config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{s.GetBasicLocalRepositoryURL()},
})
w, err := r.Worktree()
c.Assert(err, IsNil)
buf := bytes.NewBuffer(nil)
err = w.Pull(&PullOptions{
Progress: buf,
})
c.Assert(err, IsNil)
c.Assert(buf.Len(), Not(Equals), 0)
}
func (s *WorktreeSuite) TestPullProgressWithRecursion(c *C) {
if testing.Short() {
c.Skip("skipping test in short mode.")
}
path := fixtures.ByTag("submodule").One().Worktree().Root()
dir := c.MkDir()
r, _ := PlainInit(dir, false)
r.CreateRemote(&config.RemoteConfig{
Name: DefaultRemoteName,
URLs: []string{path},
})
w, err := r.Worktree()
c.Assert(err, IsNil)
err = w.Pull(&PullOptions{
RecurseSubmodules: DefaultSubmoduleRecursionDepth,
})
c.Assert(err, IsNil)
cfg, err := r.Config()
c.Assert(err, IsNil)
c.Assert(cfg.Submodules, HasLen, 2)
}
func (s *RepositorySuite) TestPullAdd(c *C) {
path := fixtures.Basic().ByTag("worktree").One().Worktree().Root()
r, err := Clone(memory.NewStorage(), memfs.New(), &CloneOptions{
URL: filepath.Join(path, ".git"),
})
c.Assert(err, IsNil)
storage := r.Storer.(*memory.Storage)
c.Assert(storage.Objects, HasLen, 28)
branch, err := r.Reference("refs/heads/master", false)
c.Assert(err, IsNil)
c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
ExecuteOnPath(c, path,
"touch foo",
"git add foo",
"git commit --no-gpg-sign -m foo foo",
)
w, err := r.Worktree()
c.Assert(err, IsNil)
err = w.Pull(&PullOptions{RemoteName: "origin"})
c.Assert(err, IsNil)
// the commit command has introduced a new commit, tree and blob
c.Assert(storage.Objects, HasLen, 31)
branch, err = r.Reference("refs/heads/master", false)
c.Assert(err, IsNil)
c.Assert(branch.Hash().String(), Not(Equals), "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
}
func (s *WorktreeSuite) TestPullAlreadyUptodate(c *C) {
path := fixtures.Basic().ByTag("worktree").One().Worktree().Root()
fs := memfs.New()
r, err := Clone(memory.NewStorage(), fs, &CloneOptions{
URL: filepath.Join(path, ".git"),
})
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
err = util.WriteFile(fs, "bar", []byte("bar"), 0755)
c.Assert(err, IsNil)
w.Add("bar")
_, err = w.Commit("bar", &CommitOptions{Author: defaultSignature()})
c.Assert(err, IsNil)
err = w.Pull(&PullOptions{})
c.Assert(err, Equals, NoErrAlreadyUpToDate)
}
func (s *WorktreeSuite) TestPullDepth(c *C) {
r, err := Clone(memory.NewStorage(), memfs.New(), &CloneOptions{
URL: fixtures.Basic().One().URL,
Depth: 1,
})
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
err = w.Pull(&PullOptions{})
c.Assert(err, Equals, nil)
}
func (s *WorktreeSuite) TestPullAfterShallowClone(c *C) {
tempDir := c.MkDir()
remoteURL := filepath.Join(tempDir, "remote")
repoDir := filepath.Join(tempDir, "repo")
remote, err := PlainInit(remoteURL, false)
c.Assert(err, IsNil)
c.Assert(remote, NotNil)
_ = CommitNewFile(c, remote, "File1")
_ = CommitNewFile(c, remote, "File2")
repo, err := PlainClone(repoDir, false, &CloneOptions{
URL: remoteURL,
Depth: 1,
Tags: NoTags,
SingleBranch: true,
ReferenceName: "master",
})
c.Assert(err, IsNil)
_ = CommitNewFile(c, remote, "File3")
_ = CommitNewFile(c, remote, "File4")
w, err := repo.Worktree()
c.Assert(err, IsNil)
err = w.Pull(&PullOptions{
RemoteName: DefaultRemoteName,
SingleBranch: true,
ReferenceName: plumbing.NewBranchReferenceName("master"),
})
c.Assert(err, IsNil)
}
func (s *WorktreeSuite) TestCheckout(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{
Force: true,
})
c.Assert(err, IsNil)
entries, err := fs.ReadDir("/")
c.Assert(err, IsNil)
c.Assert(entries, HasLen, 8)
ch, err := fs.Open("CHANGELOG")
c.Assert(err, IsNil)
content, err := io.ReadAll(ch)
c.Assert(err, IsNil)
c.Assert(string(content), Equals, "Initial changelog\n")
idx, err := s.Repository.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
}
func (s *WorktreeSuite) TestCheckoutForce(c *C) {
w := &Worktree{
r: s.Repository,
Filesystem: memfs.New(),
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
w.Filesystem = memfs.New()
err = w.Checkout(&CheckoutOptions{
Force: true,
})
c.Assert(err, IsNil)
entries, err := w.Filesystem.ReadDir("/")
c.Assert(err, IsNil)
c.Assert(entries, HasLen, 8)
}
func (s *WorktreeSuite) TestCheckoutKeep(c *C) {
w := &Worktree{
r: s.Repository,
Filesystem: memfs.New(),
}
err := w.Checkout(&CheckoutOptions{
Force: true,
})
c.Assert(err, IsNil)
// Create a new branch and create a new file.
err = w.Checkout(&CheckoutOptions{
Branch: plumbing.NewBranchReferenceName("new-branch"),
Create: true,
})
c.Assert(err, IsNil)
w.Filesystem = memfs.New()
f, err := w.Filesystem.Create("new-file.txt")
c.Assert(err, IsNil)
_, err = f.Write([]byte("DUMMY"))
c.Assert(err, IsNil)
c.Assert(f.Close(), IsNil)
// Add the file to staging.
_, err = w.Add("new-file.txt")
c.Assert(err, IsNil)
// Switch branch to master, and verify that the new file was kept in staging.
err = w.Checkout(&CheckoutOptions{
Keep: true,
})
c.Assert(err, IsNil)
fi, err := w.Filesystem.Stat("new-file.txt")
c.Assert(err, IsNil)
c.Assert(fi.Size(), Equals, int64(5))
}
func (s *WorktreeSuite) TestCheckoutSymlink(c *C) {
if runtime.GOOS == "windows" {
c.Skip("git doesn't support symlinks by default in windows")
}
dir := c.MkDir()
r, err := PlainInit(dir, false)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
w.Filesystem.Symlink("not-exists", "bar")
w.Add("bar")
w.Commit("foo", &CommitOptions{Author: defaultSignature()})
r.Storer.SetIndex(&index.Index{Version: 2})
w.Filesystem = osfs.New(filepath.Join(dir, "worktree-empty"))
err = w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
target, err := w.Filesystem.Readlink("bar")
c.Assert(target, Equals, "not-exists")
c.Assert(err, IsNil)
}
func (s *WorktreeSuite) TestCheckoutSparse(c *C) {
fs := memfs.New()
r, err := Clone(memory.NewStorage(), fs, &CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
NoCheckout: true,
})
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
sparseCheckoutDirectories := []string{"go", "json", "php"}
c.Assert(w.Checkout(&CheckoutOptions{
SparseCheckoutDirectories: sparseCheckoutDirectories,
}), IsNil)
fis, err := fs.ReadDir("/")
c.Assert(err, IsNil)
for _, fi := range fis {
c.Assert(fi.IsDir(), Equals, true)
var oneOfSparseCheckoutDirs bool
for _, sparseCheckoutDirectory := range sparseCheckoutDirectories {
if strings.HasPrefix(fi.Name(), sparseCheckoutDirectory) {
oneOfSparseCheckoutDirs = true
}
}
c.Assert(oneOfSparseCheckoutDirs, Equals, true)
}
}
func (s *WorktreeSuite) TestFilenameNormalization(c *C) {
if runtime.GOOS == "windows" {
c.Skip("windows paths may contain non utf-8 sequences")
}
url := c.MkDir()
path := fixtures.Basic().ByTag("worktree").One().Worktree().Root()
server, err := PlainClone(url, false, &CloneOptions{
URL: path,
})
c.Assert(err, IsNil)
filename := "페"
w, err := server.Worktree()
c.Assert(err, IsNil)
writeFile := func(path string) {
err := util.WriteFile(w.Filesystem, path, []byte("foo"), 0755)
c.Assert(err, IsNil)
}
writeFile(filename)
origHash, err := w.Add(filename)
c.Assert(err, IsNil)
_, err = w.Commit("foo", &CommitOptions{Author: defaultSignature()})
c.Assert(err, IsNil)
r, err := Clone(memory.NewStorage(), memfs.New(), &CloneOptions{
URL: url,
})
c.Assert(err, IsNil)
w, err = r.Worktree()
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
err = w.Filesystem.Remove(filename)
c.Assert(err, IsNil)
modFilename := norm.NFKD.String(filename)
writeFile(modFilename)
_, err = w.Add(filename)
c.Assert(err, IsNil)
modHash, err := w.Add(modFilename)
c.Assert(err, IsNil)
// At this point we've got two files with the same content.
// Hence their hashes must be the same.
c.Assert(origHash == modHash, Equals, true)
status, err = w.Status()
c.Assert(err, IsNil)
// However, their names are different and the work tree is still dirty.
c.Assert(status.IsClean(), Equals, false)
// Revert back the deletion of the first file.
writeFile(filename)
_, err = w.Add(filename)
c.Assert(err, IsNil)
status, err = w.Status()
c.Assert(err, IsNil)
// Still dirty - the second file is added.
c.Assert(status.IsClean(), Equals, false)
_, err = w.Remove(modFilename)
c.Assert(err, IsNil)
status, err = w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
func (s *WorktreeSuite) TestCheckoutSubmodule(c *C) {
url := "https://github.com/git-fixtures/submodule.git"
r := s.NewRepositoryWithEmptyWorktree(fixtures.ByURL(url).One())
w, err := r.Worktree()
c.Assert(err, IsNil)
err = w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
func (s *WorktreeSuite) TestCheckoutSubmoduleInitialized(c *C) {
url := "https://github.com/git-fixtures/submodule.git"
r := s.NewRepository(fixtures.ByURL(url).One())
w, err := r.Worktree()
c.Assert(err, IsNil)
sub, err := w.Submodules()
c.Assert(err, IsNil)
err = sub.Update(&SubmoduleUpdateOptions{Init: true})
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
func (s *WorktreeSuite) TestCheckoutRelativePathSubmoduleInitialized(c *C) {
url := "https://github.com/git-fixtures/submodule.git"
r := s.NewRepository(fixtures.ByURL(url).One())
// modify the .gitmodules from original one
file, err := r.wt.OpenFile(".gitmodules", os.O_WRONLY|os.O_TRUNC, 0666)
c.Assert(err, IsNil)
n, err := io.WriteString(file, `[submodule "basic"]
path = basic
url = ../basic.git
[submodule "itself"]
path = itself
url = ../submodule.git`)
c.Assert(err, IsNil)
c.Assert(n, Not(Equals), 0)
w, err := r.Worktree()
c.Assert(err, IsNil)
w.Add(".gitmodules")
w.Commit("test", &CommitOptions{})
// test submodule path
modules, err := w.readGitmodulesFile()
c.Assert(err, IsNil)
c.Assert(modules.Submodules["basic"].URL, Equals, "../basic.git")
c.Assert(modules.Submodules["itself"].URL, Equals, "../submodule.git")
basicSubmodule, err := w.Submodule("basic")
c.Assert(err, IsNil)
basicRepo, err := basicSubmodule.Repository()
c.Assert(err, IsNil)
basicRemotes, err := basicRepo.Remotes()
c.Assert(err, IsNil)
c.Assert(basicRemotes[0].Config().URLs[0], Equals, "https://github.com/git-fixtures/basic.git")
itselfSubmodule, err := w.Submodule("itself")
c.Assert(err, IsNil)
itselfRepo, err := itselfSubmodule.Repository()
c.Assert(err, IsNil)
itselfRemotes, err := itselfRepo.Remotes()
c.Assert(err, IsNil)
c.Assert(itselfRemotes[0].Config().URLs[0], Equals, "https://github.com/git-fixtures/submodule.git")
sub, err := w.Submodules()
c.Assert(err, IsNil)
err = sub.Update(&SubmoduleUpdateOptions{Init: true, RecurseSubmodules: DefaultSubmoduleRecursionDepth})
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
func (s *WorktreeSuite) TestCheckoutIndexMem(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
idx, err := s.Repository.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
c.Assert(idx.Entries[0].Hash.String(), Equals, "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88")
c.Assert(idx.Entries[0].Name, Equals, ".gitignore")
c.Assert(idx.Entries[0].Mode, Equals, filemode.Regular)
c.Assert(idx.Entries[0].ModifiedAt.IsZero(), Equals, false)
c.Assert(idx.Entries[0].Size, Equals, uint32(189))
// ctime, dev, inode, uid and gid are not supported on memfs fs
c.Assert(idx.Entries[0].CreatedAt.IsZero(), Equals, true)
c.Assert(idx.Entries[0].Dev, Equals, uint32(0))
c.Assert(idx.Entries[0].Inode, Equals, uint32(0))
c.Assert(idx.Entries[0].UID, Equals, uint32(0))
c.Assert(idx.Entries[0].GID, Equals, uint32(0))
}
func (s *WorktreeSuite) TestCheckoutIndexOS(c *C) {
fs := s.TemporalFilesystem(c)
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
idx, err := s.Repository.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
c.Assert(idx.Entries[0].Hash.String(), Equals, "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88")
c.Assert(idx.Entries[0].Name, Equals, ".gitignore")
c.Assert(idx.Entries[0].Mode, Equals, filemode.Regular)
c.Assert(idx.Entries[0].ModifiedAt.IsZero(), Equals, false)
c.Assert(idx.Entries[0].Size, Equals, uint32(189))
c.Assert(idx.Entries[0].CreatedAt.IsZero(), Equals, false)
if runtime.GOOS != "windows" {
c.Assert(idx.Entries[0].Dev, Not(Equals), uint32(0))
c.Assert(idx.Entries[0].Inode, Not(Equals), uint32(0))
c.Assert(idx.Entries[0].UID, Not(Equals), uint32(0))
c.Assert(idx.Entries[0].GID, Not(Equals), uint32(0))
}
}
func (s *WorktreeSuite) TestCheckoutBranch(c *C) {
w := &Worktree{
r: s.Repository,
Filesystem: memfs.New(),
}
err := w.Checkout(&CheckoutOptions{
Branch: "refs/heads/branch",
})
c.Assert(err, IsNil)
head, err := w.r.Head()
c.Assert(err, IsNil)
c.Assert(head.Name().String(), Equals, "refs/heads/branch")
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
func (s *WorktreeSuite) TestCheckoutCreateWithHash(c *C) {
w := &Worktree{
r: s.Repository,
Filesystem: memfs.New(),
}
err := w.Checkout(&CheckoutOptions{
Create: true,
Branch: "refs/heads/foo",
Hash: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"),
})
c.Assert(err, IsNil)
head, err := w.r.Head()
c.Assert(err, IsNil)
c.Assert(head.Name().String(), Equals, "refs/heads/foo")
c.Assert(head.Hash(), Equals, plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"))
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
func (s *WorktreeSuite) TestCheckoutCreate(c *C) {
w := &Worktree{
r: s.Repository,
Filesystem: memfs.New(),
}
err := w.Checkout(&CheckoutOptions{
Create: true,
Branch: "refs/heads/foo",
})
c.Assert(err, IsNil)
head, err := w.r.Head()
c.Assert(err, IsNil)
c.Assert(head.Name().String(), Equals, "refs/heads/foo")
c.Assert(head.Hash(), Equals, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
func (s *WorktreeSuite) TestCheckoutBranchAndHash(c *C) {
w := &Worktree{
r: s.Repository,
Filesystem: memfs.New(),
}
err := w.Checkout(&CheckoutOptions{
Branch: "refs/heads/foo",
Hash: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"),
})
c.Assert(err, Equals, ErrBranchHashExclusive)
}
func (s *WorktreeSuite) TestCheckoutCreateMissingBranch(c *C) {
w := &Worktree{
r: s.Repository,
Filesystem: memfs.New(),
}
err := w.Checkout(&CheckoutOptions{
Create: true,
})
c.Assert(err, Equals, ErrCreateRequiresBranch)
}
func (s *WorktreeSuite) TestCheckoutCreateInvalidBranch(c *C) {
w := &Worktree{
r: s.Repository,
Filesystem: memfs.New(),
}
for _, name := range []plumbing.ReferenceName{
"foo",
"-",
"-foo",
"refs/heads//",
"refs/heads/..",
"refs/heads/a..b",
"refs/heads/.",
} {
err := w.Checkout(&CheckoutOptions{
Create: true,
Branch: name,
})
c.Assert(err, Equals, plumbing.ErrInvalidReferenceName)
}
}
func (s *WorktreeSuite) TestCheckoutTag(c *C) {
f := fixtures.ByTag("tags").One()
r := s.NewRepositoryWithEmptyWorktree(f)
w, err := r.Worktree()
c.Assert(err, IsNil)
err = w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
head, err := w.r.Head()
c.Assert(err, IsNil)
c.Assert(head.Name().String(), Equals, "refs/heads/master")
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
err = w.Checkout(&CheckoutOptions{Branch: "refs/tags/lightweight-tag"})
c.Assert(err, IsNil)
head, err = w.r.Head()
c.Assert(err, IsNil)
c.Assert(head.Name().String(), Equals, "HEAD")
c.Assert(head.Hash().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f")
err = w.Checkout(&CheckoutOptions{Branch: "refs/tags/commit-tag"})
c.Assert(err, IsNil)
head, err = w.r.Head()
c.Assert(err, IsNil)
c.Assert(head.Name().String(), Equals, "HEAD")
c.Assert(head.Hash().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f")
err = w.Checkout(&CheckoutOptions{Branch: "refs/tags/tree-tag"})
c.Assert(err, NotNil)
head, err = w.r.Head()
c.Assert(err, IsNil)
c.Assert(head.Name().String(), Equals, "HEAD")
}
func (s *WorktreeSuite) TestCheckoutTagHash(c *C) {
f := fixtures.ByTag("tags").One()
r := s.NewRepositoryWithEmptyWorktree(f)
w, err := r.Worktree()
c.Assert(err, IsNil)
for _, hash := range []string{
"b742a2a9fa0afcfa9a6fad080980fbc26b007c69", // annotated tag
"ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc", // commit tag
"f7b877701fbf855b44c0a9e86f3fdce2c298b07f", // lightweight tag
} {
err = w.Checkout(&CheckoutOptions{
Hash: plumbing.NewHash(hash),
})
c.Assert(err, IsNil)
head, err := w.r.Head()
c.Assert(err, IsNil)
c.Assert(head.Name().String(), Equals, "HEAD")
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
for _, hash := range []string{
"fe6cb94756faa81e5ed9240f9191b833db5f40ae", // blob tag
"152175bf7e5580299fa1f0ba41ef6474cc043b70", // tree tag
} {
err = w.Checkout(&CheckoutOptions{
Hash: plumbing.NewHash(hash),
})
c.Assert(err, NotNil)
}
}
func (s *WorktreeSuite) TestCheckoutBisect(c *C) {
if testing.Short() {
c.Skip("skipping test in short mode.")
}
s.testCheckoutBisect(c, "https://github.com/src-d/go-git.git")
}
func (s *WorktreeSuite) TestCheckoutBisectSubmodules(c *C) {
s.testCheckoutBisect(c, "https://github.com/git-fixtures/submodule.git")
}
// TestCheckoutBisect simulates a git bisect going through the git history and
// checking every commit over the previous commit
func (s *WorktreeSuite) testCheckoutBisect(c *C, url string) {
f := fixtures.ByURL(url).One()
r := s.NewRepositoryWithEmptyWorktree(f)
w, err := r.Worktree()
c.Assert(err, IsNil)
iter, err := w.r.Log(&LogOptions{})
c.Assert(err, IsNil)
iter.ForEach(func(commit *object.Commit) error {
err := w.Checkout(&CheckoutOptions{Hash: commit.Hash})
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
return nil
})
}
func (s *WorktreeSuite) TestStatus(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, false)
c.Assert(status, HasLen, 9)
}
func (s *WorktreeSuite) TestStatusEmpty(c *C) {
fs := memfs.New()
storage := memory.NewStorage()
r, err := Init(storage, fs)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
c.Assert(status, NotNil)
}
func (s *WorktreeSuite) TestStatusCheckedInBeforeIgnored(c *C) {
fs := memfs.New()
storage := memory.NewStorage()
r, err := Init(storage, fs)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
err = util.WriteFile(fs, "fileToIgnore", []byte("Initial data"), 0755)
c.Assert(err, IsNil)
_, err = w.Add("fileToIgnore")
c.Assert(err, IsNil)
_, err = w.Commit("Added file that will be ignored later", defaultTestCommitOptions())
c.Assert(err, IsNil)
err = util.WriteFile(fs, ".gitignore", []byte("fileToIgnore\nsecondIgnoredFile"), 0755)
c.Assert(err, IsNil)
_, err = w.Add(".gitignore")
c.Assert(err, IsNil)
_, err = w.Commit("Added .gitignore", defaultTestCommitOptions())
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
c.Assert(status, NotNil)
err = util.WriteFile(fs, "secondIgnoredFile", []byte("Should be completely ignored"), 0755)
c.Assert(err, IsNil)
status = nil
status, err = w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
c.Assert(status, NotNil)
err = util.WriteFile(fs, "fileToIgnore", []byte("Updated data"), 0755)
c.Assert(err, IsNil)
status = nil
status, err = w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, false)
c.Assert(status, NotNil)
}
func (s *WorktreeSuite) TestStatusEmptyDirty(c *C) {
fs := memfs.New()
err := util.WriteFile(fs, "foo", []byte("foo"), 0755)
c.Assert(err, IsNil)
storage := memory.NewStorage()
r, err := Init(storage, fs)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, false)
c.Assert(status, HasLen, 1)
}
func (s *WorktreeSuite) TestStatusUnmodified(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
status, err := w.StatusWithOptions(StatusOptions{Strategy: Preload})
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
c.Assert(status.IsUntracked("LICENSE"), Equals, false)
c.Assert(status.File("LICENSE").Staging, Equals, Unmodified)
c.Assert(status.File("LICENSE").Worktree, Equals, Unmodified)
status, err = w.StatusWithOptions(StatusOptions{Strategy: Empty})
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
c.Assert(status.IsUntracked("LICENSE"), Equals, false)
c.Assert(status.File("LICENSE").Staging, Equals, Untracked)
c.Assert(status.File("LICENSE").Worktree, Equals, Untracked)
}
func (s *WorktreeSuite) TestReset(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
commit := plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
branch, err := w.r.Reference(plumbing.Master, false)
c.Assert(err, IsNil)
c.Assert(branch.Hash(), Not(Equals), commit)
err = w.Reset(&ResetOptions{Mode: MergeReset, Commit: commit})
c.Assert(err, IsNil)
branch, err = w.r.Reference(plumbing.Master, false)
c.Assert(err, IsNil)
c.Assert(branch.Hash(), Equals, commit)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
func (s *WorktreeSuite) TestResetWithUntracked(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
commit := plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
err = util.WriteFile(fs, "foo", nil, 0755)
c.Assert(err, IsNil)
err = w.Reset(&ResetOptions{Mode: MergeReset, Commit: commit})
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
func (s *WorktreeSuite) TestResetSoft(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
commit := plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
err = w.Reset(&ResetOptions{Mode: SoftReset, Commit: commit})
c.Assert(err, IsNil)
branch, err := w.r.Reference(plumbing.Master, false)
c.Assert(err, IsNil)
c.Assert(branch.Hash(), Equals, commit)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, false)
c.Assert(status.File("CHANGELOG").Staging, Equals, Added)
}
func (s *WorktreeSuite) TestResetMixed(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
commit := plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
err = w.Reset(&ResetOptions{Mode: MixedReset, Commit: commit})
c.Assert(err, IsNil)
branch, err := w.r.Reference(plumbing.Master, false)
c.Assert(err, IsNil)
c.Assert(branch.Hash(), Equals, commit)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, false)
c.Assert(status.File("CHANGELOG").Staging, Equals, Untracked)
}
func (s *WorktreeSuite) TestResetMerge(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
commitA := plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")
commitB := plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
err = w.Reset(&ResetOptions{Mode: MergeReset, Commit: commitA})
c.Assert(err, IsNil)
branch, err := w.r.Reference(plumbing.Master, false)
c.Assert(err, IsNil)
c.Assert(branch.Hash(), Equals, commitA)
f, err := fs.Create(".gitignore")
c.Assert(err, IsNil)
_, err = f.Write([]byte("foo"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
err = w.Reset(&ResetOptions{Mode: MergeReset, Commit: commitB})
c.Assert(err, Equals, ErrUnstagedChanges)
branch, err = w.r.Reference(plumbing.Master, false)
c.Assert(err, IsNil)
c.Assert(branch.Hash(), Equals, commitA)
}
func (s *WorktreeSuite) TestResetHard(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
commit := plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
f, err := fs.Create(".gitignore")
c.Assert(err, IsNil)
_, err = f.Write([]byte("foo"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
err = w.Reset(&ResetOptions{Mode: HardReset, Commit: commit})
c.Assert(err, IsNil)
branch, err := w.r.Reference(plumbing.Master, false)
c.Assert(err, IsNil)
c.Assert(branch.Hash(), Equals, commit)
}
func (s *WorktreeSuite) TestResetHardSubFolders(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
err = fs.MkdirAll("dir", os.ModePerm)
c.Assert(err, IsNil)
tf, err := fs.Create("./dir/testfile.txt")
c.Assert(err, IsNil)
_, err = tf.Write([]byte("testfile content"))
c.Assert(err, IsNil)
err = tf.Close()
c.Assert(err, IsNil)
_, err = w.Add("dir/testfile.txt")
c.Assert(err, IsNil)
_, err = w.Commit("testcommit", &CommitOptions{Author: &object.Signature{Name: "name", Email: "email"}})
c.Assert(err, IsNil)
err = fs.Remove("dir/testfile.txt")
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, false)
err = w.Reset(&ResetOptions{Files: []string{"dir/testfile.txt"}, Mode: HardReset})
c.Assert(err, IsNil)
status, err = w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
func (s *WorktreeSuite) TestResetHardWithGitIgnore(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
tf, err := fs.Create("newTestFile.txt")
c.Assert(err, IsNil)
_, err = tf.Write([]byte("testfile content"))
c.Assert(err, IsNil)
err = tf.Close()
c.Assert(err, IsNil)
_, err = w.Add("newTestFile.txt")
c.Assert(err, IsNil)
_, err = w.Commit("testcommit", &CommitOptions{Author: &object.Signature{Name: "name", Email: "email"}})
c.Assert(err, IsNil)
err = fs.Remove("newTestFile.txt")
c.Assert(err, IsNil)
f, err := fs.Create(".gitignore")
c.Assert(err, IsNil)
_, err = f.Write([]byte("foo\n"))
c.Assert(err, IsNil)
_, err = f.Write([]byte("newTestFile.txt\n"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, false)
err = w.Reset(&ResetOptions{Mode: HardReset})
c.Assert(err, IsNil)
status, err = w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
func (s *WorktreeSuite) TestResetSparsely(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
sparseResetDirs := []string{"php"}
err := w.ResetSparsely(&ResetOptions{Mode: HardReset}, sparseResetDirs)
c.Assert(err, IsNil)
files, err := fs.ReadDir("/")
c.Assert(err, IsNil)
c.Assert(files, HasLen, 1)
c.Assert(files[0].Name(), Equals, "php")
files, err = fs.ReadDir("/php")
c.Assert(err, IsNil)
c.Assert(files, HasLen, 1)
c.Assert(files[0].Name(), Equals, "crappy.php")
}
func (s *WorktreeSuite) TestStatusAfterCheckout(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, true)
}
func (s *WorktreeSuite) TestStatusModified(c *C) {
fs := s.TemporalFilesystem(c)
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
f, err := fs.Create(".gitignore")
c.Assert(err, IsNil)
_, err = f.Write([]byte("foo"))
c.Assert(err, IsNil)
err = f.Close()
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, false)
c.Assert(status.File(".gitignore").Worktree, Equals, Modified)
}
func (s *WorktreeSuite) TestStatusIgnored(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
w.Checkout(&CheckoutOptions{})
fs.MkdirAll("another", os.ModePerm)
f, _ := fs.Create("another/file")
f.Close()
fs.MkdirAll("vendor/github.com", os.ModePerm)
f, _ = fs.Create("vendor/github.com/file")
f.Close()
fs.MkdirAll("vendor/gopkg.in", os.ModePerm)
f, _ = fs.Create("vendor/gopkg.in/file")
f.Close()
status, _ := w.Status()
c.Assert(len(status), Equals, 3)
_, ok := status["another/file"]
c.Assert(ok, Equals, true)
_, ok = status["vendor/github.com/file"]
c.Assert(ok, Equals, true)
_, ok = status["vendor/gopkg.in/file"]
c.Assert(ok, Equals, true)
f, _ = fs.Create(".gitignore")
f.Write([]byte("vendor/g*/"))
f.Close()
f, _ = fs.Create("vendor/.gitignore")
f.Write([]byte("!github.com/\n"))
f.Close()
status, _ = w.Status()
c.Assert(len(status), Equals, 4)
_, ok = status[".gitignore"]
c.Assert(ok, Equals, true)
_, ok = status["another/file"]
c.Assert(ok, Equals, true)
_, ok = status["vendor/.gitignore"]
c.Assert(ok, Equals, true)
_, ok = status["vendor/github.com/file"]
c.Assert(ok, Equals, true)
}
func (s *WorktreeSuite) TestStatusUntracked(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
f, err := w.Filesystem.Create("foo")
c.Assert(err, IsNil)
c.Assert(f.Close(), IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.File("foo").Staging, Equals, Untracked)
c.Assert(status.File("foo").Worktree, Equals, Untracked)
}
func (s *WorktreeSuite) TestStatusDeleted(c *C) {
fs := s.TemporalFilesystem(c)
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
err = fs.Remove(".gitignore")
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status.IsClean(), Equals, false)
c.Assert(status.File(".gitignore").Worktree, Equals, Deleted)
}
func (s *WorktreeSuite) TestSubmodule(c *C) {
path := fixtures.ByTag("submodule").One().Worktree().Root()
r, err := PlainOpen(path)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
m, err := w.Submodule("basic")
c.Assert(err, IsNil)
c.Assert(m.Config().Name, Equals, "basic")
}
func (s *WorktreeSuite) TestSubmodules(c *C) {
path := fixtures.ByTag("submodule").One().Worktree().Root()
r, err := PlainOpen(path)
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
l, err := w.Submodules()
c.Assert(err, IsNil)
c.Assert(l, HasLen, 2)
}
func (s *WorktreeSuite) TestAddUntracked(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = util.WriteFile(w.Filesystem, "foo", []byte("FOO"), 0755)
c.Assert(err, IsNil)
hash, err := w.Add("foo")
c.Assert(hash.String(), Equals, "d96c7efbfec2814ae0301ad054dc8d9fc416c9b5")
c.Assert(err, IsNil)
idx, err = w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 10)
e, err := idx.Entry("foo")
c.Assert(err, IsNil)
c.Assert(e.Hash, Equals, hash)
c.Assert(e.Mode, Equals, filemode.Executable)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 1)
file := status.File("foo")
c.Assert(file.Staging, Equals, Added)
c.Assert(file.Worktree, Equals, Unmodified)
obj, err := w.r.Storer.EncodedObject(plumbing.BlobObject, hash)
c.Assert(err, IsNil)
c.Assert(obj, NotNil)
c.Assert(obj.Size(), Equals, int64(3))
}
func (s *WorktreeSuite) TestIgnored(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
w.Excludes = make([]gitignore.Pattern, 0)
w.Excludes = append(w.Excludes, gitignore.ParsePattern("foo", nil))
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = util.WriteFile(w.Filesystem, "foo", []byte("FOO"), 0755)
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 0)
file := status.File("foo")
c.Assert(file.Staging, Equals, Untracked)
c.Assert(file.Worktree, Equals, Untracked)
}
func (s *WorktreeSuite) TestExcludedNoGitignore(c *C) {
f := fixtures.ByTag("empty").One()
r := s.NewRepository(f)
fs := memfs.New()
w := &Worktree{
r: r,
Filesystem: fs,
}
_, err := fs.Open(".gitignore")
c.Assert(err, Equals, os.ErrNotExist)
w.Excludes = make([]gitignore.Pattern, 0)
w.Excludes = append(w.Excludes, gitignore.ParsePattern("foo", nil))
err = util.WriteFile(w.Filesystem, "foo", []byte("FOO"), 0755)
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 0)
file := status.File("foo")
c.Assert(file.Staging, Equals, Untracked)
c.Assert(file.Worktree, Equals, Untracked)
}
func (s *WorktreeSuite) TestAddModified(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = util.WriteFile(w.Filesystem, "LICENSE", []byte("FOO"), 0644)
c.Assert(err, IsNil)
hash, err := w.Add("LICENSE")
c.Assert(err, IsNil)
c.Assert(hash.String(), Equals, "d96c7efbfec2814ae0301ad054dc8d9fc416c9b5")
idx, err = w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
e, err := idx.Entry("LICENSE")
c.Assert(err, IsNil)
c.Assert(e.Hash, Equals, hash)
c.Assert(e.Mode, Equals, filemode.Regular)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 1)
file := status.File("LICENSE")
c.Assert(file.Staging, Equals, Modified)
c.Assert(file.Worktree, Equals, Unmodified)
}
func (s *WorktreeSuite) TestAddUnmodified(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
hash, err := w.Add("LICENSE")
c.Assert(hash.String(), Equals, "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f")
c.Assert(err, IsNil)
}
func (s *WorktreeSuite) TestAddRemoved(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = w.Filesystem.Remove("LICENSE")
c.Assert(err, IsNil)
hash, err := w.Add("LICENSE")
c.Assert(err, IsNil)
c.Assert(hash.String(), Equals, "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f")
e, err := idx.Entry("LICENSE")
c.Assert(err, IsNil)
c.Assert(e.Hash, Equals, hash)
c.Assert(e.Mode, Equals, filemode.Regular)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 1)
file := status.File("LICENSE")
c.Assert(file.Staging, Equals, Deleted)
}
func (s *WorktreeSuite) TestAddRemovedInDirectory(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = w.Filesystem.Remove("go/example.go")
c.Assert(err, IsNil)
err = w.Filesystem.Remove("json/short.json")
c.Assert(err, IsNil)
hash, err := w.Add("go")
c.Assert(err, IsNil)
c.Assert(hash.IsZero(), Equals, true)
e, err := idx.Entry("go/example.go")
c.Assert(err, IsNil)
c.Assert(e.Hash, Equals, plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198"))
c.Assert(e.Mode, Equals, filemode.Regular)
e, err = idx.Entry("json/short.json")
c.Assert(err, IsNil)
c.Assert(e.Hash, Equals, plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956"))
c.Assert(e.Mode, Equals, filemode.Regular)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 2)
file := status.File("go/example.go")
c.Assert(file.Staging, Equals, Deleted)
file = status.File("json/short.json")
c.Assert(file.Staging, Equals, Unmodified)
}
func (s *WorktreeSuite) TestAddRemovedInDirectoryWithTrailingSlash(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = w.Filesystem.Remove("go/example.go")
c.Assert(err, IsNil)
err = w.Filesystem.Remove("json/short.json")
c.Assert(err, IsNil)
hash, err := w.Add("go/")
c.Assert(err, IsNil)
c.Assert(hash.IsZero(), Equals, true)
e, err := idx.Entry("go/example.go")
c.Assert(err, IsNil)
c.Assert(e.Hash, Equals, plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198"))
c.Assert(e.Mode, Equals, filemode.Regular)
e, err = idx.Entry("json/short.json")
c.Assert(err, IsNil)
c.Assert(e.Hash, Equals, plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956"))
c.Assert(e.Mode, Equals, filemode.Regular)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 2)
file := status.File("go/example.go")
c.Assert(file.Staging, Equals, Deleted)
file = status.File("json/short.json")
c.Assert(file.Staging, Equals, Unmodified)
}
func (s *WorktreeSuite) TestAddRemovedInDirectoryDot(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = w.Filesystem.Remove("go/example.go")
c.Assert(err, IsNil)
err = w.Filesystem.Remove("json/short.json")
c.Assert(err, IsNil)
hash, err := w.Add(".")
c.Assert(err, IsNil)
c.Assert(hash.IsZero(), Equals, true)
e, err := idx.Entry("go/example.go")
c.Assert(err, IsNil)
c.Assert(e.Hash, Equals, plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198"))
c.Assert(e.Mode, Equals, filemode.Regular)
e, err = idx.Entry("json/short.json")
c.Assert(err, IsNil)
c.Assert(e.Hash, Equals, plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956"))
c.Assert(e.Mode, Equals, filemode.Regular)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 2)
file := status.File("go/example.go")
c.Assert(file.Staging, Equals, Deleted)
file = status.File("json/short.json")
c.Assert(file.Staging, Equals, Deleted)
}
func (s *WorktreeSuite) TestAddSymlink(c *C) {
dir := c.MkDir()
r, err := PlainInit(dir, false)
c.Assert(err, IsNil)
err = util.WriteFile(r.wt, "foo", []byte("qux"), 0644)
c.Assert(err, IsNil)
err = r.wt.Symlink("foo", "bar")
c.Assert(err, IsNil)
w, err := r.Worktree()
c.Assert(err, IsNil)
h, err := w.Add("foo")
c.Assert(err, IsNil)
c.Assert(h, Not(Equals), plumbing.NewHash("19102815663d23f8b75a47e7a01965dcdc96468c"))
h, err = w.Add("bar")
c.Assert(err, IsNil)
c.Assert(h, Equals, plumbing.NewHash("19102815663d23f8b75a47e7a01965dcdc96468c"))
obj, err := w.r.Storer.EncodedObject(plumbing.BlobObject, h)
c.Assert(err, IsNil)
c.Assert(obj, NotNil)
c.Assert(obj.Size(), Equals, int64(3))
}
func (s *WorktreeSuite) TestAddDirectory(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = util.WriteFile(w.Filesystem, "qux/foo", []byte("FOO"), 0755)
c.Assert(err, IsNil)
err = util.WriteFile(w.Filesystem, "qux/baz/bar", []byte("BAR"), 0755)
c.Assert(err, IsNil)
h, err := w.Add("qux")
c.Assert(err, IsNil)
c.Assert(h.IsZero(), Equals, true)
idx, err = w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 11)
e, err := idx.Entry("qux/foo")
c.Assert(err, IsNil)
c.Assert(e.Mode, Equals, filemode.Executable)
e, err = idx.Entry("qux/baz/bar")
c.Assert(err, IsNil)
c.Assert(e.Mode, Equals, filemode.Executable)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 2)
file := status.File("qux/foo")
c.Assert(file.Staging, Equals, Added)
c.Assert(file.Worktree, Equals, Unmodified)
file = status.File("qux/baz/bar")
c.Assert(file.Staging, Equals, Added)
c.Assert(file.Worktree, Equals, Unmodified)
}
func (s *WorktreeSuite) TestAddDirectoryErrorNotFound(c *C) {
r, _ := Init(memory.NewStorage(), memfs.New())
w, _ := r.Worktree()
h, err := w.Add("foo")
c.Assert(err, NotNil)
c.Assert(h.IsZero(), Equals, true)
}
func (s *WorktreeSuite) TestAddAll(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = util.WriteFile(w.Filesystem, "file1", []byte("file1"), 0644)
c.Assert(err, IsNil)
err = util.WriteFile(w.Filesystem, "file2", []byte("file2"), 0644)
c.Assert(err, IsNil)
err = util.WriteFile(w.Filesystem, "file3", []byte("ignore me"), 0644)
c.Assert(err, IsNil)
w.Excludes = make([]gitignore.Pattern, 0)
w.Excludes = append(w.Excludes, gitignore.ParsePattern("file3", nil))
err = w.AddWithOptions(&AddOptions{All: true})
c.Assert(err, IsNil)
idx, err = w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 11)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 2)
file1 := status.File("file1")
c.Assert(file1.Staging, Equals, Added)
file2 := status.File("file2")
c.Assert(file2.Staging, Equals, Added)
file3 := status.File("file3")
c.Assert(file3.Staging, Equals, Untracked)
c.Assert(file3.Worktree, Equals, Untracked)
}
func (s *WorktreeSuite) TestAddGlob(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = util.WriteFile(w.Filesystem, "qux/qux", []byte("QUX"), 0755)
c.Assert(err, IsNil)
err = util.WriteFile(w.Filesystem, "qux/baz", []byte("BAZ"), 0755)
c.Assert(err, IsNil)
err = util.WriteFile(w.Filesystem, "qux/bar/baz", []byte("BAZ"), 0755)
c.Assert(err, IsNil)
err = w.AddWithOptions(&AddOptions{Glob: w.Filesystem.Join("qux", "b*")})
c.Assert(err, IsNil)
idx, err = w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 11)
e, err := idx.Entry("qux/baz")
c.Assert(err, IsNil)
c.Assert(e.Mode, Equals, filemode.Executable)
e, err = idx.Entry("qux/bar/baz")
c.Assert(err, IsNil)
c.Assert(e.Mode, Equals, filemode.Executable)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 3)
file := status.File("qux/qux")
c.Assert(file.Staging, Equals, Untracked)
c.Assert(file.Worktree, Equals, Untracked)
file = status.File("qux/baz")
c.Assert(file.Staging, Equals, Added)
c.Assert(file.Worktree, Equals, Unmodified)
file = status.File("qux/bar/baz")
c.Assert(file.Staging, Equals, Added)
c.Assert(file.Worktree, Equals, Unmodified)
}
func (s *WorktreeSuite) TestAddFilenameStartingWithDot(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = util.WriteFile(w.Filesystem, "qux", []byte("QUX"), 0o755)
c.Assert(err, IsNil)
err = util.WriteFile(w.Filesystem, "baz", []byte("BAZ"), 0o755)
c.Assert(err, IsNil)
err = util.WriteFile(w.Filesystem, "foo/bar/baz", []byte("BAZ"), 0o755)
c.Assert(err, IsNil)
_, err = w.Add("./qux")
c.Assert(err, IsNil)
_, err = w.Add("./baz")
c.Assert(err, IsNil)
_, err = w.Add("foo/bar/../bar/./baz")
c.Assert(err, IsNil)
idx, err = w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 12)
e, err := idx.Entry("qux")
c.Assert(err, IsNil)
c.Assert(e.Mode, Equals, filemode.Executable)
e, err = idx.Entry("baz")
c.Assert(err, IsNil)
c.Assert(e.Mode, Equals, filemode.Executable)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 3)
file := status.File("qux")
c.Assert(file.Staging, Equals, Added)
c.Assert(file.Worktree, Equals, Unmodified)
file = status.File("baz")
c.Assert(file.Staging, Equals, Added)
c.Assert(file.Worktree, Equals, Unmodified)
file = status.File("foo/bar/baz")
c.Assert(file.Staging, Equals, Added)
c.Assert(file.Worktree, Equals, Unmodified)
}
func (s *WorktreeSuite) TestAddGlobErrorNoMatches(c *C) {
r, _ := Init(memory.NewStorage(), memfs.New())
w, _ := r.Worktree()
err := w.AddGlob("foo")
c.Assert(err, Equals, ErrGlobNoMatches)
}
func (s *WorktreeSuite) TestAddSkipStatusAddedPath(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = util.WriteFile(w.Filesystem, "file1", []byte("file1"), 0644)
c.Assert(err, IsNil)
err = w.AddWithOptions(&AddOptions{Path: "file1", SkipStatus: true})
c.Assert(err, IsNil)
idx, err = w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 10)
e, err := idx.Entry("file1")
c.Assert(err, IsNil)
c.Assert(e.Mode, Equals, filemode.Regular)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 1)
file := status.File("file1")
c.Assert(file.Staging, Equals, Added)
c.Assert(file.Worktree, Equals, Unmodified)
}
func (s *WorktreeSuite) TestAddSkipStatusModifiedPath(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = util.WriteFile(w.Filesystem, "LICENSE", []byte("file1"), 0644)
c.Assert(err, IsNil)
err = w.AddWithOptions(&AddOptions{Path: "LICENSE", SkipStatus: true})
c.Assert(err, IsNil)
idx, err = w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
e, err := idx.Entry("LICENSE")
c.Assert(err, IsNil)
c.Assert(e.Mode, Equals, filemode.Regular)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 1)
file := status.File("LICENSE")
c.Assert(file.Staging, Equals, Modified)
c.Assert(file.Worktree, Equals, Unmodified)
}
func (s *WorktreeSuite) TestAddSkipStatusNonModifiedPath(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = w.AddWithOptions(&AddOptions{Path: "LICENSE", SkipStatus: true})
c.Assert(err, IsNil)
idx, err = w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
e, err := idx.Entry("LICENSE")
c.Assert(err, IsNil)
c.Assert(e.Mode, Equals, filemode.Regular)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 0)
file := status.File("LICENSE")
c.Assert(file.Staging, Equals, Untracked)
c.Assert(file.Worktree, Equals, Untracked)
}
func (s *WorktreeSuite) TestAddSkipStatusWithIgnoredPath(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
idx, err := w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
err = util.WriteFile(fs, ".gitignore", []byte("fileToIgnore\n"), 0755)
c.Assert(err, IsNil)
_, err = w.Add(".gitignore")
c.Assert(err, IsNil)
_, err = w.Commit("Added .gitignore", defaultTestCommitOptions())
c.Assert(err, IsNil)
err = util.WriteFile(fs, "fileToIgnore", []byte("file to ignore"), 0644)
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 0)
file := status.File("fileToIgnore")
c.Assert(file.Staging, Equals, Untracked)
c.Assert(file.Worktree, Equals, Untracked)
err = w.AddWithOptions(&AddOptions{Path: "fileToIgnore", SkipStatus: true})
c.Assert(err, IsNil)
idx, err = w.r.Storer.Index()
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 10)
e, err := idx.Entry("fileToIgnore")
c.Assert(err, IsNil)
c.Assert(e.Mode, Equals, filemode.Regular)
status, err = w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 1)
file = status.File("fileToIgnore")
c.Assert(file.Staging, Equals, Added)
c.Assert(file.Worktree, Equals, Unmodified)
}
func (s *WorktreeSuite) TestRemove(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
hash, err := w.Remove("LICENSE")
c.Assert(hash.String(), Equals, "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f")
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 1)
c.Assert(status.File("LICENSE").Staging, Equals, Deleted)
}
func (s *WorktreeSuite) TestRemoveNotExistentEntry(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
hash, err := w.Remove("not-exists")
c.Assert(hash.IsZero(), Equals, true)
c.Assert(err, NotNil)
}
func (s *WorktreeSuite) TestRemoveDirectory(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
hash, err := w.Remove("json")
c.Assert(hash.IsZero(), Equals, true)
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 2)
c.Assert(status.File("json/long.json").Staging, Equals, Deleted)
c.Assert(status.File("json/short.json").Staging, Equals, Deleted)
_, err = w.Filesystem.Stat("json")
c.Assert(os.IsNotExist(err), Equals, true)
}
func (s *WorktreeSuite) TestRemoveDirectoryUntracked(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
err = util.WriteFile(w.Filesystem, "json/foo", []byte("FOO"), 0755)
c.Assert(err, IsNil)
hash, err := w.Remove("json")
c.Assert(hash.IsZero(), Equals, true)
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 3)
c.Assert(status.File("json/long.json").Staging, Equals, Deleted)
c.Assert(status.File("json/short.json").Staging, Equals, Deleted)
c.Assert(status.File("json/foo").Staging, Equals, Untracked)
_, err = w.Filesystem.Stat("json")
c.Assert(err, IsNil)
}
func (s *WorktreeSuite) TestRemoveDeletedFromWorktree(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
err = fs.Remove("LICENSE")
c.Assert(err, IsNil)
hash, err := w.Remove("LICENSE")
c.Assert(hash.String(), Equals, "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f")
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 1)
c.Assert(status.File("LICENSE").Staging, Equals, Deleted)
}
func (s *WorktreeSuite) TestRemoveGlob(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
err = w.RemoveGlob(w.Filesystem.Join("json", "l*"))
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 1)
c.Assert(status.File("json/long.json").Staging, Equals, Deleted)
}
func (s *WorktreeSuite) TestRemoveGlobDirectory(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
err = w.RemoveGlob("js*")
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 2)
c.Assert(status.File("json/short.json").Staging, Equals, Deleted)
c.Assert(status.File("json/long.json").Staging, Equals, Deleted)
_, err = w.Filesystem.Stat("json")
c.Assert(os.IsNotExist(err), Equals, true)
}
func (s *WorktreeSuite) TestRemoveGlobDirectoryDeleted(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
err = fs.Remove("json/short.json")
c.Assert(err, IsNil)
err = util.WriteFile(w.Filesystem, "json/foo", []byte("FOO"), 0755)
c.Assert(err, IsNil)
err = w.RemoveGlob("js*")
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 3)
c.Assert(status.File("json/short.json").Staging, Equals, Deleted)
c.Assert(status.File("json/long.json").Staging, Equals, Deleted)
}
func (s *WorktreeSuite) TestMove(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
hash, err := w.Move("LICENSE", "foo")
c.Check(hash.String(), Equals, "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f")
c.Assert(err, IsNil)
status, err := w.Status()
c.Assert(err, IsNil)
c.Assert(status, HasLen, 2)
c.Assert(status.File("LICENSE").Staging, Equals, Deleted)
c.Assert(status.File("foo").Staging, Equals, Added)
}
func (s *WorktreeSuite) TestMoveNotExistentEntry(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
hash, err := w.Move("not-exists", "foo")
c.Assert(hash.IsZero(), Equals, true)
c.Assert(err, NotNil)
}
func (s *WorktreeSuite) TestMoveToExistent(c *C) {
fs := memfs.New()
w := &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{Force: true})
c.Assert(err, IsNil)
hash, err := w.Move(".gitignore", "LICENSE")
c.Assert(hash.IsZero(), Equals, true)
c.Assert(err, Equals, ErrDestinationExists)
}
func (s *WorktreeSuite) TestClean(c *C) {
fs := fixtures.ByTag("dirty").One().Worktree()
// Open the repo.
fs, err := fs.Chroot("repo")
c.Assert(err, IsNil)
r, err := PlainOpen(fs.Root())
c.Assert(err, IsNil)
wt, err := r.Worktree()
c.Assert(err, IsNil)
// Status before cleaning.
status, err := wt.Status()
c.Assert(err, IsNil)
c.Assert(len(status), Equals, 2)
err = wt.Clean(&CleanOptions{})
c.Assert(err, IsNil)
// Status after cleaning.
status, err = wt.Status()
c.Assert(err, IsNil)
c.Assert(len(status), Equals, 1)
fi, err := fs.Lstat("pkgA")
c.Assert(err, IsNil)
c.Assert(fi.IsDir(), Equals, true)
// Clean with Dir: true.
err = wt.Clean(&CleanOptions{Dir: true})
c.Assert(err, IsNil)
status, err = wt.Status()
c.Assert(err, IsNil)
c.Assert(len(status), Equals, 0)
// An empty dir should be deleted, as well.
_, err = fs.Lstat("pkgA")
c.Assert(err, ErrorMatches, ".*(no such file or directory.*|.*file does not exist)*.")
}
func (s *WorktreeSuite) TestCleanBare(c *C) {
storer := memory.NewStorage()
r, err := Init(storer, nil)
c.Assert(err, IsNil)
c.Assert(r, NotNil)
wtfs := memfs.New()
err = wtfs.MkdirAll("worktree", os.ModePerm)
c.Assert(err, IsNil)
wtfs, err = wtfs.Chroot("worktree")
c.Assert(err, IsNil)
r, err = Open(storer, wtfs)
c.Assert(err, IsNil)
wt, err := r.Worktree()
c.Assert(err, IsNil)
_, err = wt.Filesystem.Lstat(".")
c.Assert(err, IsNil)
// Clean with Dir: true.
err = wt.Clean(&CleanOptions{Dir: true})
c.Assert(err, IsNil)
// Root worktree directory must remain after cleaning
_, err = wt.Filesystem.Lstat(".")
c.Assert(err, IsNil)
}
func TestAlternatesRepo(t *testing.T) {
fs := fixtures.ByTag("alternates").One().Worktree()
// Open 1st repo.
rep1fs, err := fs.Chroot("rep1")
assert.NoError(t, err)
rep1, err := PlainOpen(rep1fs.Root())
assert.NoError(t, err)
// Open 2nd repo.
rep2fs, err := fs.Chroot("rep2")
assert.NoError(t, err)
d, _ := rep2fs.Chroot(GitDirName)
storer := filesystem.NewStorageWithOptions(d,
cache.NewObjectLRUDefault(), filesystem.Options{
AlternatesFS: fs,
})
rep2, err := Open(storer, rep2fs)
assert.NoError(t, err)
// Get the HEAD commit from the main repo.
h, err := rep1.Head()
assert.NoError(t, err)
commit1, err := rep1.CommitObject(h.Hash())
assert.NoError(t, err)
// Get the HEAD commit from the shared repo.
h, err = rep2.Head()
assert.NoError(t, err)
commit2, err := rep2.CommitObject(h.Hash())
assert.NoError(t, err)
assert.Equal(t, commit1.String(), commit2.String())
}
func (s *WorktreeSuite) TestGrep(c *C) {
cases := []struct {
name string
options GrepOptions
wantResult []GrepResult
dontWantResult []GrepResult
wantError error
}{
{
name: "basic word match",
options: GrepOptions{
Patterns: []*regexp.Regexp{regexp.MustCompile("import")},
},
wantResult: []GrepResult{
{
FileName: "go/example.go",
LineNumber: 3,
Content: "import (",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
{
FileName: "vendor/foo.go",
LineNumber: 3,
Content: "import \"fmt\"",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
},
}, {
name: "case insensitive match",
options: GrepOptions{
Patterns: []*regexp.Regexp{regexp.MustCompile(`(?i)IMport`)},
},
wantResult: []GrepResult{
{
FileName: "go/example.go",
LineNumber: 3,
Content: "import (",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
{
FileName: "vendor/foo.go",
LineNumber: 3,
Content: "import \"fmt\"",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
},
}, {
name: "invert match",
options: GrepOptions{
Patterns: []*regexp.Regexp{regexp.MustCompile("import")},
InvertMatch: true,
},
dontWantResult: []GrepResult{
{
FileName: "go/example.go",
LineNumber: 3,
Content: "import (",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
{
FileName: "vendor/foo.go",
LineNumber: 3,
Content: "import \"fmt\"",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
},
}, {
name: "match at a given commit hash",
options: GrepOptions{
Patterns: []*regexp.Regexp{regexp.MustCompile("The MIT License")},
CommitHash: plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
},
wantResult: []GrepResult{
{
FileName: "LICENSE",
LineNumber: 1,
Content: "The MIT License (MIT)",
TreeName: "b029517f6300c2da0f4b651b8642506cd6aaf45d",
},
},
dontWantResult: []GrepResult{
{
FileName: "go/example.go",
LineNumber: 3,
Content: "import (",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
},
}, {
name: "match for a given pathspec",
options: GrepOptions{
Patterns: []*regexp.Regexp{regexp.MustCompile("import")},
PathSpecs: []*regexp.Regexp{regexp.MustCompile("go/")},
},
wantResult: []GrepResult{
{
FileName: "go/example.go",
LineNumber: 3,
Content: "import (",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
},
dontWantResult: []GrepResult{
{
FileName: "vendor/foo.go",
LineNumber: 3,
Content: "import \"fmt\"",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
},
}, {
name: "match at a given reference name",
options: GrepOptions{
Patterns: []*regexp.Regexp{regexp.MustCompile("import")},
ReferenceName: "refs/heads/master",
},
wantResult: []GrepResult{
{
FileName: "go/example.go",
LineNumber: 3,
Content: "import (",
TreeName: "refs/heads/master",
},
},
}, {
name: "ambiguous options",
options: GrepOptions{
Patterns: []*regexp.Regexp{regexp.MustCompile("import")},
CommitHash: plumbing.NewHash("2d55a722f3c3ecc36da919dfd8b6de38352f3507"),
ReferenceName: "somereferencename",
},
wantError: ErrHashOrReference,
}, {
name: "multiple patterns",
options: GrepOptions{
Patterns: []*regexp.Regexp{
regexp.MustCompile("import"),
regexp.MustCompile("License"),
},
},
wantResult: []GrepResult{
{
FileName: "go/example.go",
LineNumber: 3,
Content: "import (",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
{
FileName: "vendor/foo.go",
LineNumber: 3,
Content: "import \"fmt\"",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
{
FileName: "LICENSE",
LineNumber: 1,
Content: "The MIT License (MIT)",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
},
}, {
name: "multiple pathspecs",
options: GrepOptions{
Patterns: []*regexp.Regexp{regexp.MustCompile("import")},
PathSpecs: []*regexp.Regexp{
regexp.MustCompile("go/"),
regexp.MustCompile("vendor/"),
},
},
wantResult: []GrepResult{
{
FileName: "go/example.go",
LineNumber: 3,
Content: "import (",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
{
FileName: "vendor/foo.go",
LineNumber: 3,
Content: "import \"fmt\"",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
},
},
}
path := fixtures.Basic().ByTag("worktree").One().Worktree().Root()
dir := c.MkDir()
server, err := PlainClone(dir, false, &CloneOptions{
URL: path,
})
c.Assert(err, IsNil)
w, err := server.Worktree()
c.Assert(err, IsNil)
for _, tc := range cases {
gr, err := w.Grep(&tc.options)
if tc.wantError != nil {
c.Assert(err, Equals, tc.wantError)
} else {
c.Assert(err, IsNil)
}
// Iterate through the results and check if the wanted result is present
// in the got result.
for _, wantResult := range tc.wantResult {
found := false
for _, gotResult := range gr {
if wantResult == gotResult {
found = true
break
}
}
if !found {
c.Errorf("unexpected grep results for %q, expected result to contain: %v", tc.name, wantResult)
}
}
// Iterate through the results and check if the not wanted result is
// present in the got result.
for _, dontWantResult := range tc.dontWantResult {
found := false
for _, gotResult := range gr {
if dontWantResult == gotResult {
found = true
break
}
}
if found {
c.Errorf("unexpected grep results for %q, expected result to NOT contain: %v", tc.name, dontWantResult)
}
}
}
}
func (s *WorktreeSuite) TestGrepBare(c *C) {
cases := []struct {
name string
options GrepOptions
wantResult []GrepResult
dontWantResult []GrepResult
wantError error
}{
{
name: "basic word match",
options: GrepOptions{
Patterns: []*regexp.Regexp{regexp.MustCompile("import")},
CommitHash: plumbing.ZeroHash,
},
wantResult: []GrepResult{
{
FileName: "go/example.go",
LineNumber: 3,
Content: "import (",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
{
FileName: "vendor/foo.go",
LineNumber: 3,
Content: "import \"fmt\"",
TreeName: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
},
},
},
}
path := fixtures.Basic().ByTag("worktree").One().Worktree().Root()
dir := c.MkDir()
r, err := PlainClone(dir, true, &CloneOptions{
URL: path,
})
c.Assert(err, IsNil)
for _, tc := range cases {
gr, err := r.Grep(&tc.options)
if tc.wantError != nil {
c.Assert(err, Equals, tc.wantError)
} else {
c.Assert(err, IsNil)
}
// Iterate through the results and check if the wanted result is present
// in the got result.
for _, wantResult := range tc.wantResult {
found := false
for _, gotResult := range gr {
if wantResult == gotResult {
found = true
break
}
}
if !found {
c.Errorf("unexpected grep results for %q, expected result to contain: %v", tc.name, wantResult)
}
}
// Iterate through the results and check if the not wanted result is
// present in the got result.
for _, dontWantResult := range tc.dontWantResult {
found := false
for _, gotResult := range gr {
if dontWantResult == gotResult {
found = true
break
}
}
if found {
c.Errorf("unexpected grep results for %q, expected result to NOT contain: %v", tc.name, dontWantResult)
}
}
}
}
func (s *WorktreeSuite) TestResetLingeringDirectories(c *C) {
dir := c.MkDir()
commitOpts := &CommitOptions{Author: &object.Signature{
Name: "foo",
Email: "foo@foo.foo",
When: time.Now(),
}}
repo, err := PlainInit(dir, false)
c.Assert(err, IsNil)
w, err := repo.Worktree()
c.Assert(err, IsNil)
os.WriteFile(filepath.Join(dir, "README"), []byte("placeholder"), 0o644)
_, err = w.Add(".")
c.Assert(err, IsNil)
initialHash, err := w.Commit("Initial commit", commitOpts)
c.Assert(err, IsNil)
os.MkdirAll(filepath.Join(dir, "a", "b"), 0o755)
os.WriteFile(filepath.Join(dir, "a", "b", "1"), []byte("1"), 0o644)
_, err = w.Add(".")
c.Assert(err, IsNil)
_, err = w.Commit("Add file in nested sub-directories", commitOpts)
c.Assert(err, IsNil)
// reset to initial commit, which should remove a/b/1, a/b, and a
err = w.Reset(&ResetOptions{
Commit: initialHash,
Mode: HardReset,
})
c.Assert(err, IsNil)
_, err = os.Stat(filepath.Join(dir, "a", "b", "1"))
c.Assert(errors.Is(err, os.ErrNotExist), Equals, true)
_, err = os.Stat(filepath.Join(dir, "a", "b"))
c.Assert(errors.Is(err, os.ErrNotExist), Equals, true)
_, err = os.Stat(filepath.Join(dir, "a"))
c.Assert(errors.Is(err, os.ErrNotExist), Equals, true)
}
func (s *WorktreeSuite) TestAddAndCommit(c *C) {
expectedFiles := 2
dir := c.MkDir()
repo, err := PlainInit(dir, false)
c.Assert(err, IsNil)
w, err := repo.Worktree()
c.Assert(err, IsNil)
os.WriteFile(filepath.Join(dir, "foo"), []byte("bar"), 0o644)
os.WriteFile(filepath.Join(dir, "bar"), []byte("foo"), 0o644)
_, err = w.Add(".")
c.Assert(err, IsNil)
_, err = w.Commit("Test Add And Commit", &CommitOptions{Author: &object.Signature{
Name: "foo",
Email: "foo@foo.foo",
When: time.Now(),
}})
c.Assert(err, IsNil)
iter, err := w.r.Log(&LogOptions{})
c.Assert(err, IsNil)
filesFound := 0
err = iter.ForEach(func(c *object.Commit) error {
files, err := c.Files()
if err != nil {
return err
}
err = files.ForEach(func(f *object.File) error {
filesFound++
return nil
})
return err
})
c.Assert(err, IsNil)
c.Assert(filesFound, Equals, expectedFiles)
}
func (s *WorktreeSuite) TestAddAndCommitEmpty(c *C) {
dir := c.MkDir()
repo, err := PlainInit(dir, false)
c.Assert(err, IsNil)
w, err := repo.Worktree()
c.Assert(err, IsNil)
_, err = w.Add(".")
c.Assert(err, IsNil)
_, err = w.Commit("Test Add And Commit", &CommitOptions{Author: &object.Signature{
Name: "foo",
Email: "foo@foo.foo",
When: time.Now(),
}})
c.Assert(err, Equals, ErrEmptyCommit)
}
func (s *WorktreeSuite) TestLinkedWorktree(c *C) {
fs := fixtures.ByTag("linked-worktree").One().Worktree()
// Open main repo.
{
fs, err := fs.Chroot("main")
c.Assert(err, IsNil)
repo, err := PlainOpenWithOptions(fs.Root(), &PlainOpenOptions{EnableDotGitCommonDir: true})
c.Assert(err, IsNil)
wt, err := repo.Worktree()
c.Assert(err, IsNil)
status, err := wt.Status()
c.Assert(err, IsNil)
c.Assert(len(status), Equals, 2) // 2 files
head, err := repo.Head()
c.Assert(err, IsNil)
c.Assert(string(head.Name()), Equals, "refs/heads/master")
}
// Open linked-worktree #1.
{
fs, err := fs.Chroot("linked-worktree-1")
c.Assert(err, IsNil)
repo, err := PlainOpenWithOptions(fs.Root(), &PlainOpenOptions{EnableDotGitCommonDir: true})
c.Assert(err, IsNil)
wt, err := repo.Worktree()
c.Assert(err, IsNil)
status, err := wt.Status()
c.Assert(err, IsNil)
c.Assert(len(status), Equals, 3) // 3 files
_, ok := status["linked-worktree-1-unique-file.txt"]
c.Assert(ok, Equals, true)
head, err := repo.Head()
c.Assert(err, IsNil)
c.Assert(string(head.Name()), Equals, "refs/heads/linked-worktree-1")
}
// Open linked-worktree #2.
{
fs, err := fs.Chroot("linked-worktree-2")
c.Assert(err, IsNil)
repo, err := PlainOpenWithOptions(fs.Root(), &PlainOpenOptions{EnableDotGitCommonDir: true})
c.Assert(err, IsNil)
wt, err := repo.Worktree()
c.Assert(err, IsNil)
status, err := wt.Status()
c.Assert(err, IsNil)
c.Assert(len(status), Equals, 3) // 3 files
_, ok := status["linked-worktree-2-unique-file.txt"]
c.Assert(ok, Equals, true)
head, err := repo.Head()
c.Assert(err, IsNil)
c.Assert(string(head.Name()), Equals, "refs/heads/branch-with-different-name")
}
// Open linked-worktree #2.
{
fs, err := fs.Chroot("linked-worktree-invalid-commondir")
c.Assert(err, IsNil)
_, err = PlainOpenWithOptions(fs.Root(), &PlainOpenOptions{EnableDotGitCommonDir: true})
c.Assert(err, Equals, ErrRepositoryIncomplete)
}
}
func TestValidPath(t *testing.T) {
type testcase struct {
path string
wantErr bool
}
tests := []testcase{
{".git", true},
{".git/b", true},
{".git\\b", true},
{"git~1", true},
{"a/../b", true},
{"a\\..\\b", true},
{"/", true},
{"", true},
{".gitmodules", false},
{".gitignore", false},
{"a..b", false},
{".", false},
{"a/.git", false},
{"a\\.git", false},
{"a/.git/b", false},
{"a\\.git\\b", false},
}
if runtime.GOOS == "windows" {
tests = append(tests, []testcase{
{"\\\\a\\b", true},
{"C:\\a\\b", true},
{".git . . .", true},
{".git . . ", true},
{".git ", true},
{".git.", true},
{".git::$INDEX_ALLOCATION", true},
}...)
}
for _, tc := range tests {
t.Run(tc.path, func(t *testing.T) {
err := validPath(tc.path)
if tc.wantErr {
assert.Error(t, err)
} else {
assert.NoError(t, err)
}
})
}
}
func TestWindowsValidPath(t *testing.T) {
tests := []struct {
path string
want bool
}{
{".git", false},
{".git . . .", false},
{".git ", false},
{".git ", false},
{".git . .", false},
{".git . .", false},
{".git::$INDEX_ALLOCATION", false},
{".git:", false},
{"a", true},
{"a\\b", true},
{"a/b", true},
{".gitm", true},
}
for _, tc := range tests {
t.Run(tc.path, func(t *testing.T) {
got := windowsValidPath(tc.path)
assert.Equal(t, tc.want, got)
})
}
}
var statusCodeNames = map[StatusCode]string{
Unmodified: "Unmodified",
Untracked: "Untracked",
Modified: "Modified",
Added: "Added",
Deleted: "Deleted",
Renamed: "Renamed",
Copied: "Copied",
UpdatedButUnmerged: "UpdatedButUnmerged",
}
func setupForRestore(c *C, s *WorktreeSuite) (fs billy.Filesystem, w *Worktree, names []string) {
fs = memfs.New()
w = &Worktree{
r: s.Repository,
Filesystem: fs,
}
err := w.Checkout(&CheckoutOptions{})
c.Assert(err, IsNil)
names = []string{"foo", "CHANGELOG", "LICENSE", "binary.jpg"}
verifyStatus(c, "Checkout", w, names, []FileStatus{
{Worktree: Untracked, Staging: Untracked},
{Worktree: Untracked, Staging: Untracked},
{Worktree: Untracked, Staging: Untracked},
{Worktree: Untracked, Staging: Untracked},
})
// Touch of bunch of files including create a new file and delete an exsiting file
for _, name := range names {
err = util.WriteFile(fs, name, []byte("Foo Bar"), 0755)
c.Assert(err, IsNil)
}
err = util.RemoveAll(fs, names[3])
c.Assert(err, IsNil)
// Confirm the status after doing the edits without staging anything
verifyStatus(c, "Edits", w, names, []FileStatus{
{Worktree: Untracked, Staging: Untracked},
{Worktree: Modified, Staging: Unmodified},
{Worktree: Modified, Staging: Unmodified},
{Worktree: Deleted, Staging: Unmodified},
})
// Stage all files and verify the updated status
for _, name := range names {
_, err = w.Add(name)
c.Assert(err, IsNil)
}
verifyStatus(c, "Staged", w, names, []FileStatus{
{Worktree: Unmodified, Staging: Added},
{Worktree: Unmodified, Staging: Modified},
{Worktree: Unmodified, Staging: Modified},
{Worktree: Unmodified, Staging: Deleted},
})
// Add secondary changes to a file to make sure we only restore the staged file
err = util.WriteFile(fs, names[1], []byte("Foo Bar:11"), 0755)
c.Assert(err, IsNil)
err = util.WriteFile(fs, names[2], []byte("Foo Bar:22"), 0755)
c.Assert(err, IsNil)
verifyStatus(c, "Secondary Edits", w, names, []FileStatus{
{Worktree: Unmodified, Staging: Added},
{Worktree: Modified, Staging: Modified},
{Worktree: Modified, Staging: Modified},
{Worktree: Unmodified, Staging: Deleted},
})
return
}
func verifyStatus(c *C, marker string, w *Worktree, files []string, statuses []FileStatus) {
c.Assert(len(files), Equals, len(statuses))
status, err := w.Status()
c.Assert(err, IsNil)
for i, file := range files {
current := status.File(file)
expected := statuses[i]
c.Assert(current.Worktree, Equals, expected.Worktree, Commentf("%s - [%d] : %s Worktree %s != %s", marker, i, file, statusCodeNames[current.Worktree], statusCodeNames[expected.Worktree]))
c.Assert(current.Staging, Equals, expected.Staging, Commentf("%s - [%d] : %s Staging %s != %s", marker, i, file, statusCodeNames[current.Staging], statusCodeNames[expected.Staging]))
}
}
func (s *WorktreeSuite) TestRestoreStaged(c *C) {
fs, w, names := setupForRestore(c, s)
// Attempt without files should throw an error like the git restore --staged
opts := RestoreOptions{Staged: true}
err := w.Restore(&opts)
c.Assert(err, Equals, ErrNoRestorePaths)
// Restore Staged files in 2 groups and confirm status
opts.Files = []string{names[0], "./" + names[1]}
err = w.Restore(&opts)
c.Assert(err, IsNil)
verifyStatus(c, "Restored First", w, names, []FileStatus{
{Worktree: Untracked, Staging: Untracked},
{Worktree: Modified, Staging: Unmodified},
{Worktree: Modified, Staging: Modified},
{Worktree: Unmodified, Staging: Deleted},
})
// Make sure the restore didn't overwrite our secondary changes
contents, err := util.ReadFile(fs, names[1])
c.Assert(err, IsNil)
c.Assert(string(contents), Equals, "Foo Bar:11")
opts.Files = []string{"./" + names[2], names[3]}
err = w.Restore(&opts)
c.Assert(err, IsNil)
verifyStatus(c, "Restored Second", w, names, []FileStatus{
{Worktree: Untracked, Staging: Untracked},
{Worktree: Modified, Staging: Unmodified},
{Worktree: Modified, Staging: Unmodified},
{Worktree: Deleted, Staging: Unmodified},
})
// Make sure the restore didn't overwrite our secondary changes
contents, err = util.ReadFile(fs, names[2])
c.Assert(err, IsNil)
c.Assert(string(contents), Equals, "Foo Bar:22")
}
func (s *WorktreeSuite) TestRestoreWorktree(c *C) {
_, w, names := setupForRestore(c, s)
// Attempt without files should throw an error like the git restore
opts := RestoreOptions{}
err := w.Restore(&opts)
c.Assert(err, Equals, ErrNoRestorePaths)
opts.Files = []string{names[0], names[1]}
err = w.Restore(&opts)
c.Assert(err, Equals, ErrRestoreWorktreeOnlyNotSupported)
}
func (s *WorktreeSuite) TestRestoreBoth(c *C) {
_, w, names := setupForRestore(c, s)
// Attempt without files should throw an error like the git restore --staged --worktree
opts := RestoreOptions{Staged: true, Worktree: true}
err := w.Restore(&opts)
c.Assert(err, Equals, ErrNoRestorePaths)
// Restore Staged files in 2 groups and confirm status
opts.Files = []string{names[0], names[1]}
err = w.Restore(&opts)
c.Assert(err, IsNil)
verifyStatus(c, "Restored First", w, names, []FileStatus{
{Worktree: Untracked, Staging: Untracked},
{Worktree: Untracked, Staging: Untracked},
{Worktree: Modified, Staging: Modified},
{Worktree: Unmodified, Staging: Deleted},
})
opts.Files = []string{names[2], names[3]}
err = w.Restore(&opts)
c.Assert(err, IsNil)
verifyStatus(c, "Restored Second", w, names, []FileStatus{
{Worktree: Untracked, Staging: Untracked},
{Worktree: Untracked, Staging: Untracked},
{Worktree: Untracked, Staging: Untracked},
{Worktree: Untracked, Staging: Untracked},
})
}
func TestFilePermissions(t *testing.T) {
// Initialize an in memory repository
remoteUrl := t.TempDir()
inMemoryFs := memfs.New()
remoteFs := osfs.New(remoteUrl)
remoteStorage := filesystem.NewStorage(remoteFs, cache.NewObjectLRUDefault())
remoteRepository, err := Init(remoteStorage, inMemoryFs)
assert.NoError(t, err)
err = util.WriteFile(inMemoryFs, "fileWithExecuteBit", []byte("Initial data"), 0755)
assert.NoError(t, err)
err = util.WriteFile(inMemoryFs, "regularFile", []byte("Initial data"), 0644)
assert.NoError(t, err)
remoteWorktree, err := remoteRepository.Worktree()
assert.NoError(t, err)
_, err = remoteWorktree.Add("fileWithExecuteBit")
assert.NoError(t, err)
_, err = remoteWorktree.Add("regularFile")
assert.NoError(t, err)
_, err = remoteWorktree.Commit("my commit", &CommitOptions{})
assert.NoError(t, err)
worktreePath := t.TempDir()
localRepo, err := PlainClone(worktreePath, false, &CloneOptions{URL: remoteUrl})
assert.NoError(t, err)
localWorktree, err := localRepo.Worktree()
assert.NoError(t, err)
idx, err := localWorktree.r.Storer.Index()
assert.NoError(t, err)
expectedEntries := []index.Entry{
{
Name: "fileWithExecuteBit",
Mode: filemode.Executable,
},
{
Name: "regularFile",
Mode: filemode.Regular,
},
}
assert.Len(t, idx.Entries, len(expectedEntries))
for i, expectedEntry := range expectedEntries {
assert.Equal(t, expectedEntry.Name, idx.Entries[i].Name)
assert.Equal(t, expectedEntry.Mode, idx.Entries[i].Mode)
}
}
go-git-5.13.2/worktree_unix_other.go 0000664 0000000 0000000 00000000711 14744245500 0017431 0 ustar 00root root 0000000 0000000 // +build openbsd dragonfly solaris
package git
import (
"syscall"
"time"
"github.com/go-git/go-git/v5/plumbing/format/index"
)
func init() {
fillSystemInfo = func(e *index.Entry, sys interface{}) {
if os, ok := sys.(*syscall.Stat_t); ok {
e.CreatedAt = time.Unix(os.Atim.Unix())
e.Dev = uint32(os.Dev)
e.Inode = uint32(os.Ino)
e.GID = os.Gid
e.UID = os.Uid
}
}
}
func isSymlinkWindowsNonAdmin(err error) bool {
return false
}
go-git-5.13.2/worktree_windows.go 0000664 0000000 0000000 00000001333 14744245500 0016740 0 ustar 00root root 0000000 0000000 // +build windows
package git
import (
"os"
"syscall"
"time"
"github.com/go-git/go-git/v5/plumbing/format/index"
)
func init() {
fillSystemInfo = func(e *index.Entry, sys interface{}) {
if os, ok := sys.(*syscall.Win32FileAttributeData); ok {
seconds := os.CreationTime.Nanoseconds() / 1000000000
nanoseconds := os.CreationTime.Nanoseconds() - seconds*1000000000
e.CreatedAt = time.Unix(seconds, nanoseconds)
}
}
}
func isSymlinkWindowsNonAdmin(err error) bool {
const ERROR_PRIVILEGE_NOT_HELD syscall.Errno = 1314
if err != nil {
if errLink, ok := err.(*os.LinkError); ok {
if errNo, ok := errLink.Err.(syscall.Errno); ok {
return errNo == ERROR_PRIVILEGE_NOT_HELD
}
}
}
return false
}
]