在线时间:8:00-16:00
迪恩网络APP
随时随地掌握行业动态
扫描二维码
关注迪恩网络微信公众号
Ruggedlibgit2 bindings in Ruby Rugged is a library for accessing libgit2 in Ruby. It gives you the speed andportability of libgit2 with the beauty of the Ruby language. libgit2libgit2 is a pure C implementation of the Git core methods. It's designed to befast and portable. For more information about libgit2,check out libgit2's website or browse thelibgit2 organization on GitHub. InstallRugged is a self-contained gem. You can install it by running: $ gem install rugged You need to have CMake and $ brew install cmake pkg-config Please follow the above in case installation of the gem fails with If you want to build Rugged with HTTPS and SSH support, check out the list of optional libgit2 dependencies. If you're using bundler and want to bundle gem 'rugged', git: 'git://github.com/libgit2/rugged.git', submodules: true To load Rugged, you'll usually want to add something like this: require 'rugged' Use the system provided libgit2By default, Rugged builds and uses a bundled version of libgit2. If youwant 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-librariesbundle install However, note that Rugged does only support specific versions of libgit2. UsageRugged gives you access to the many parts of a Git repository. You can read andwrite objects, walk a tree, access the staging area, and lots more. Let's lookat each area individually. RepositoriesInstantiationThe repository is naturally central to Git. Rugged has a repo = Rugged::Repository.new('path/to/my/repository')# => #<Rugged::Repository:2228536260 {path: "path/to/my/repository/.git/"}> You can create a new repository with Rugged::Repository.init_at('.', :bare) You can also let Rugged discover the path to the .git directory if you give it asubdirectory. Rugged::Repository.discover("/Users/me/projects/repo/lib/subdir/")# => "/Users/me/projects/repo/.git/" Once your Repository instantiated (in the following examples, as Accessing a Repository# Does the given SHA1 exist in this repository?repo.exists?('07b44cbda23b726e5d54e2ef383495922c024202')# => true# Boolean repository state values:repo.bare?# => falserepo.empty?# => truerepo.head_unborn?# => falserepo.head_detached?# => false# Path accessorsrepo.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 objectobject = repo.read('a0ae5566e3c8a3bddffab21022056f0b5e03ef07')# => #<Rugged::OdbObject:0x109a64780>object.len# => 237object.data# => "tree 76f23f186076fc291742816721ea8c3e95567241\nparent 8e3c5c52b8f29da0adc7e8be8a037cbeaea6de6b\nauthor Vicent Mart\303\255 <[email protected]> 1333859005 +0200\ncommitter Vicent Mart\303\255 <[email protected]> 1333859005 +0200\n\nAdd `Repository#blob_at`\n"object.type# => :commit Writing to a RepositoryThere's a few ways to write to a repository. To write directly from yourinstantiated repository object: sha = repo.write(content, type) You can also use the oid = repo.write("This is a blob.", :blob)index = repo.indexindex.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 => "[email protected]", :name => 'Test Author', :time => Time.now }options[:committer] = { :email => "[email protected]", :name => 'Test Author', :time => Time.now }options[:message] ||= "Making a commit via Rugged!"options[:parents] = repo.empty? ? [] : [ repo.head.target ].compactoptions[:update_ref] = 'HEAD'Rugged::Commit.create(repo, options) Objects
obj = repo.lookup(sha)obj.oid # object shaobj.type # One of :commit, :tree, :blob or :tagrobj = obj.read_rawstr = robj.dataint = robj.len There are four base object types in Git: blobs, commits, tags, andtrees. Each of these object types have a corresponding class within Rugged. Commit Objectscommit = repo.lookup('a0ae5566e3c8a3bddffab21022056f0b5e03ef07')# => #<Rugged::Commit:2245304380>commit.message# => "Add `Repository#blob_at`\n"commit.time# => Sat Apr 07 21:23:25 -0700 2012commit.author# => {:email=>"[email protected]", :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=>"[email protected]", :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 Objectstag = repo.lookup(tag_sha)object = tag.targetsha = tag.target.oidstr = tag.target_type # :commit, :tag, :blobstr = tag.name # "v1.0"str = tag.messageperson = tag.tagger Tree Objectstree = repo.lookup('779fbb1e17e666832773a9825875300ea736c2da')# => #<Rugged::Tree:2245194360># number of tree entriestree.counttree[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 subdirstree.each_blob { |entry| puts entry[:name] } # list only files You can also write trees with the 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.writeoptions[:author] = { :email => "[email protected]", :name => 'Test Author', :time => Time.now }options[:committer] = { :email => "[email protected]", :name => 'Test Author', :time => Time.now }options[:message] ||= "Making a commit via Rugged!"options[:parents] = repo.empty? ? [] : [ repo.head.target ].compactoptions[:update_ref] = 'HEAD'Rugged::Commit.create(repo, options) Blob ObjectsBlob 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 ObjectsThere is currently no way to stream data from a blob, because If you need to access a Blob object through an IO-like API, you can wrap it with the # Sinatra endpointget "/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 endend Commit Walker
You first push head SHAs onto the walker, and then call next to get a list ofthe reachable commit objects one at a time. You can also walker = Rugged::Walker.new(repo)walker.sorting(Rugged::SORT_TOPO | Rugged::SORT_REVERSE) # optionalwalker.push(hex_sha_interesting)walker.hide(hex_sha_uninteresting)walker.each { |c| puts c.inspect }walker.reset Index ("staging") areaWe can inspect and manipulate the Git Index as well. To work with the indexinside an existing repository, instantiate it by using the 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) RefsYou can access references through the ref = repo.references["refs/heads/master"]sha = ref.target_idstr = ref.type # :directstr = ref.name # "refs/heads/master" You can also easily iterate over all references: repo.references.each do |ref| puts ref.nameend Or only over references that match the given pattern (glob): repo.references.each("refs/tags/*") do |ref| puts ref.nameend 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.firstsha = entry[:id_old]sha = entry[:id_new]str = entry[:message]prsn = entry[:committer] BranchesThe 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... DiffsThere are various ways to get hands on diffs: # Diff between two subsequent commitsdiff_commits = commit_object.parents[0].diff(commit_object)# Diff between two tree objectsdiff_trees = tree_object_a.diff(tree_object_b)# Diff between index/staging and current working directorydiff_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 patchdiff.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 :renameddiff.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 appliedfile = File.open('/some/file', 'w')diff.write_patch(file)file.close Config filesIt's also easy to read and manipulate the Git config file data with Rugged. # Read valuesrepo.config['core.bare']# Set valuesrepo.config['user.name'] = true# Delete valuesrepo.config.delete('user.name') General methodsRugged also includes a general library for handling basic Git operations. One ofthese is converting a raw sha (20 bytes) into a readable hex sha (40characters). 全部评论
专题导读
上一篇:gitlist: An elegant and modern git repository viewer发布时间:2022-02-13下一篇:ungit: The easiest way to use git. On any platform. Anywhere.发布时间:2022-02-13热门推荐
热门话题
阅读排行榜
|
请发表评论