Data

Tools

Indexes

Applications

Experiments

Ruby

A summary of data about the Ruby ecosystem.

https://github.com/ruby-git/ruby-git

Ruby/Git is a Ruby library that can be used to create, read and manipulate Git repositories by wrapping system calls to the git binary.
https://github.com/ruby-git/ruby-git

Keywords from Contributors

activerecord mvc activejob rubygems deployment rubocop rspec rack code-formatter static-code-analysis

Last synced: about 23 hours ago
JSON representation

Repository metadata

Ruby/Git is a Ruby library that can be used to create, read and manipulate Git repositories by wrapping system calls to the git binary.

README.md

The git gem

Gem Version
Build Status
Documentation
Change Log
Conventional Commits
AI Policy
License: MIT

This branch is unreleased v6.0.0 development. The current release series
is v5.x, released from the 5.x branch. v6.0.0 removes the APIs deprecated
during v5.x. See Upgrading to v6.x for what
changes.

Summary

The git gem provides a Ruby interface to the git
command line.

Get a repository object by:

  • opening an existing working copy with
    Git.open
  • initializing a new repository with
    Git.init
  • cloning a repository with
    Git.clone

Git::Repository documents the
methods you can call on a repository object.

Install

This gem is a wrapper around the git command line, so a git executable (version
2.43.0 or greater) must be installed and on your PATH. See the Git version support
policy for details.

Install the gem and add to the application's Gemfile by executing:

bundle add git

If you are not using bundler to manage dependencies, install the gem by executing:

gem install git

Quick start

All functionality for this gem starts with the top-level
Git module. Use this module to run non-repo
scoped git commands such as config.

The Git module also has factory methods such as open, clone, and init which
return a Git::Repository object. Use
the Git::Repository object to run repo-specific git commands such as add,
commit, push, and log.

Clone, read status, and log:

require 'git'

repo = Git.clone('https://github.com/ruby-git/ruby-git.git', 'ruby-git')
repo.status_info.changed.each_key { |path| puts "changed: #{path}" }
repo.log(5).execute.each { |c| puts c.message }

Open an existing repo and commit:

require 'git'

repo = Git.open('/path/to/repo')
repo.add(all: true)
repo.commit('chore: update files')
repo.push

Initialize a new repo and make the first commit:

require 'git'

repo = Git.init('my_project')
repo.add(all: true)
repo.commit('initial commit')

Examples

These examples cover configuring the gem and git itself. For the full set of
repository operations, see Full API below.

Gem configuration

Configure the git gem:

Git.configure do |config|
  config.binary_path = '/usr/local/bin/git'
  config.git_ssh = 'ssh -i ~/.ssh/id_rsa'
end

# or

Git.config.binary_path = '/usr/local/bin/git'
Git.config.git_ssh = 'ssh -i ~/.ssh/id_rsa'

How SSH configuration is determined:

  • If the API call does not specify git_ssh, the gem uses the global config
    (Git.configure { |c| c.git_ssh = ... }).
  • If the call specifies git_ssh: nil, the gem disables SSH for that instance and
    uses no SSH key or script.
  • If git_ssh is a non-empty string, the gem uses it for that instance instead of
    the global config.

You can also specify a custom SSH script on a per-repository basis:

# Use a specific SSH key for a single repository
git = Git.open('/path/to/repo', git_ssh: 'ssh -i /path/to/private_key')

# Or when cloning
git = Git.clone('git@github.com:user/repo.git', 'local-dir',
                git_ssh: 'ssh -i /path/to/private_key')

# Or when initializing
git = Git.init('new-repo', git_ssh: 'ssh -i /path/to/private_key')

This matters in multi-threaded applications where different repositories need
different SSH credentials.

Git configuration

Read and set git configuration values (via git config):

# Global config (in ~/.gitconfig)
entries = Git.config_list(global: true)         # returns Array<Git::ConfigEntryInfo>
entry   = Git.config_get('user.email', global: true) # returns Git::ConfigEntryInfo or nil
email    = entry&.value                          # => "user@example.com" or nil
Git.config_set('user.email', 'user@example.com', global: true)

