https://github.com/libgit2/rugged

ruby bindings to libgit2
https://github.com/libgit2/rugged

Keywords

git libgit2 ruby

Keywords from Contributors

activerecord mvc activejob rubygem ruby-gem rubocop rack background-jobs rspec sinatra

Last synced: about 11 hours ago
JSON representation

Repository metadata

ruby bindings to libgit2

Host: GitHub
URL: https://github.com/libgit2/rugged
Owner: libgit2
License: mit
Created: 2010-09-10T16:18:17.000Z (over 15 years ago)
Default Branch: master
Last Pushed: 2026-02-28T18:12:44.000Z (3 days ago)
Last Synced: 2026-03-01T09:52:07.037Z (3 days ago)
Topics: git, libgit2, ruby
Language: C
Homepage:
Size: 21.3 MB
Stars: 2,289
Watchers: 65
Forks: 285
Open Issues: 122
Releases: 7
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE

Rugged

libgit2 bindings in Ruby

Rugged is a library for accessing libgit2 in Ruby. It gives you the speed and
portability of libgit2 with the beauty of the Ruby language.

libgit2

libgit2 is a pure C implementation of the Git core methods. It's designed to be
fast and portable. For more information about libgit2,
check out libgit2's website or browse the
libgit2 organization on GitHub.

Install

Rugged is a self-contained gem. You can install it by running:

$ gem install rugged

Prerequisites

You need to have CMake and pkg-config installed on your system to be able to build the included version of libgit2.

Debian, Including Ubuntu

All Debian-derived Linux distros provide apt:

$ sudo apt install libgit2-dev cmake pkg-config

Note that you only need libgit2-dev if you want to build with the system
libgit2 rather than the vendored version. In this case, note that the major and
minor versions of libgit2 and rugged must match.

Mac

On OS X, after installing Homebrew, you can get the required packages with:

$ brew install cmake pkg-config

Please follow the above in case installation of the gem fails with ERROR: CMake is required to build Rugged..

Options

If you want to build Rugged with HTTPS and SSH support, check out the list of optional libgit2 dependencies.

To install rugged with SSH support ensure you have the LibSSH2 library present, then pass the required CMAKE_FLAGS:

CMAKE_FLAGS='-DUSE_SSH=ON' gem install rugged

Or pass the --with-ssh build option:

gem install rugged -- --with-ssh

If you're using bundler and want to bundle libgit2 with Rugged, you can use the :submodules option:

gem 'rugged', git: 'git://github.com/libgit2/rugged.git', submodules: true

If you would like to bundle rugged with SSH support add the --with-ssh build option to the bundler config:

bundle config build.rugged --with-ssh

Usage

To load Rugged, you'll usually want to add something like this:

require 'rugged'

Use the system provided libgit2

By default, Rugged builds and uses a bundled version of libgit2. If you
want to use the system library instead, you can install rugged as follows:

gem install rugged -- --use-system-libraries

Or if you are using bundler:

bundle config build.rugged --use-system-libraries
bundle install

However, note that Rugged does only support specific versions of libgit2.

Usage

Rugged gives you access to the many parts of a Git repository. You can read and
write objects, walk a tree, access the staging area, and lots more. Let's look
at each area individually.

Repositories

Instantiation

The repository is naturally central to Git. Rugged has a Repository class that
you can instantiate with a path to open an existing repository :

repo = Rugged::Repository.new('path/to/my/repository')
# => #<Rugged::Repository:2228536260 {path: "path/to/my/repository/.git/"}>

You can create a new repository with init_at. Add a second parameter :bare to make a bare repository:

Rugged::Repository.init_at('.', :bare)

You can also let Rugged discover the path to the .git directory if you give it a
subdirectory.

Rugged::Repository.discover("/Users/me/projects/repo/lib/subdir/")
# => "/Users/me/projects/repo/.git/"

Once your Repository instantiated (in the following examples, as repo), you
can access or modify it.

Accessing a Repository

# Does the given SHA1 exist in this repository?
repo.exists?('07b44cbda23b726e5d54e2ef383495922c024202')
# => true

# Boolean repository state values:
repo.bare?
# => false
repo.empty?
# => true
repo.head_unborn?
# => false
repo.head_detached?
# => false

# Path accessors
repo.path
# => "path/to/my/repository/.git/"
repo.workdir
# => "path/to/my/repository/"

# The HEAD of the repository.
ref = repo.head
# => #<Rugged::Reference:2228467240 {name: "refs/heads/master", target:  #<Rugged::Commit:2228467250 {message: "helpful message", tree: #<Rugged::Tree:2228467260 {oid: 5d6f29220a0783b8085134df14ec4d960b6c3bf2}>}>

