rugged 0.1.2 → 0.16.0b1

data/README.md

@@ -11,6 +11,8 @@ First you need to install libgit2:
 
     $ git clone git://github.com/libgit2/libgit2.git
     $ cd libgit2
+    $ mdkir build && cd build
+    $ cmake ..
     $ make
     $ make install
 
@@ -32,8 +34,8 @@ API
 There is a general library for some basic Gitty methods.  So far, just converting
 a raw sha (20 bytes) into a readable hex sha (40 char).
 
-    raw = Rugged::Lib.hex_to_raw(hex_sha)
-    hex = Rugged::Lib.raw_to_hex(20_byte_raw_sha)
+    raw = Rugged.hex_to_raw(hex_sha)
+    hex = Rugged.raw_to_hex(20_byte_raw_sha)
 
 
 Repository Access
@@ -74,22 +76,20 @@ but all of these methods should be useful in it's derived classes
     # the repository and instantiated
     # If the 'sha' ID of the object is missing, the object will be
     # created in memory and can be written later on to the repository
-    Rugged::Object(repo, sha)
-      obj.sha
+    Rugged::Object.new(repo, sha)
+      obj.oid
       obj.type
 
       str = obj.read_raw	# read the raw data of the object
-      sha = obj.write		# write the object to a repository
-
 
 The next classes are for consuming and creating the 4 base
-git object types.  just about every method should be able to take
-of each should be able to take a parameter to change the value
-so the object can be re-written slightly differently or no parameter
-to simply read the current value out
+git object types. Just about every method should be able to take
+a parameter to change the value so the object can be re-written 
+slightly different or no parameter to simply read the current 
+value out.
 
-    gobjc =
-    Rugged::Commit.new < Rugged::Object
+    gobjc = Rugged::Commit.new
+    # Rugged::Commit.new < Rugged::Object
       str   = gobjc.message
       str   = gobjc.message_short
       str   = gobjc.message_body # TODO
@@ -97,18 +97,18 @@ to simply read the current value out
       prsn  = gobjc.committer
       gobjr = gobjc.tree
       sha   = gobjc.tree_sha
-      arr   = gobjc.parents [*] # TODO
+      arr   = gobjc.parents [*] # TODO: write
 
-    gobtg =
-    Rugged::Tag.new < Rugged::Object
+    gobtg = Rugged::Tag.new
+    # Rugged::Tag.new < Rugged::Object
       gobj  = gobtg.target
       int   = gobtg.target_type
       str   = gobtg.name
       prsn  = gobtg.tagger
       str   = gobtg.message
 
-    gobtr =
-    Rugged::Tree.new < Rugged::Object
+    gobtr = Rugged::Tree.new
+    # Rugged::Tree.new < Rugged::Object
               gobtr.add(ent) # TODO
               gobtr.remove(name) # TODO
       int   = gobtr.entry_count
@@ -133,10 +133,11 @@ objects, one at a time. You can also hide() commits if you are not interested in
 anything beneath them (useful for a `git log master ^origin/master` type deal).
 
     walker = 
-    Rugged::Walker.new(repo) 
+    Rugged::Walker.new(repo)
+             walker.walk { |c| puts c.inspect } # walk is just an alias of each
+             walker.each { |c| puts c.inspect } 
              walker.push(hex_sha_interesting)
              walker.hide(hex_sha_uninteresting)
-      cmt  = walker.next # false if none left
              walker.reset
 
 
@@ -151,29 +152,17 @@ of manually opening the Index by its path.
     # TODO: the remove and add functions immediately flush to the index file on disk
     index =
     Rugged::Index.new(path)
-            index.refresh              # re-read the index file from disk
-      int = index.entry_count # count of index entries
+            index.reload              # re-read the index file from disk
+      int = index.count # count of index entries
+            index.entries # collection of index entries
+            index.each { |i| puts i.inspect }
       ent = index.get_entry(i/path)
             index.remove(i/path)
             index.add(ientry)    # also updates existing entry if there is one
             index.add(path)      # create ientry from file in path, update index
       #TODO index.read_tree(gobtr, path='/')
       #TODO index.write_tree