# Repository config
repo = Git.open('path/to/repo')
entries  = repo.config_list                     # returns Array<Git::ConfigEntryInfo>
entry    = repo.config_get('user.email')        # returns Git::ConfigEntryInfo or nil
email    = entry&.value                         # => "anotheruser@example.com" or nil
repo.config_set('user.email', 'anotheruser@example.com')

Full API

The quick start and the configuration sections above cover the most common setup.
The Git::Repository reference
covers everything else: reading history, diffs, branches, remotes, worktrees,
staging, and low-level index and tree work. It documents every method and the object
type each one returns (such as Git::Log, Git::Object::Commit, Git::Diff,
Git::Branch, and Git::Worktree), so you can follow the links from a method to
the full API of its result.

Errors raised by this gem

The git gem raises only ArgumentError or errors that subclass Git::Error. It
does not explicitly raise any other types of errors.

Rescue Git::Error to catch any runtime error raised by this gem, unless you need
more specific error handling.

begin
  # some git operation
rescue Git::Error => e
  puts "An error occurred: #{e.message}"
end

See Git::Error for more information.

Specifying and handling timeouts

Set a timeout for git command line operations either globally or per method call for
methods that accept a :timeout parameter.

The timeout is the number of seconds a git command may run before the gem sends
it SIGKILL. It must be a real, non-negative Numeric. When a command times out,
the gem kills it and raises Git::TimeoutError, which derives from
Git::SignaledError and Git::Error. The gem may hang if the git command does
not terminate after receiving SIGKILL.

If the timeout value is 0 or nil, no timeout is enforced.

If a method accepts a :timeout parameter and receives a non-nil value, that value
overrides the global timeout. In this context, a value of nil, which is usually
the default, uses the global timeout value, and a value of 0 turns off timeout
enforcement for that method call no matter what the global value is.

To set a global timeout, use the Git.config object:

Git.config.timeout = nil # a value of nil or 0 means no timeout is enforced
Git.config.timeout = 1.5 # can be any real, non-negative Numeric interpreted as number of seconds

The global timeout can be overridden for a specific method if the method accepts a
:timeout parameter:

repo_url = 'https://github.com/ruby-git/ruby-git.git'
Git.clone(repo_url) # Use the global timeout value
Git.clone(repo_url, timeout: nil) # Also uses the global timeout value
Git.clone(repo_url, timeout: 0) # Do not enforce a timeout
Git.clone(repo_url, timeout: 10.5)  # Timeout after 10.5 seconds raising Git::TimeoutError

If the command takes too long, the gem raises Git::TimeoutError:

begin
  Git.clone(repo_url, timeout: 10)
rescue Git::TimeoutError => e
  e.result.tap do |r|
    r.class #=> Git::CommandLine::Result
    r.status #=> #<Process::Status: pid 62173 SIGKILL (signal 9)>
    r.status.timeout? #=> true
    r.git_cmd # The git command ran as an array of strings
    r.stdout # The command's output to stdout until it was terminated
    r.stderr # The command's output to stderr until it was terminated
  end
end

Deprecations

This gem uses ActiveSupport's deprecation mechanism to report deprecation warnings.

You can silence deprecation warnings by adding this line to your source code:

Git::Deprecation.behavior = :silence

Or by setting this environment variable before loading the gem:

GIT_DEPRECATION_BEHAVIOR=silence

Accepted environment variable values are the behavior names supported by your
installed ActiveSupport version.

If GIT_DEPRECATION_BEHAVIOR is set to an unsupported value, loading the gem
raises ArgumentError with the accepted behavior names.

See the Active Support Deprecation
documentation
for more details.

Before upgrading the git gem to the next major version, follow the upgrade procedure
in UPGRADING.md. It turns the warnings into errors so
that you cannot miss one.

For the full list of deprecated methods and their replacements, see
UPGRADING.md.

Platform limitations

Regex metacharacters on Git for Windows