# From the returned ref, you can also access the `name`, `target`, and target SHA:
ref.name
# => "refs/heads/master"
ref.target
# => #<Rugged::Commit:2228467250 {message: "helpful message", tree: #<Rugged::Tree:2228467260 {oid: 5d6f29220a0783b8085134df14ec4d960b6c3bf2}>}>
ref.target_id
# => "2bc6a70483369f33f641ca44873497f13a15cde5"

# Reading an object
object = repo.read('a0ae5566e3c8a3bddffab21022056f0b5e03ef07')
# => #<Rugged::OdbObject:0x109a64780>
object.len
# => 237
object.data
# => "tree 76f23f186076fc291742816721ea8c3e95567241\nparent 8e3c5c52b8f29da0adc7e8be8a037cbeaea6de6b\nauthor Vicent Mart\303\255 <tanoku@gmail.com> 1333859005 +0200\ncommitter Vicent Mart\303\255 <tanoku@gmail.com> 1333859005 +0200\n\nAdd `Repository#blob_at`\n"
object.type
# => :commit

Writing to a Repository

There's a few ways to write to a repository. To write directly from your
instantiated repository object:

sha = repo.write(content, type)

You can also use the Commit object directly to craft a commit; this is a bit
more high-level, so it may be preferable:

oid = repo.write("This is a blob.", :blob)
index = repo.index
index.read_tree(repo.head.target.tree)
index.add(:path => "README.md", :oid => oid, :mode => 0100644)

options = {}
options[:tree] = index.write_tree(repo)

options[:author] = { :email => "testuser@github.com", :name => 'Test Author', :time => Time.now }
options[:committer] = { :email => "testuser@github.com", :name => 'Test Author', :time => Time.now }
options[:message] ||= "Making a commit via Rugged!"
options[:parents] = repo.empty? ? [] : [ repo.head.target ].compact
options[:update_ref] = 'HEAD'

Rugged::Commit.create(repo, options)

Objects

Object is the main object class - it shouldn't be created directly, but all of
these methods should be useful in their derived classes.

obj = repo.lookup(sha)
obj.oid  # object sha
obj.type # One of :commit, :tree, :blob or :tag

robj = obj.read_raw
str  = robj.data
int  = robj.len

There are four base object types in Git: blobs, commits, tags, and
trees. Each of these object types have a corresponding class within Rugged.

Commit Objects

commit = repo.lookup('a0ae5566e3c8a3bddffab21022056f0b5e03ef07')
# => #<Rugged::Commit:2245304380>

commit.message
# => "Add `Repository#blob_at`\n"

commit.time
# => Sat Apr 07 21:23:25 -0700 2012

commit.author
# => {:email=>"tanoku@gmail.com", :name=>"Vicent Mart\303\255", :time=>Sun Apr 08 04:23:25 UTC 2012}

commit.tree
# => #<Rugged::Tree:2245269740>

commit.parents
# => [#<Rugged::Commit:2245264600 {message: "Merge pull request #47 from isaac/remotes\n\nAdd Rugged::Repository#remotes", tree: #<Rugged::Tree:2245264240 {oid: 6a2aee58a41fa007d07aa55565e2231f9b39b4a9}>]

You can also write new objects to the database this way:

author = {:email=>"tanoku@gmail.com", :time=>Time.now, :name=>"Vicent Mart\303\255"}

Rugged::Commit.create(r,
	:author => author,
	:message => "Hello world\n\n",
	:committer => author,
	:parents => ["2cb831a8aea28b2c1b9c63385585b864e4d3bad1"],
	:tree => some_tree,
	:update_ref => "HEAD") #=> "f148106ca58764adc93ad4e2d6b1d168422b9796"

Tag Objects

tag  = repo.lookup(tag_sha)

object = tag.target
sha    = tag.target.oid
str    = tag.target_type # :commit, :tag, :blob
str    = tag.name        # "v1.0"
str    = tag.message
person = tag.tagger

Tree Objects

tree = repo.lookup('779fbb1e17e666832773a9825875300ea736c2da')
# => #<Rugged::Tree:2245194360>

# number of tree entries
tree.count

tree[0]           # or...
tree.first        # or...
tree.get_entry(0)
# => {:type=>:blob, :oid=>"99e7edb53db9355f10c6f2dfaa5a183f205d93bf", :filemode=>33188, :name=>".gitignore"}

The tree object is an Enumerable, so you can also do stuff like this:

tree.each { |e| puts e[:oid] }
tree.sort { |a, b| a[:oid] <=> b[:oid] }.map { |e| e[:name] }.join(':')

And there are some Rugged-specific methods, too:

tree.each_tree { |entry| puts entry[:name] }  # list subdirs
tree.each_blob { |entry| puts entry[:name] }  # list only files

You can also write trees with the TreeBuilder:

oid = repo.write("This is a blob.", :blob)
builder = Rugged::Tree::Builder.new(repo)
builder << { :type => :blob, :name => "README.md", :oid => oid, :filemode => 0100644 }

options = {}
options[:tree] = builder.write

options[:author] = { :email => "testuser@github.com", :name => 'Test Author', :time => Time.now }
options[:committer] = { :email => "testuser@github.com", :name => 'Test Author', :time => Time.now }
options[:message] ||= "Making a commit via Rugged!"
options[:parents] = repo.empty? ? [] : [ repo.head.target ].compact
options[:update_ref] = 'HEAD'

Rugged::Commit.create(repo, options)

Blob Objects

Blob objects represent the data in the files of a Tree Object.

blob = repo.lookup('e1253910439ea902cf49be8a9f02f3c08d89ac73')
blob.content # => Gives you the content of the blob.

Streaming Blob Objects

There is currently no way to stream data from a blob, because libgit2 itself does not (yet) support
streaming blobs out of the git object database. While there are hooks and interfaces for supporting it,
the default file system backend always loads the entire blob contents into memory.

If you need to access a Blob object through an IO-like API, you can wrap it with the StringIO class.
Note that the only advantage here is a stream-compatible interface, the complete blob object will still
be loaded into memory. Below is an example for streaming a Blob using the Sinatra framework:

# Sinatra endpoint
get "/blobs/:sha" do
  repo = Rugged::Repository.new(my_repo_path)
  blob = repo.lookup params[:sha]

  headers({
    "Vary" => "Accept",
    "Connection" => "keep-alive",
    "Transfer-Encoding" => "chunked",
    "Content-Type" => "application/octet-stream",
  })

  stream do |out|
    StringIO.new(blob.content).each(8000) do |chunk|
      out << chunk
    end
  end
end

Commit Walker

Rugged::Walker is a class designed to help you traverse a set of commits over
a repository.