-    
-    ientry = 
-    Rugged::IndexEntry.new(index, offset)
-      str = ientry.path
-     time = ientry.ctime
-     time = ientry.mtime
-      str = ientry.sha
-      int = ientry.dev
-      int = ientry.ino
-      int = ientry.mode
-      int = ientry.uid
-      int = ientry.gid
-      int = ientry.file_size
-      int = ientry.flags # (what flags are available?)
-      int = ientry.flags_extended # (what flags are available?)
+ 
 
 Index Status # TODO
 -------------------

data/Rakefile

@@ -1,31 +1,34 @@
-# stolen largely from defunkt/mustache
 require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/extensiontask'
 
-Rake::ExtensionTask.new('rugged') do |r|
-  r.lib_dir = 'lib/rugged'
-end
-
-#
-# Helpers
-#
+begin
+  require 'rake/extensiontask'
+rescue LoadError
+  abort <<-error
+  rake-compile is missing; Rugged depends on rake-compiler to build the C wrapping code.
 
-def command?(command)
-  system("type #{command} > /dev/null")
+  Install it by running `gem i rake-compiler`
+error
 end
 
+Rake::ExtensionTask.new('rugged') do |r|
+  r.lib_dir = 'lib/rugged'
+end
 
 #
 # Tests
 #
+task :default => [:compile, :test]
 
-task :default => :test
+task :pack_dist do
+  dir = File.dirname(File.expand_path(__FILE__))
+  output = File.join(dir, 'ext', 'rugged', 'vendor', 'libgit2-dist.tar.gz')
+  Dir.chdir(ENV['LIBGIT2_PATH']) do
+    `git archive --format=tar --prefix=libgit2-dist/ HEAD | gzip > #{output}`
+  end
+end
 
-desc "Run tests"
-task :turn do
-  suffix = "-n #{ENV['TEST']}" if ENV['TEST']
-  sh "turn test/*_test.rb #{suffix}"
+task :cover do
+  ruby 'test/coverage/cover.rb'
 end
 
 Rake::TestTask.new do |t|
@@ -33,84 +36,3 @@ Rake::TestTask.new do |t|
   t.pattern = 'test/**/*_test.rb'
   t.verbose = false
 end
-
-if command? :kicker
-  desc "Launch Kicker (like autotest)"
-  task :kicker do
-    puts "Kicking... (ctrl+c to cancel)"
-    exec "kicker -e rake test lib"
-  end
-end
-
-desc "Update the libgit2 SHA"
-task :libgit do
-  sha = `git --git-dir=../libgit2/.git rev-parse HEAD`
-  File.open("LIBGIT2_VERSION", 'w') do |f|
-    f.puts "# git --git-dir=../libgit2/.git rev-parse HEAD"
-    f.puts sha
-  end
-end
-
-
-#
-# Ron
-#
-
-if command? :ronn
-  desc "Show the manual"
-  task :man => "man:build" do
-    exec "man man/mustache.1"
-  end
-
-  desc "Build the manual"
-  task "man:build" do
-    sh "ronn -br5 --organization=SCHACON --manual='Rugged Manual' man/*.ron"
-  end
-end
-
-
-#
-# Gems
-#
-
-begin
-  require 'mg'
-  MG.new("rugged.gemspec")
-
-  desc "Push a new version to Gemcutter and publish docs."
-  task :publish => "gem:publish" do
-    require File.dirname(__FILE__) + '/lib/mustache/version'
-
-    system "git tag v#{Rugged::Version}"
-    sh "git push origin master --tags"
-    sh "git clean -fd"
-    exec "rake pages"
-  end
-rescue LoadError
-  warn "mg not available."
-  warn "Install it with: gem i mg"
-end
-
-#
-# Documentation
-#
-
-desc "Publish to GitHub Pages"
-task :pages => [ "man:build" ] do
-  Dir['man/*.html'].each do |f|
-    cp f, File.basename(f).sub('.html', '.newhtml')
-  end
-
-  `git commit -am 'generated manual'`
-  `git checkout site`
-
-  Dir['*.newhtml'].each do |f|
-    mv f, f.sub('.newhtml', '.html')
-  end
-
-  `git add .`
-  `git commit -m updated`
-  `git push site site:master`
-  `git checkout master`
-  puts :done
-end

data/ext/rugged/extconf.rb

@@ -1,9 +1,49 @@
 require 'mkmf'
 