On Git for Windows, git's regex engine matches bytes rather than characters. A
metacharacter such as ., or a POSIX character class such as [[:alpha:]], therefore
never matches a whole multi-byte character. The same call matches on Linux and macOS.

The failure is silent. Nothing raises, and the result is indistinguishable from a
pattern that genuinely does not occur:

# File content, commit message, and config value are all 'ÄPFEL sind gut'.
# 'Ä' is two bytes in UTF-8 (C3 84), so '.' has to match both to match the character.

repo.grep('^.PFEL')                              # => {} on Windows, matches elsewhere
repo.log.grep('^.PFEL').execute.size             # =>  0 on Windows, 1 elsewhere
repo.config_get_all('test.desc', '^.PFEL')       # => [] on Windows, matches elsewhere

This is a property of the regex engine git bundles on that platform, not something the
gem sets. It is unaffected by the locale: the behavior is identical under en_US.UTF-8,
C.UTF-8, C, and with no LC_ALL set at all. Literal (metacharacter-free) patterns
and case-insensitive matching are unaffected on every platform.

Workaround. Perl-compatible regular expressions do match characters on Git for
Windows, so the methods that can reach a PCRE engine accept an opt-in selector:

repo.grep('^.PFEL', nil, perl_regexp: true)      # matches on every platform
repo.log.perl_regexp.grep('^.PFEL').execute      # matches on every platform
repo.full_log_commits(grep: '^.PFEL', perl_regexp: true)

Two caveats:

  • PCRE is a different dialect. Git's other modes are POSIX basic regular
    expressions (the default) and POSIX extended regular expressions (selected
    explicitly). Selecting PCRE is a deliberate choice by the caller, so the gem does
    not substitute it automatically based on the host.
  • PCRE must be compiled in. Git for Windows and the mainstream Linux and macOS
    packages ship it, but git built without USE_LIBPCRE fails with cannot use Perl-compatible regexes....

There is no workaround for git config value patterns. They are POSIX extended
regular expressions with no PCRE mode, so config_get, config_get_all,
config_get_regexp, config_replace_all, config_unset, and config_unset_all cannot
match a metacharacter against a non-ASCII character on Git for Windows. Match on ASCII
text or an exact value instead.

config_replace_all deserves particular care, because there the failure is worse than
an empty result. When the value pattern selects nothing, git config --replace-all
adds the new value as an additional entry rather than replacing one, and exits zero:

# Existing value of test.desc is 'ÄPFEL sind gut'
repo.config_replace_all('test.desc', 'NEW', '^.PFEL')

repo.config_get_all('test.desc').map(&:value)
# => ["NEW"]                     elsewhere, replaced as intended
# => ["ÄPFEL sind gut", "NEW"]   on Windows, original kept and duplicate added

So a replace can silently leave the original value in place and add a second entry beside
it. Confirm with config_get_all when the key must end up single-valued.

Project policies

These documents set expectations for behavior, contribution workflows, AI-assisted
changes, decision making, maintainer roles, and licensing. Please review them before
opening issues or pull requests.

Document Description
CODE_OF_CONDUCT We follow the Ruby community Code of Conduct; expect respectful, harassment-free participation and report concerns to maintainers.
CONTRIBUTING How to report issues, submit PRs with Conventional Commits, meet coding/testing standards, and follow the Code of Conduct.
AI_POLICY AI-assisted contributions are welcome. Contributors are expected to read and apply the AI Policy, and ensure any AI-assisted work meets our quality, security, and licensing standards.
Ruby version support policy Supported Ruby runtimes and platforms; bump decisions and CI coverage expectations.
Git version support policy Minimum supported git version and how version bumps are communicated and enforced.
Deprecation policy When an API may be removed, what a deprecation warning says, and how to upgrade across a major version.
Release support policy Which branch releases what, and how long each major series is supported.
GOVERNANCE Principles-first governance defining maintainer/project lead roles, least-privilege access, consensus/majority decisions, and nomination/emeritus steps.
MAINTAINERS Lists active maintainers (Project Lead noted) and emeritus alumni with links; see governance for role scope.
LICENSE MIT License terms for using, modifying, and redistributing this project.