You first push head SHAs onto the walker, and then call next to get a list of
the reachable commit objects one at a time. You can also hide() commits if you
are not interested in anything beneath them (useful in situations like when
you're running something like git log master ^origin/master).

walker = Rugged::Walker.new(repo)
walker.sorting(Rugged::SORT_TOPO | Rugged::SORT_REVERSE) # optional
walker.push(hex_sha_interesting)
walker.hide(hex_sha_uninteresting)
walker.each { |c| puts c.inspect }
walker.reset

Index ("staging") area

We can inspect and manipulate the Git Index as well. To work with the index
inside an existing repository, instantiate it by using the Repository.index
method instead of manually opening the Index by its path.

index = Rugged::Index.new(path)

# Re-read the index file from disk.
index.reload

# Count up index entries.
count = index.count

# The collection of index entries.
index.entries

# Iterating over index entries.
index.each { |i| puts i.inspect }

# Get a particular entry in the index.
index[path]

# Unstage.
index.remove(path)

# Stage. Also updates existing entry if there is one.
index.add(ientry)

# Stage. Create ientry from file in path, updates the index.
index.add(path)

Refs

You can access references through the Rugged::ReferenceCollection object returned by Repository#references.

ref = repo.references["refs/heads/master"]

sha = ref.target_id
str = ref.type   # :direct
str = ref.name   # "refs/heads/master"

You can also easily iterate over all references:

repo.references.each do |ref|
  puts ref.name
end

Or only over references that match the given pattern (glob):

repo.references.each("refs/tags/*") do |ref|
  puts ref.name
end

It is also easy to create, update, rename or delete a reference:

ref = repo.references.create("refs/heads/unit_test", some_commit_sha)

repo.references.update(ref, new_sha) # or...
repo.references.update("refs/heads/unit_test", new_sha)

repo.references.rename(ref, "refs/heads/blead") # or...
repo.references.rename("refs/heads/unit_test", "refs/heads/blead")

repo.references.delete(ref) # or...
repo.references.delete("refs/heads/unit_test") # or...

Finally, you can access the reflog for any branch:

ref = repo.references["refs/heads/master"]
entry = ref.log.first
sha   = entry[:id_old]
sha   = entry[:id_new]
str   = entry[:message]
prsn  = entry[:committer]

Branches

The Rugged::BranchCollection object returned by Repository#branches will help
you with all of your branch-related needs.

Iterate over all branches:

repo.branches.each_name().sort
# => ["master", "origin/HEAD", "origin/master", "origin/packed"]

repo.branches.each_name(:local).sort
# => ["master"]

repo.branches.each_name(:remote).sort
# => ["origin/HEAD", "origin/master", "origin/packed"]

Look up branches and get attributes:

branch = repo.branches["master"]
branch.name # => 'master'
branch.canonical_name # => 'refs/heads/master'

Look up the id for the target of a branch:

repo.branches["master"].target_id
# => "36060c58702ed4c2a40832c51758d5344201d89a"

Creation and deletion:

branch = repo.branches.create("test_branch", "HEAD")

repo.branches.rename("test_branch", "new_branch") # or...
repo.branches.rename("refs/heads/test_branch", "new_branch") # or...
repo.branches.rename(ref, "new_branch") # or...

repo.branches.delete("test_branch") # or...
repo.branches.delete("refs/heads/test_branch") # or...
repo.branches.delete(ref) # or...

Diffs

There are various ways to get hands on diffs:

# Diff between two subsequent commits
diff_commits = commit_object.parents[0].diff(commit_object)

# Diff between two tree objects
diff_trees = tree_object_a.diff(tree_object_b)

# Diff between index/staging and current working directory
diff_index = repository.index.diff

# Diff between index/staging and another diffable (commit/tree/index)
diff_index_diffable = repository.index.diff(some_diffable)

When you already have a diff object, you can examine it:

# Get patch
diff.patch
=> "diff --git a/foo1 b/foo1\nnew file mode 100644\nindex 0000000..81b68f0\n--- /dev/null\n+++ b/foo1\n@@ -0,0 +1,2 @@\n+abc\n+add line1\ndiff --git a/txt1 b/txt1\ndeleted file mode 100644\nindex 81b68f0..0000000\n--- a/txt1\n+++ /dev/null\n@@ -1,2 +0,0 @@\n-abc\n-add line1\ndiff --git a/txt2 b/txt2\nindex a7bb42f..a357de7 100644\n--- a/txt2\n+++ b/txt2\n@@ -1,2 +1,3 @@\n abc2\n add line2-1\n+add line2-2\n"

# Get delta (faster, if you only need information on what files changed)
diff.each_delta{ |d| puts d.inspect }
#<Rugged::Diff::Delta:70144372137380 {old_file: {:oid=>"0000000000000000000000000000000000000000", :path=>"foo1", :size=>0, :flags=>6, :mode=>0}, new_file: {:oid=>"81b68f040b120c9627518213f7fc317d1ed18e1c", :path=>"foo1", :size=>14, :flags=>6, :mode=>33188}, similarity: 0, status: :added>
#<Rugged::Diff::Delta:70144372136540 {old_file: {:oid=>"81b68f040b120c9627518213f7fc317d1ed18e1c", :path=>"txt1", :size=>14, :flags=>6, :mode=>33188}, new_file: {:oid=>"0000000000000000000000000000000000000000", :path=>"txt1", :size=>0, :flags=>6, :mode=>0}, similarity: 0, status: :deleted>
#<Rugged::Diff::Delta:70144372135780 {old_file: {:oid=>"a7bb42f71183c162efea5e4c80597437d716c62b", :path=>"txt2", :size=>17, :flags=>6, :mode=>33188}, new_file: {:oid=>"a357de7d870823acc3953f1b2471f9c18d0d56ea", :path=>"txt2", :size=>29, :flags=>6, :mode=>33188}, similarity: 0, status: :modified>

# Detect renamed files
# Note that the status field changed from :added/:deleted to :renamed
diff.find_similar!
diff.each_delta{ |d| puts d.inspect }
#<Rugged::Diff::Delta:70144372230920 {old_file: {:oid=>"81b68f040b120c9627518213f7fc317d1ed18e1c", :path=>"txt1", :size=>14, :flags=>6, :mode=>33188}, new_file: {:oid=>"81b68f040b120c9627518213f7fc317d1ed18e1c", :path=>"foo1", :size=>14, :flags=>6, :mode=>33188}, similarity: 100, status: :renamed>
#<Rugged::Diff::Delta:70144372230140 {old_file: {:oid=>"a7bb42f71183c162efea5e4c80597437d716c62b", :path=>"txt2", :size=>17, :flags=>6, :mode=>33188}, new_file: {:oid=>"a357de7d870823acc3953f1b2471f9c18d0d56ea", :path=>"txt2", :size=>29, :flags=>6, :mode=>33188}, similarity: 0, status: :modified>

# Merge one diff into another (mutating the first one)
diff1.merge!(diff2)

# Write a patch into a file (or any other object responding to write)
# Note that the patch as in diff.patch will be written, it won't be applied
file = File.open('/some/file', 'w')
diff.write_patch(file)
file.close

Config files

It's also easy to read and manipulate the Git config file data with Rugged.

# Read values
repo.config['core.bare']

# Set values
repo.config['user.name'] = true

# Delete values
repo.config.delete('user.name')

General methods

Rugged also includes a general library for handling basic Git operations. One of
these is converting a raw sha (20 bytes) into a readable hex sha (40
characters).

Rugged.hex_to_raw('bfde59cdd0dfac1d892814f66a95641abd8a1faf')
# => "\277\336Y\315\320\337\254\035\211(\024\366j\225d\032\275\212\037\257"

Rugged.raw_to_hex("\277\336Y\315\320\337\254\035\211(\024\366j\225d\032\275\212\037\257")
=> "bfde59cdd0dfac1d892814f66a95641abd8a1faf"

Alternative backends

You can store bare repositories in alternative backends instead of storing on disk. (see
redbadger/rugged-redis for an example of how a rugged backend works).

a_backend = MyProject::CustomObjectDB(opt1: 'setting', opt2: 'setting')

repo = Rugged::Repository.init_at('repo_name', :bare, backend: a_backend)

# or

repo = Rugged::Repository.bare('repo_name', backend: a_backend)

Contributing

Fork libgit2/rugged on GitHub, make it awesomer (preferably in a branch named
for the topic), send a pull request.

Development

Simply clone and install:

$ git clone https://github.com/libgit2/rugged.git
$ cd rugged
$ bundle install
$ rake compile
$ rake test

Support

We encourage you to use StackOverflow for any questions or concerns regarding Rugged. Please tag your questions with the rugged keyword.

For bug reports, please open a ticket on the GitHub issue tracker.

Authors

Vicent Marti tanoku@gmail.com
Scott Chacon schacon@gmail.com
Arthur Schreiber schreiber.arthur@gmail.com

License

MIT. See LICENSE file.

Owner metadata

Name: libgit2
Login: libgit2
Email:
Kind: organization
Description: A portable, pure C implementation of the Git core methods provided as a re-entrant linkable library with a solid API.
Website: https://libgit2.org
Location:
Twitter:
Company:
Icon url: https://avatars.githubusercontent.com/u/394745?v=4
Repositories: 25
Last ynced at: 2024-03-25T20:15:35.094Z
Profile URL: https://github.com/libgit2

GitHub Events

Total

Delete event: 3
Pull request event: 12
Fork event: 10
Issues event: 5
Watch event: 36
Issue comment event: 24
Push event: 8
Create event: 4
Commit comment event: 1

Last Year

Delete event: 1
Pull request event: 6
Fork event: 5
Issues event: 4
Watch event: 23
Issue comment event: 14
Push event: 3
Create event: 2

Committers metadata

Last synced: 3 days ago

Total Commits: 2,199
Total Committers: 122
Avg Commits per committer: 18.025
Development Distribution Score (DDS): 0.697

Commits in past year: 22
Committers in past year: 2
Avg Commits per committer in past year: 11.0
Development Distribution Score (DDS) in past year: 0.045

Name	Email	Commits
Arthur Schreiber	s**r@g**m	667
hubot	c**t@g**m	334
Vicent Marti	t**u@g**m	286
Carlos Martín Nieto	c**n@d**e	209
Brian Lopez	s**z@g**m	115
Nikolai Vladimirov	n**y@v**m	99
Scott Chacon	s**n@g**m	65
Ted Nyman	t**d@t**o	46
Aaron Patterson	a**n@g**m	40
Matt Burke	s**s@g**m	33
Edward Thomson	e**n@g**m	24
Scott J. Goldman	s**g@g**m	21
Andy Delcambre	a**y@g**m	19
Viktor Charypar	c**r@g**m	12
Ben Toews	m****i	10
Matt Hodgson	m**n@m**m	8
Dawa Ometto	d**o@p**l	8
Bart Kamphorst	b**t@k**m	7
DawidJanczak	d**k@g**m	7
Michael Ding	d**n@f**g	6
Aaron Quint	a**n@q**m	5
Albert Sun	A**n@n**m	5
Justin Love	g**t@J**e	5
Zach Holman	z**h@z**m	5
Mindaugas Mozūras	m**s@g**m	4
Russell Belfer	rb@g****m	4
Adam Hess	H**r@g**m	4
David Michael Barr	b@r****u	4
Ciro Santilli	c**i@g**m	4
Andy Delcambre	a**e@g**m	4
and 92 more...

Committer domains:

Issue and Pull Request metadata

Last synced: 3 days ago

Total issues: 61
Total pull requests: 85
Average time to close issues: almost 2 years
Average time to close pull requests: 5 months
Total issue authors: 53
Total pull request authors: 26
Average comments per issue: 2.95
Average comments per pull request: 0.99
Merged pull request: 65
Bot issues: 0
Bot pull requests: 0

Past year issues: 5
Past year pull requests: 5
Past year average time to close issues: N/A
Past year average time to close pull requests: N/A
Past year issue authors: 5
Past year pull request authors: 4
Past year average comments per issue: 2.8
Past year average comments per pull request: 0.4
Past year merged pull request: 0
Past year bot issues: 0
Past year bot pull requests: 0

More stats: https://issues.ecosyste.ms/repositories/lookup?url=https://github.com/libgit2/rugged

Top Issue Authors

dvzrv (4)
33Crypto (3)
ioquatix (2)
radar (2)
mslinn (2)
JoyceBabu (1)
shawnwonolo (1)
ghost (1)
greyltc (1)
benbalter (1)
alexey-igrychev (1)
martinber (1)
abitrolly (1)
umdstu (1)
dideler (1)

Top Pull Request Authors

carlosmn (53)
bryanhelms (2)
Bo98 (2)
petergoldstein (2)
agrare (2)
tjk (2)
brandonweeks (2)
toy (2)
djberg96 (1)
mslinn (1)
majioa (1)
HParker (1)
dm9pZCAq (1)
alexjfisher (1)
Caleb-T-Owens (1)

Top Issue Labels

libgit2 (3)

Top Pull Request Labels

Package metadata

Total packages: 32
Total downloads:
- rubygems: 172,093,762 total
Total docker downloads: 2,855,302,542
Total dependent packages: 224 (may contain duplicates)
Total dependent repositories: 3,816 (may contain duplicates)
Total versions: 321
Total maintainers: 10

gem.coop: rugged

Rugged is a Ruby bindings to the libgit2 linkable C Git library. This is for testing and using the libgit2 library in a language that is awesome.

Homepage: https://github.com/libgit2/rugged
Documentation: http://www.rubydoc.info/gems/rugged/
Licenses: MIT
Latest release: 1.9.0 (published about 1 year ago)
Last Synced: 2026-03-01T08:28:10.799Z (3 days ago)
Versions: 113
Dependent Packages: 0
Dependent Repositories: 0
Downloads: 86,035,022 Total
Docker Downloads: 1,427,651,271
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Docker downloads count: 0.068%
- Average: 0.094%
- Downloads: 0.309%
Maintainers (8)
- schacon
- rtomayko
- brianmario
- vmg
- carlosmn
- ethomson
- arthurschreiber
- scottjg

rubygems.org: rugged

Rugged is a Ruby bindings to the libgit2 linkable C Git library. This is for testing and using the libgit2 library in a language that is awesome.

Homepage: https://github.com/libgit2/rugged
Documentation: http://www.rubydoc.info/gems/rugged/
Licenses: MIT
Latest release: 1.9.0 (published about 1 year ago)
Last Synced: 2026-03-02T02:32:19.746Z (2 days ago)
Versions: 114
Dependent Packages: 224
Dependent Repositories: 3,816
Downloads: 86,048,821 Total
Docker Downloads: 1,427,651,271
Rankings:
- Dependent packages count: 0.176%
- Docker downloads count: 0.249%
- Downloads: 0.353%
- Dependent repos count: 0.51%
- Average: 0.647%
- Stargazers count: 1.057%
- Forks count: 1.539%
Maintainers (8)
- schacon
- rtomayko
- brianmario
- vmg
- carlosmn
- ethomson
- arthurschreiber
- scottjg

alpine-v3.18: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 1.5.1-r0 (published almost 3 years ago)
Last Synced: 2026-03-01T02:55:53.665Z (3 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 2.562%
- Forks count: 5.122%
- Stargazers count: 5.127%
Maintainers (1)
- jakub@jirutka.cz

alpine-edge: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 1.9.0-r1 (published 11 months ago)
Last Synced: 2026-02-25T04:00:48.128Z (7 days ago)
Versions: 9
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Stargazers count: 5.15%
- Forks count: 6.121%
- Average: 6.478%
- Dependent packages count: 14.641%
Maintainers (1)
- jakub@jirutka.cz

alpine-v3.13: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 1.1.0-r0 (published over 5 years ago)
Last Synced: 2026-02-02T13:07:42.221Z (29 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Stargazers count: 3.274%
- Forks count: 3.95%
- Average: 6.687%
- Dependent packages count: 19.522%
Maintainers (1)
- jakub@jirutka.cz

alpine-v3.12: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 1.0.0-r1 (published almost 6 years ago)
Last Synced: 2026-03-01T00:49:53.982Z (3 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Stargazers count: 2.93%
- Forks count: 3.565%
- Average: 6.991%
- Dependent packages count: 21.468%
Maintainers (1)
- jakub@jirutka.cz

alpine-v3.14: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 1.1.0-r0 (published over 5 years ago)
Last Synced: 2026-03-01T12:06:25.120Z (2 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Stargazers count: 3.343%
- Forks count: 3.878%
- Average: 7.225%
- Dependent packages count: 21.681%
Maintainers (1)
- jakub@jirutka.cz

alpine-v3.9: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 0.27.5-r0 (published about 7 years ago)
Last Synced: 2026-03-02T10:03:47.126Z (1 day ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Stargazers count: 2.646%
- Forks count: 3.211%
- Average: 7.252%
- Dependent packages count: 23.151%
Maintainers (1)
- jakub@jirutka.cz

alpine-v3.11: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 0.28.4.1-r0 (published about 6 years ago)
Last Synced: 2026-03-01T12:14:09.894Z (2 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Stargazers count: 3.149%
- Forks count: 3.583%
- Average: 7.333%
- Dependent packages count: 22.601%
Maintainers (1)
- jakub@jirutka.cz

alpine-v3.8: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 0.27.1-r0 (published over 7 years ago)
Last Synced: 2026-03-01T12:11:09.769Z (2 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Stargazers count: 2.516%
- Forks count: 2.967%
- Average: 7.677%
- Dependent packages count: 25.225%
Maintainers (1)
- jakub@jirutka.cz

proxy.golang.org: github.com/libgit2/rugged

Homepage:
Documentation: https://pkg.go.dev/github.com/libgit2/rugged#section-documentation
Licenses: mit
Latest release: v1.9.0 (published about 1 year ago)
Last Synced: 2026-03-01T08:28:16.821Z (3 days ago)
Versions: 55
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent packages count: 6.999%
- Average: 8.173%
- Dependent repos count: 9.346%

alpine-v3.15: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 1.2.0-r0 (published over 4 years ago)
Last Synced: 2026-03-01T00:55:29.296Z (3 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Stargazers count: 3.632%
- Forks count: 3.954%
- Average: 8.293%
- Dependent packages count: 25.585%
Maintainers (1)
- jakub@jirutka.cz

alpine-v3.16: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 1.4.3-r0 (published almost 4 years ago)
Last Synced: 2026-03-01T00:58:08.297Z (3 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Stargazers count: 3.886%
- Forks count: 4.015%
- Average: 8.803%
- Dependent packages count: 27.311%
Maintainers (1)
- jakub@jirutka.cz

alpine-v3.10: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 0.28.0-r0 (published almost 7 years ago)
Last Synced: 2026-02-02T13:42:43.125Z (29 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Stargazers count: 2.727%
- Forks count: 3.24%
- Average: 8.881%
- Dependent packages count: 29.555%
Maintainers (1)
- jakub@jirutka.cz

alpine-v3.17: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 1.5.0.1-r0 (published over 3 years ago)
Last Synced: 2026-03-01T03:05:21.956Z (3 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Forks count: 4.575%
- Stargazers count: 5.176%
- Average: 9.251%
- Dependent packages count: 27.254%
Maintainers (1)
- jakub@jirutka.cz

gem.coop: mushin_ext_ruggy

a mushin ext of the ruby rugged gem

Homepage: https://github.com/libgit2/rugged
Documentation: http://www.rubydoc.info/gems/mushin_ext_ruggy/
Licenses: MIT
Latest release: 0.2.0 (published about 9 years ago)
Last Synced: 2026-03-01T08:28:10.579Z (3 days ago)
Versions: 2
Dependent Packages: 0
Dependent Repositories: 0
Downloads: 4,960 Total
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 23.227%
- Downloads: 69.682%
Maintainers (1)
- zotherstupidguy

rubygems.org: mushin_ext_ruggy

a mushin ext of the ruby rugged gem

Homepage: https://github.com/libgit2/rugged
Documentation: http://www.rubydoc.info/gems/mushin_ext_ruggy/
Licenses: MIT
Latest release: 0.2.0 (published about 9 years ago)
Last Synced: 2026-02-28T03:38:09.224Z (4 days ago)
Versions: 2
Dependent Packages: 0
Dependent Repositories: 0
Downloads: 4,959 Total
Rankings:
- Stargazers count: 0.942%
- Forks count: 1.417%
- Dependent packages count: 15.706%
- Average: 27.789%
- Dependent repos count: 46.782%
- Downloads: 74.099%
Maintainers (1)
- zotherstupidguy

alpine-v3.22: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 1.9.0-r1 (published 11 months ago)
Last Synced: 2026-03-01T01:16:43.938Z (3 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%
Maintainers (1)
- jakub@jirutka.cz

debian-13: ruby-rugged

Homepage: https://github.com/libgit2/rugged
Documentation: https://packages.debian.org/trixie/ruby-rugged
Licenses:
Latest release: 1.9.0+ds-1 (published 19 days ago)
Last Synced: 2026-02-13T13:19:24.657Z (18 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%

alpine-v3.20: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 1.7.2-r0 (published almost 2 years ago)
Last Synced: 2026-03-01T01:58:08.194Z (3 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%
Maintainers (1)
- jakub@jirutka.cz

alpine-v3.21: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 1.7.2-r1 (published over 1 year ago)
Last Synced: 2026-03-01T01:29:35.347Z (3 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%
Maintainers (1)
- jakub@jirutka.cz

ubuntu-22.04: ruby-rugged

Homepage: https://github.com/libgit2/rugged
Licenses:
Latest release: 1.2.0+ds-1 (published 18 days ago)
Last Synced: 2026-02-13T13:25:33.834Z (18 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-rugged

Homepage: https://github.com/libgit2/rugged
Documentation: https://packages.debian.org/bookworm/ruby-rugged
Licenses:
Latest release: 1.5.1+ds-1 (published 19 days ago)
Last Synced: 2026-02-12T23:40:35.865Z (19 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:

alpine-v3.23: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 1.9.0-r1 (published 11 months ago)
Last Synced: 2026-02-03T15:56:32.213Z (28 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:

debian-11: ruby-rugged

Homepage: https://github.com/libgit2/rugged
Documentation: https://packages.debian.org/bullseye/ruby-rugged
Licenses:
Latest release: 1.1.0+ds-4 (published 21 days ago)
Last Synced: 2026-02-13T08:24:37.192Z (19 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%

alpine-v3.19: ruby-rugged

Ruby bindings to libgit2

Homepage: https://github.com/libgit2/rugged
Licenses: MIT
Latest release: 1.6.3-r1 (published over 2 years ago)
Last Synced: 2026-02-03T13:25:30.876Z (28 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%
Maintainers (1)
- jakub@jirutka.cz

ubuntu-24.10: ruby-rugged

Homepage: https://github.com/libgit2/rugged
Licenses:
Latest release: 1.7.2+ds-1build1 (published 22 days ago)
Last Synced: 2026-02-09T17:13:49.402Z (22 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:

ubuntu-23.10: ruby-rugged

Homepage: https://github.com/libgit2/rugged
Licenses:
Latest release: 1.5.1+ds-1 (published 18 days ago)
Last Synced: 2026-02-13T18:32:27.408Z (18 days 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-rugged

Homepage: https://github.com/libgit2/rugged
Licenses:
Latest release: 0.28.4.1+ds-1build1 (published 19 days ago)
Last Synced: 2026-02-13T07:22:20.024Z (19 days 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-rugged

Homepage: https://github.com/libgit2/rugged
Licenses:
Latest release: 1.5.1+ds-1 (published 21 days ago)
Last Synced: 2026-02-11T06:49:09.558Z (21 days 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-rugged

Homepage: https://github.com/libgit2/rugged
Licenses:
Latest release: 1.7.1+ds-1build2 (published 25 days ago)
Last Synced: 2026-02-06T16:00:43.180Z (25 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:

debian-10: ruby-rugged

Homepage: https://github.com/libgit2/rugged
Documentation: https://packages.debian.org/buster/ruby-rugged
Licenses:
Latest release: 0.27.4+ds-1 (published 20 days ago)
Last Synced: 2026-02-13T04:25:36.315Z (19 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%

Dependencies

Gemfile rubygems

rubysl ~> 2.0

rugged.gemspec rubygems

minitest ~> 5.0 development
pry >= 0 development
rake-compiler >= 0.9.0 development

.github/workflows/ci.yml actions

actions/checkout master composite
ruby/setup-ruby v1 composite

Score: 34.42278825155976