-dir_config("rugged")
+def sys(cmd)
+  puts " -- #{cmd}"
+  unless ret = xsystem(cmd)
+    raise "ERROR: '#{cmd}' failed"
+  end
+  ret
+end
 
-have_library("git2")
-have_library('z')
+if `which make`.strip.empty?
+  STDERR.puts "ERROR: GNU make is required to build Rugged"
+  exit(1)
+end
 
-create_makefile("rugged/rugged")
+if p = ENV['LIBGIT2_PATH']
+  $INCFLAGS[0,0] = " -I#{File.join(p, 'include')} "
+  $LDFLAGS << " -L#{p} "
+
+  unless have_library 'git2' and have_header 'git2.h'
+    STDERR.puts "ERROR: Invalid `LIBGIT2_PATH` environment"
+    exit(1)
+  end
+else
+  CWD = File.expand_path(File.dirname(__FILE__))
+
+  LIBGIT2_DIST = 'libgit2-dist.tar.gz'
+  LIBGIT2_DIR = File.basename(LIBGIT2_DIST, '.tar.gz')
+
+  Dir.chdir("#{CWD}/vendor") do
+    FileUtils.rm_rf(LIBGIT2_DIR) if File.exists?(LIBGIT2_DIR)
 
+    sys("tar zxvf #{LIBGIT2_DIST}")
+    Dir.chdir(LIBGIT2_DIR) do
+      sys("make -f Makefile.embed")
+      FileUtils.cp "libgit2.a", "#{CWD}/libgit2_embed.a"
+    end
+  end
+
+  $INCFLAGS[0,0] = " -I#{CWD}/vendor/#{LIBGIT2_DIR}/include "
+  $LDFLAGS << " -L#{CWD} "
+
+  unless have_library 'git2_embed' and have_header 'git2.h'
+    STDERR.puts "ERROR: Failed to build libgit2"
+    exit(1)
+  end
+end
+
+create_makefile("rugged/rugged")

data/ext/rugged/remote.c