Ruby version support policy

This gem is expected to function correctly on:

  • All non-EOL versions of the MRI
    Ruby on Mac, Linux, and Windows
  • JRuby and TruffleRuby on Linux, starting from the earliest release whose Ruby
    compatibility target is at or above the oldest supported MRI version, unless a
    newer release is otherwise needed (for example, when a release does not
    implement a feature the gem depends on)

Consult the CI build matrix in
.github/workflows/continuous_integration.yml
for the exact JRuby and TruffleRuby versions tested. Newer releases of each engine
are expected to work but are not tested.

Because the JRuby and TruffleRuby floors derive from the MRI floor, they move
whenever the oldest supported MRI version changes.

This project intends to support the latest version of JRuby on Windows once
the process_executer gem properly
supports subprocess status reporting on JRuby for Windows (see
main-branch/process_executer#156).

Git version support policy

This gem requires git 2.43.0 or later, as the gemspec declares. The floor weighs the
git features the gem depends on, the systems users still run, and the git versions
CI can test.

Git 2.43.0 was released on November 20, 2023. The gem may work with an older git,
but the project does not test or support versions before 2.43.0. Users on an older
git should upgrade to at least 2.43.0.

A later major or minor release may raise the floor when the gem adopts a newer git
feature or when keeping compatibility with an old git becomes impractical. The
CHANGELOG and release notes document each such change.

Deprecation policy

This gem removes an API only in a major release, and only after a normal release
deprecated it with a runtime warning and documented its replacement in
UPGRADING.md. A normal release is one that is not a pre-release. The
warning names the major release that removes the API once that is decided. Until then
it says the API will be removed in a future major release.

The recommended way to upgrade across a major version:

  1. Upgrade to the latest release of the major series you are on.
  2. Set GIT_DEPRECATION_BEHAVIOR=raise (or Git::Deprecation.behavior = :raise) in
    your test suite and, if possible, staging.
  3. Fix each deprecation using the entries in UPGRADING.md until the
    suite is clean.
  4. Upgrade to the next major release.

Because every deprecation warning is present in the last release of a major series,
this procedure finds every change the next major requires. The version-specific steps
are in UPGRADING.md. See
Deprecations for how to configure the warnings.

Release support policy

All development happens on main, which releases the next version of the gem,
including the next major version. The next release from main is v6.0.0. Every
further v5.x release is cut from 5.x.

Each supported previous major series is maintained on a branch named for that
series, currently 5.x and 4.x. These branches receive bug fixes and security
fixes, and backward-compatible features at the maintainers' discretion. Fixes land on
main first and are backported, except a fix for a problem that exists only in a
maintenance branch, which targets that branch directly.

Support for a major series ends when the second major after it is released. v4.x is
supported until v6.0.0 ships, and v5.x until v7.0.0.

Project announcements

2026-09-04: v5.x releases move to the 5.x branch

On September 4, 2026, we created the 5.x branch from v5.4.1. Every further v5.x
release is cut from that branch, and the next release from main is v6.0.0. Nothing
changes for users of the gem: v5.x continues to receive bug fixes and security fixes
per the Release support policy, and v4.x is supported
until v6.0.0 ships.

For contributors, fixes still land on main first and are backported to 5.x. A fix
for a problem that exists only in v5.x targets 5.x directly. See the
branch strategy and
issue #1717, the v6.0.0 roadmap.

2026-09-04: Retired branches deleted

On September 4, 2026, we deleted the v1 and master branches. Neither had a
purpose: support for v1.x ended when v3.0.0 shipped, per the
Release support policy, and master was the pre-rename
default branch, frozen since the rename to main on 2025-06-06. Every v1.x release
remains available as a tag, so nothing released was lost.

The branches that remain are the ones the release support policy describes: main
releases the next version, 4.x maintains the v4.x series, and 5.x maintains the
v5.x series. See issue #1786 for
the details.

2026-08-23: v5.x deprecations and the v6.0.0 roadmap

The v6.0.0 plan is public. The remaining ActiveRecord-style
classes (Git::Branch, Git::Remote, Git::Stash, Git::Worktree,
Git::Object::Tag, Git::Status, Git::Author, and their collections) will be
deprecated during the v5.x series in favor of the immutable *Info value-object
APIs. v6.0.0 will remove each deprecated class once a normal v5.x release has carried
its deprecation warning and UPGRADING.md entry, per the
Deprecation policy. v6.0.0 will not ship until every planned
deprecation has shipped that way. v6.0.0 also raises the version floors to git 2.43.0
and Ruby 3.3.

Issue #1717 is the roadmap
and tracks scope, order, and status. If your code uses the classes above, you can
start migrating now. Each deprecation names its replacement, and
UPGRADING.md carries the migration guide as releases ship.

2026-07-28: v5.0.0 released

We have published git v5.0.0, the
first stable release of the v5.x series, after five public beta releases in June and
July 2026.

v5.0.0 is a major release with breaking changes. See
UPGRADING.md for the complete migration guide.

To install:

gem 'git', '~> 5.0'

Or:

gem install git

Most v4.x code requires no changes. Compatibility shims keep the old API working
while emitting deprecation warnings that tell you what to migrate before v6.0.0.

2026-01-07: AI policy introduced

We have adopted an AI Policy that sets expectations for
AI-assisted contributions. Read it before opening a PR. It asks that you understand
every change you submit, that the work meets the project's quality bar, and that it
respects licensing requirements.

The policy states principles rather than a checklist, so it is short to read and
still sets clear expectations.

2025-07-09: Architectural redesign

On this date we announced an architectural redesign of the git gem. The architecture
at the time was difficult to maintain and change. The redesign replaced it with a
three-layer structure of commands, parsers, and a Git::Repository facade, which is
easier to test because each layer can be exercised on its own.

The redesign shipped in v5.0.0 and is complete. Git::Base and Git::Lib are
gone, along with the g.lib accessor. See UPGRADING.md for what
changed and how to migrate.

The three documents written to plan it are kept as a historical record in
archive/v5-redesign/. They describe the state of the code
before and during the migration and are not current policy. The standards that apply
to new code live in .github/skills/.

  1. Analysis of the Current Architecture:
    a breakdown of the v4.x design and its challenges.
  2. The Proposed Redesign: an overview
    of the three-layer architecture.
  3. Implementation Plan: the
    step-by-step plan that was followed.

2025-07-07: We now use RuboCop

The ruby-git project has adopted RuboCop as its static
code analyzer and formatter so that contributions share one style. All new
contributions must follow the style rules the project's RuboCop configuration
enforces.

Run RuboCop from the project's Rakefile:

rake rubocop

RuboCop also runs as part of the default rake task, which our continuous integration
workflow runs.

PRs with RuboCop offenses will not be merged. In rare cases, it might be acceptable
to disable a RuboCop check for the most limited scope possible.

If you have a problem fixing a RuboCop offense, don't be afraid to ask a
contributor.

2025-06-06: Default branch rename

On June 6, 2025, we renamed the default branch from master to main.

Instructions for renaming your local or forked branch to match are in the gist
Default Branch Name
Change.

2025-05-15: We've switched to Conventional Commits

The ruby-git project has adopted the Conventional Commits
standard for all commit messages.
This enables automated changelog generation and is a step toward continuous
delivery.

All commits to this repository must follow the Conventional Commits standard.
Commits that do not follow it will fail the CI build, and PRs that include them will
not be merged.

To validate your commit messages locally before pushing them to GitHub, install the
git commit-msg hook by running bin/setup in the project root.

Read more about this change in the Commit Message Guidelines section of
CONTRIBUTING.md.

Owner metadata

GitHub Events

Total
Last Year

Committers metadata

Last synced: 2 days ago

Total Commits: 1,703
Total Committers: 125
Avg Commits per committer: 13.624
Development Distribution Score (DDS): 0.247

Commits in past year: 1,056
Committers in past year: 8
Avg Commits per committer in past year: 132.0
Development Distribution Score (DDS) in past year: 0.01

Name Email Commits
James Couball j****l@y****m 1283
robertodecurnex d****o@g****m 108
scott Chacon s****n@a****) 46
scott Chacon s****n@a****m 34
Joshua Nichols j****h@t****m 23
Scott Chacon s****n@g****m 18
Per Lundberg p****g@e****m 9
Eric Mueller n****a@g****m 8
Roberto Decurnex r****x@a****t 8
Daniel Mendler m****d@s****e 7
Vern Burton me@v****m 7
copilot-swe-agent[bot] 1****t 5
elliottcable g****t@e****e 4
Kelly Stannard k****d@l****m 4
James Rosen j****n@g****m 4
Cameron Walsh c****h@b****m 3
Yuichi Tateno h****h@g****m 3
Michael Mallete m****e@g****m 3
Jorge Bernal j****l@w****s 3
Costa Shapiro c****a@m****m 2
Eric Goodwin e****c@e****m 2
Gianni Chiappetta g****i@r****g 2
Joe Moore j****e@g****m 2
Yuya.Nishida y****a@j****g 2
Yuta Harima y****5@g****m 2
TIT s****n@y****u 2
Jon Dufresne j****e@g****m 2
Jonathan Rudenberg j****5@g****m 2
Joshua Liebowitz t****s 2
Kaoru Shirai 4****o 2
and 95 more...

Committer domains:

Issue and Pull Request metadata

Last synced: 1 day ago

Total issues: 162
Total pull requests: 615
Average time to close issues: 11 months
Average time to close pull requests: about 1 month
Total issue authors: 52
Total pull request authors: 38
Average comments per issue: 1.51
Average comments per pull request: 0.43
Merged pull request: 532
Bot issues: 0
Bot pull requests: 0

Past year issues: 84
Past year pull requests: 310
Past year average time to close issues: 22 days
Past year average time to close pull requests: 1 day
Past year issue authors: 5
Past year pull request authors: 6
Past year average comments per issue: 0.87
Past year average comments per pull request: 0.17
Past year merged pull request: 280
Past year bot issues: 0
Past year bot pull requests: 0

More stats: https://issues.ecosyste.ms/repositories/lookup?url=https://github.com/ruby-git/ruby-git

Top Issue Authors

  • jcouball (92)
  • ndregs (14)
  • TuanNguyen2807 (4)
  • costa (3)
  • mblythe86 (2)
  • dhs-rec (1)
  • zhigangh (1)
  • jayhendren (1)
  • HarlemSquirrel (1)
  • ghost (1)
  • pieterocp (1)
  • zedtux (1)
  • sergio-bobillier (1)
  • ccallebs (1)
  • fwolfst (1)