@@ -0,0 +1,215 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2011 GitHub, Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "rugged.h"
+
+extern VALUE rb_mRugged;
+extern VALUE rb_cRuggedRepo;
+VALUE rb_cRuggedRemote;
+
+static void rb_git_remote__free(git_remote *remote)
+{
+	git_remote_free(remote);
+}
+
+static VALUE rb_git_remote__new(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE rb_remote, rb_repo, rb_url, rb_name;
+	git_remote *remote;
+	git_repository *repo;
+	const char *url;
+	int error;
+
+	rb_scan_args(argc, argv, "21", &rb_repo, &rb_url, &rb_name);
+
+	Check_Type(rb_url, T_STRING);
+
+	if (!rb_obj_is_instance_of(rb_repo, rb_cRuggedRepo))
+		rb_raise(rb_eTypeError, "Expecting a Rugged Repository");
+
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	url = StringValueCStr(rb_url);
+
+	if (git_remote_valid_url(url)) {
+		if (!NIL_P(rb_name))
+			Check_Type(rb_name, T_STRING);
+
+		error = git_remote_new(
+			&remote,
+			repo,
+			StringValueCStr(rb_url),
+			NIL_P(rb_name) ? NULL : StringValueCStr(rb_name)
+		);
+	} else {
+		error = git_remote_load(&remote, repo, url);
+	}
+
+	rugged_exception_check(error);
+
+	rb_remote = Data_Wrap_Struct(klass, NULL, &rb_git_remote__free, remote);
+	rugged_set_owner(rb_remote, rb_repo);
+	return rb_remote;
+}
+
+static VALUE rb_git_remote_disconnect(VALUE self)
+{
+	git_remote *remote;
+	Data_Get_Struct(self, git_remote, remote);
+
+	git_remote_disconnect(remote);
+	return Qnil;
+}
+
+static VALUE rb_git_remote_connect(VALUE self, VALUE rb_direction)
+{
+	int error, direction = 0;
+	git_remote *remote;
+	ID id_direction;
+
+	Data_Get_Struct(self, git_remote, remote);
+
+	Check_Type(rb_direction, T_SYMBOL);
+	id_direction = SYM2ID(rb_direction);
+
+	if (id_direction == rb_intern("fetch"))
+		direction = GIT_DIR_FETCH;
+	else if (id_direction == rb_intern("push"))
+		direction = GIT_DIR_PUSH;
+	else
+		rb_raise(rb_eTypeError,
+			"Invalid remote direction. Expected `:fetch` or `:push`");
+
+	error = git_remote_connect(remote, direction);
+	rugged_exception_check(error);
+
+	if (rb_block_given_p())
+		rb_ensure(rb_yield, self, rb_git_remote_disconnect, self);
+
+	return Qnil;
+}
+
+static VALUE rugged_rhead_new(git_remote_head *head)
+{
+	VALUE rb_head = rb_hash_new();
+
+	rb_hash_aset(rb_head, CSTR2SYM("local?"), head->local ? Qtrue : Qfalse);
+	rb_hash_aset(rb_head, CSTR2SYM("oid"), rugged_create_oid(&head->oid));
+	rb_hash_aset(rb_head, CSTR2SYM("loid"), rugged_create_oid(&head->loid));
+	rb_hash_aset(rb_head, CSTR2SYM("name"), rugged_str_new2(head->name, NULL));
+
+	return rb_head;
+}
+
+static int cb_remote__ls(git_remote_head *head, void *payload)
+{
+	rb_funcall((VALUE)payload, rb_intern("call"), 1, rugged_rhead_new(head));
+	return GIT_SUCCESS;
+}
+
+static VALUE rb_git_remote_ls(VALUE self)
+{
+	int error;
+	git_remote *remote;
+	Data_Get_Struct(self, git_remote, remote);
+
+	if (!rb_block_given_p())
+		return rb_funcall(self, rb_intern("to_enum"), 1, CSTR2SYM("ls"));
+
+	error = git_remote_ls(remote, &cb_remote__ls, (void *)rb_block_proc());
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+static VALUE rb_git_remote_name(VALUE self)
+{
+	git_remote *remote;
+	Data_Get_Struct(self, git_remote, remote);
+
+	return rugged_str_new2(git_remote_name(remote), NULL);
+}
+
+static VALUE rb_git_remote_url(VALUE self)
+{
+	git_remote *remote;
+	Data_Get_Struct(self, git_remote, remote);
+
+	return rugged_str_new2(git_remote_url(remote), NULL);
+}
+
+static VALUE rb_git_remote_connected(VALUE self)
+{
+	git_remote *remote;
+	Data_Get_Struct(self, git_remote, remote);
+
+	return git_remote_connected(remote) ? Qtrue : Qfalse;
+}
+
+static VALUE rb_git_remote_download(VALUE self)
+{
+	int error;
+	git_remote *remote;
+	char *path;
+	VALUE rb_path;
+
+	Data_Get_Struct(self, git_remote, remote);
+
+	error = git_remote_download(&path, remote);
+	rugged_exception_check(error);
+
+	rb_path = rugged_str_new2(path, NULL);
+	free(path);
+
+	return rb_path;
+}
+
+static VALUE rb_git_remote_update_tips(VALUE self)
+{
+	int error;
+	git_remote *remote;
+
+	Data_Get_Struct(self, git_remote, remote);
+
+	error = git_remote_update_tips(remote);
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+void Init_rugged_remote()
+{
+	rb_cRuggedRemote = rb_define_class_under(rb_mRugged, "Remote", rb_cObject);
+
+	rb_define_singleton_method(rb_cRuggedRemote, "new", rb_git_remote__new, -1);
+
+	rb_define_method(rb_cRuggedRemote, "connect", rb_git_remote_connect, 1);
+	rb_define_method(rb_cRuggedRemote, "disconnect", rb_git_remote_disconnect, 0);
+	rb_define_method(rb_cRuggedRemote, "name", rb_git_remote_name, 0);
+	rb_define_method(rb_cRuggedRemote, "url", rb_git_remote_url, 0);
+	rb_define_method(rb_cRuggedRemote, "connected?", rb_git_remote_connected, 0);
+	rb_define_method(rb_cRuggedRemote, "ls", rb_git_remote_ls, 0);
+	rb_define_method(rb_cRuggedRemote, "download", rb_git_remote_download, 0);
+	rb_define_method(rb_cRuggedRemote, "update_tips!", rb_git_remote_update_tips, 0);
+}