Top Pull Request Authors

  • jcouball (553)
  • nevinera (9)
  • mpapis (4)
  • hatkyinc2 (3)
  • traylenator (3)
  • urbanautomaton (3)
  • lHydra (2)
  • pcantrell (2)
  • costa (2)
  • bilbof (2)
  • fxposter (2)
  • frostyfab (2)
  • mattsalt (2)
  • bcg00ding (2)
  • maths22 (1)

Top Issue Labels

  • enhancement (31)
  • architecture (9)
  • bug (6)
  • breaking-change (5)
  • major-change (5)
  • refactoring (4)
  • internal-change (3)
  • minor-change (3)
  • tests (3)
  • documentation (2)
  • good first issue (1)
  • testing (1)
  • v2.0.0 (1)
  • refactor (1)

Top Pull Request Labels

  • autorelease: tagged (20)
  • internal-change (9)
  • patch-change (9)
  • autorelease: pending (8)
  • minor-change (5)
  • Bug (2)
  • Internal Change (2)
  • Major Change (2)
  • Not Merged (1)
  • New Feature (1)

Package metadata

gem.coop: git

The git gem provides an API that can be used to create, read, and manipulate Git repositories by wrapping system calls to the git command line. The API can be used for working with Git in complex interactions including branching and merging, object inspection and manipulation, history, patch generation and more.

  • Homepage: http://github.com/ruby-git/ruby-git
  • Documentation: http://www.rubydoc.info/gems/git/
  • Licenses: MIT
  • Latest release: 5.4.1 (published 4 days ago)
  • Last Synced: 2026-09-06T20:32:04.154Z (2 days ago)
  • Versions: 95
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Downloads: 206,614,128 Total
  • Docker Downloads: 536,153,506
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 0.081%
    • Downloads: 0.137%
    • Docker downloads count: 0.185%
  • Maintainers (1)
rubygems.org: git

The git gem provides an API that can be used to create, read, and manipulate Git repositories by wrapping system calls to the git command line. The API can be used for working with Git in complex interactions including branching and merging, object inspection and manipulation, history, patch generation and more.

proxy.golang.org: github.com/ruby-git/ruby-git

  • Homepage:
  • Documentation: https://pkg.go.dev/github.com/ruby-git/ruby-git#section-documentation
  • Licenses: mit
  • Latest release: v5.4.1+incompatible (published 4 days ago)
  • Last Synced: 2026-09-06T20:32:05.472Z (2 days ago)
  • Versions: 83
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Forks count: 1.25%
    • Stargazers count: 1.62%
    • Average: 5.812%
    • Dependent packages count: 9.576%
    • Dependent repos count: 10.802%
gem.coop: p-mongo-git

The Git Gem provides an API that can be used to create, read, and manipulate Git repositories by wrapping system calls to the `git` binary. The API can be used for working with Git in complex interactions including branching and merging, object inspection and manipulation, history, patch generation and more.

  • Homepage: http://github.com/ruby-git/ruby-git
  • Documentation: http://www.rubydoc.info/gems/p-mongo-git/
  • Licenses: MIT
  • Latest release: 1.8.1 (published about 5 years ago)
  • Last Synced: 2026-09-06T20:32:04.811Z (2 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Downloads: 2,875 Total
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 30.298%
    • Downloads: 90.893%
  • Maintainers (1)
rubygems.org: p-mongo-git

The Git Gem provides an API that can be used to create, read, and manipulate Git repositories by wrapping system calls to the `git` binary. The API can be used for working with Git in complex interactions including branching and merging, object inspection and manipulation, history, patch generation and more.

  • Homepage: http://github.com/ruby-git/ruby-git
  • Documentation: http://www.rubydoc.info/gems/p-mongo-git/
  • Licenses: MIT
  • Latest release: 1.8.1 (published about 5 years ago)
  • Last Synced: 2026-09-06T20:32:04.796Z (2 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Downloads: 2,875 Total
  • Rankings:
    • Forks count: 1.1%
    • Stargazers count: 1.114%
    • Dependent packages count: 15.706%
    • Average: 31.754%
    • Dependent repos count: 46.782%
    • Downloads: 94.066%
  • Maintainers (1)
ubuntu-23.10: ruby-git

  • Homepage: https://github.com/ruby-git/ruby-git
  • Licenses: mit
  • Latest release: 1.13.1-1 (published 7 months ago)
  • Last Synced: 2026-07-25T15:02:52.356Z (about 2 months ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
ubuntu-20.04: ruby-git

  • Homepage: https://github.com/ruby-git/ruby-git
  • Licenses: mit
  • Latest release: 1.6.0+0-1 (published 7 months ago)
  • Last Synced: 2026-03-13T14:28:27.021Z (6 months ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
ubuntu-24.04: ruby-git

  • Homepage: https://github.com/ruby-git/ruby-git
  • Licenses: mit
  • Latest release: 1.13.1-1 (published 7 months ago)
  • Last Synced: 2026-08-31T16:29:22.267Z (8 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
debian-12: ruby-git

  • Homepage: https://github.com/ruby-git/ruby-git
  • Documentation: https://packages.debian.org/bookworm/ruby-git
  • Licenses: mit
  • Latest release: 1.13.1-1 (published 7 months ago)
  • Last Synced: 2026-08-28T10:28:04.436Z (11 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
debian-13: ruby-git

  • Homepage: https://github.com/ruby-git/ruby-git
  • Documentation: https://packages.debian.org/trixie/ruby-git
  • Licenses: mit
  • Latest release: 1.13.1-1 (published 7 months ago)
  • Last Synced: 2026-03-14T18:09:21.355Z (6 months ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
gentoo-portage: dev-ruby/git

Library for using Git in Ruby

  • Homepage: https://github.com/ruby-git/ruby-git
  • Documentation: https://packages.gentoo.org/packages/dev-ruby/git
  • Licenses: MIT
  • Latest release: 4.3.0 (published 5 months ago)
  • Last Synced: 2026-07-28T01:17:16.899Z (about 1 month ago)
  • Versions: 10
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
ubuntu-24.10: ruby-git

  • Homepage: https://github.com/ruby-git/ruby-git
  • Licenses: mit
  • Latest release: 1.13.1-1 (published 7 months ago)
  • Last Synced: 2026-03-09T17:05:38.623Z (6 months ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
ubuntu-22.04: ruby-git

  • Homepage: https://github.com/ruby-git/ruby-git
  • Licenses: mit
  • Latest release: 1.9.1-1 (published 7 months ago)
  • Last Synced: 2026-03-13T13:36:30.680Z (6 months ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
pkgsrc-netbsd-x86_64-10.1-all: devel/ruby-git

API to create, read, and manipulate Git repositories

  • Homepage: https://github.com/ruby-git/ruby-git
  • Documentation: https://pkgsrc.se/devel/ruby-git
  • Licenses: mit
  • Latest release: 1.19.1 (published 5 months ago)
  • Last Synced: 2026-05-27T06:45:52.635Z (3 months ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
ubuntu-23.04: ruby-git

  • Homepage: https://github.com/ruby-git/ruby-git
  • Licenses: mit
  • Latest release: 1.13.1-1 (published 7 months ago)
  • Last Synced: 2026-03-11T17:19:44.975Z (6 months ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
debian-11: ruby-git

  • Homepage: https://github.com/ruby-git/ruby-git
  • Documentation: https://packages.debian.org/bullseye/ruby-git
  • Licenses: mit
  • Latest release: 1.7.0-1 (published 7 months ago)
  • Last Synced: 2026-03-14T06:22:55.271Z (6 months ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%

Dependencies

.github/workflows/continuous_integration.yml actions
  • actions/checkout v3 composite
  • ruby/setup-ruby v1 composite
git.gemspec rubygems
  • bump ~> 0.10 development
  • create_github_release ~> 0.2 development
  • minitar ~> 0.9 development
  • rake ~> 13.0 development
  • redcarpet ~> 3.5 development
  • test-unit ~> 3.3 development
  • yard ~> 0.9, >= 0.9.28 development
  • yardstick ~> 0.9 development
  • addressable ~> 2.8
  • rchardet ~> 1.8
Gemfile rubygems
.github/workflows/enforce_conventional_commits.yml actions
  • actions/checkout v6 composite
  • wagoid/commitlint-github-action v6 composite
docker/test/docker-compose.yml docker
.github/workflows/experimental_continuous_integration.yml actions
  • actions/checkout v6 composite
  • actions/setup-java v5 composite
  • ruby/setup-ruby v1 composite
.github/workflows/release.yml actions
  • actions/checkout v6 composite
  • googleapis/release-please-action v5 composite
  • ruby/setup-ruby v1 composite
  • rubygems/release-gem v1 composite
docker/test/Dockerfile docker
  • ruby latest build
package.json npm
  • @commitlint/cli ^19.8.0 development
  • @commitlint/config-conventional ^19.8.0 development
  • husky ^9.1.7 development
.github/workflows/warm_bundler_caches.yml actions
  • actions/checkout v6 composite
  • ruby/setup-ruby v1 composite

Score: 33.467065952787756