hglib 0.2.0 → 0.3.0

data/spec/hglib/repo/id_spec.rb

@@ -2,16 +2,28 @@
 
 require_relative '../../spec_helper'
 
+require 'securerandom'
+require 'pathname'
 require 'hglib/repo/id'
 
 
-RSpec.describe Hglib::Repo::Id do
+RSpec.describe Hglib::Repo::Id, :requires_binary do
+
+	let( :repo_dir ) do
+		Pathname( Dir.mktmpdir(['hglib', 'repodir']) )
+	end
+	let( :repo ) { Hglib.init(repo_dir) }
+	let( :fake_sha ) { Random.bytes(20).unpack1('h*') }
+
 
 	it "can be created for an empty repo" do
-		result = described_class.new( '000000000000', 'tip' )
+		result = repo.id
 
-		expect( result.global ).to eq( '000000000000' )
-		expect( result ).to eq( '000000000000' )
+		expect( result.id ).to eq( described_class::DEFAULT_ID )
+		expect( result ).to eq( described_class::DEFAULT_ID )
+		expect( result.parents ).to contain_exactly( described_class::DEFAULT_ID )
+		expect( result.branch ).to eq( described_class::DEFAULT_BRANCH )
+		expect( result.node ).to eq( described_class::DEFAULT_NODE )
 		expect( result.tags ).to contain_exactly( 'tip' )
 		expect( result.bookmarks ).to be_empty
 		expect( result ).to_not have_uncommitted_changes
@@ -19,10 +31,17 @@ RSpec.describe Hglib::Repo::Id do
 
 
 	it "can be created for a repo with commits" do
-		result = described_class.new( 'd03a659966ec', 'tip' )
+		newfile = repo_dir + 'README.md'
+		newfile.write( <<~END_OF_FILE )
+		There is nothing to see here.
+		END_OF_FILE
+
+		repo.addr
+		repo.commit( message: "Add stuff." )
 
-		expect( result.global ).to eq( 'd03a659966ec' )
-		expect( result ).to eq( 'd03a659966ec' )
+		result = repo.id
+
+		expect( result.id ).to match( /\A\p{XDigit}{40}\z/ )
 		expect( result.tags ).to contain_exactly( 'tip' )
 		expect( result.bookmarks ).to be_empty
 		expect( result ).to_not have_uncommitted_changes
@@ -30,43 +49,26 @@ RSpec.describe Hglib::Repo::Id do
 
 
 	it "can be created for a repo with uncommitted changes" do
-		result = described_class.new( 'd03a659966ec', 'tip', uncommitted_changes: true )
-
-		expect( result.global ).to eq( 'd03a659966ec' )
-		expect( result ).to have_uncommitted_changes
-	end
-
-
-	it "can be created for a repo with more than one tag" do
-		result = described_class.new( 'd03a659966ec', 'qbase', 'qtip', 'repo-features.patch', 'tip' )
-
-		expect( result.global ).to eq( 'd03a659966ec' )
-		expect( result.tags ).to contain_exactly( 'qbase', 'qtip', 'repo-features.patch', 'tip' )
-	end
-
+		newfile = repo_dir + 'README.md'
+		newfile.write( <<~END_OF_FILE )
+		There is more nothing to see here.
+		END_OF_FILE
 
-	it "can be created for a repo with a bookmark" do
-		result = described_class.new( 'd03a659966ec', 'tip', bookmarks: 'master' )
+		repo.add
+		result = repo.id
 
-		expect( result.global ).to eq( 'd03a659966ec' )
-		expect( result.bookmarks ).to contain_exactly( 'master' )
-	end
-
-
-	it "can be created for a repo with more than one bookmark" do
-		result = described_class.new( 'd03a659966ec', 'tip', bookmarks: ['master', 'github/master'] )
-
-		expect( result.global ).to eq( 'd03a659966ec' )
-		expect( result.bookmarks ).to contain_exactly( 'master', 'github/master' )
+		expect( result.id ).to match( /\A\p{XDigit}{40}\z/ )
+		expect( result ).to have_uncommitted_changes
 	end
 
 
 	describe "equality" do
 
 		it "is equal to an object of the same class with the same values" do
-			id = described_class.new( 'd03a659966ec',
-				'qbase', 'qtip', 'repo-features.patch', 'tip',
-				uncommitted_changes: true,
+			id = described_class.new(
+				id: fake_sha,
+				tags: ['qbase', 'qtip', 'repo-features.patch', 'tip'],
+				dirty: '+',
 				bookmarks: ['master', 'live']
 			)
 
@@ -77,103 +79,63 @@ RSpec.describe Hglib::Repo::Id do
 
 
 		it "is equal to the String that contains the same revision identifier" do
-			id = described_class.new( 'd03a659966ec',
-				'qbase', 'qtip', 'repo-features.patch', 'tip',
-				uncommitted_changes: true,
-				bookmarks: ['master', 'live']
-			)
+			id = described_class.new( id: fake_sha )
 
-			expect( id ).to eq( 'd03a659966ec' )
+			expect( id ).to eq( fake_sha )
 		end
 
 	end
 
 
-	describe "parsing server output" do
-
-		it "can parse the server output from an empty repo" do
-			result = described_class.parse( '000000000000 tip' )
-
-			expect( result.global ).to eq( '000000000000' )
-			expect( result ).to eq( '000000000000' )
-			expect( result.tags ).to contain_exactly( 'tip' )
-			expect( result.bookmarks ).to be_empty
-			expect( result ).to_not have_uncommitted_changes
-		end
-
-
-		it "can be parsed from the server output from a repo with commits" do
-			result = described_class.parse( 'd03a659966ec tip' )
-
-			expect( result.global ).to eq( 'd03a659966ec' )
-			expect( result ).to eq( 'd03a659966ec' )
-			expect( result.tags ).to contain_exactly( 'tip' )
-			expect( result.bookmarks ).to be_empty
-			expect( result ).to_not have_uncommitted_changes
-		end
-
-
-		it "can be parsed from the server output from a repo with uncommitted changes" do
-			result = described_class.parse( 'd03a659966ec+ tip' )
-
-			expect( result.global ).to eq( 'd03a659966ec' )
-			expect( result ).to have_uncommitted_changes
-		end
-
+	describe "stringifying" do
 
-		it "can be parsed from the server output from a repo with more than one tag" do
-			result = described_class.parse( 'd03a659966ec qbase/qtip/repo-features.patch/tip' )
+		it "works for the ID of an empty repo" do
+			id = repo.id
 
-			expect( result.global ).to eq( 'd03a659966ec' )
-			expect( result.tags ).to contain_exactly( 'qbase', 'qtip', 'repo-features.patch', 'tip' )
+			expect( id.to_s ).to eq( '0000000000000000000000000000000000000000 tip' )
 		end
 
 
-		it "can be parsed from the server output from a repo with a bookmark" do
-			result = described_class.parse( 'd03a659966ec tip master' )
-
-			expect( result.global ).to eq( 'd03a659966ec' )
-			expect( result.bookmarks ).to contain_exactly( 'master' )
-		end
+		it "works for the ID of a repo with uncommitted changes" do
+			newfile = repo_dir + 'README.md'
+			newfile.write( <<~END_OF_FILE )
+			So much less to see here.
+			END_OF_FILE
 
+			repo.add
 
-		it "can be parsed from the server output from a repo with more than one bookmark" do
-			result = described_class.parse( 'd03a659966ec tip master/servant' )
+			id = repo.id
 
-			expect( result.global ).to eq( 'd03a659966ec' )
-			expect( result.bookmarks ).to contain_exactly( 'master', 'servant' )
+			expect( id.to_s ).to match( /\A\p{XDigit}{40}\+ tip/ )
 		end
 
-	end
-
 
-	describe "stringifying" do
-
-		it "works for the ID of an empty repo" do
-			id = described_class.new( '000000000000', 'tip' )
-
-			expect( id.to_s ).to eq( '000000000000 tip' )
-		end
+		it "works for the ID of a repo with more than one tag" do
+			newfile = repo_dir + 'README.md'
+			newfile.write( "A file." )
 
+			repo.add
+			repo.commit( message: "Added a README" )
+			repo.tag( "v1", "add_readme", "live" )
+			repo.update( rev: '-2' )
 
-		it "works for the ID of a repo with uncommitted changes" do
-			id = described_class.new( 'd03a659966ec', 'tip', uncommitted_changes: true )
+			id = repo.id
 
-			expect( id.to_s ).to eq( 'd03a659966ec+ tip' )
+			expect( id.to_s ).to match( %r(\A\p{XDigit}{40} add_readme/live/v1) )
 		end
 
 
-		it "works for the ID of a repo with more than one tag" do
-			id = described_class.new( 'd03a659966ec', 'qbase', 'qtip', 'repo-features.patch', 'tip' )
-
-			expect( id.to_s ).to eq( 'd03a659966ec qbase/qtip/repo-features.patch/tip' )
-		end
+		it "works for the ID of a repo with a bookmark" do
+			newfile = repo_dir + 'README.md'
+			newfile.write( "A file." )
 
+			repo.add
+			repo.commit( message: "Added a README" )
+			repo.bookmark( "master" )
 
-		it "works for the ID of a repo with a bookmark" do
-			id = described_class.new( 'd03a659966ec', 'tip', bookmarks: 'master' )
+			id = repo.id
 
-			expect( id.to_s ).to eq( 'd03a659966ec tip master' )
+			expect( id.to_s ).to match( %r(\A\p{XDigit}{40} tip master) )
 		end
 
 	end

data/spec/hglib/repo/log_entry_spec.rb

@@ -9,20 +9,20 @@ require 'hglib/repo/log_entry'
 RSpec.describe Hglib::Repo::LogEntry do
 
 	RAW_LOG_ENTRY = {
-		"bookmarks" => ['master'],
-		"branch"    => "default",
-		"date"      => [1526420446, 25200],
-		"desc"      => "Flesh out the features of Repo objects",
-		"node"      => "d4af915821dea2feca29288dc16742c0d41cee8c",
-		"parents"   => ["a366819bd05b8dd995440105340e057528be25e6"],
-		"phase"     => "public",
-		"rev"       => 5,
-		"tags"      => ['github/master', 'tip'],
-		"user"      => "Michael Granger <ged@FaerieMUD.org>"
+		bookmarks: ['master'],
+		branch: "default",
+		date: [1526420446, 25200],
+		desc: "Flesh out the features of Repo objects",
+		node: "d4af915821dea2feca29288dc16742c0d41cee8c",
+		parents: ["a366819bd05b8dd995440105340e057528be25e6"],
+		phase: "public",
+		rev: 5,
+		tags: ['github/master', 'tip'],
+		user: "Michael Granger <ged@FaerieMUD.org>"
 	}.freeze
 
 	VERBOSE_LOG_ENTRY = RAW_LOG_ENTRY.merge(
-		"files"     => %w[.hoerc .ruby-version lib/hglib/repo.rb spec/hglib/repo_spec.rb]
+		files: %w[.hoerc .ruby-version lib/hglib/repo.rb spec/hglib/repo_spec.rb]
 	).freeze
 
 
@@ -62,7 +62,7 @@ RSpec.describe Hglib::Repo::LogEntry do
 		expect( entry.summary ).to eq( 'Flesh out the features of Repo objects' )
 
 		expect( entry.diff ).to be_nil
-		expect( entry.files ).to contain_exactly( *VERBOSE_LOG_ENTRY['files'] )
+		expect( entry.files ).to contain_exactly( *VERBOSE_LOG_ENTRY[:files] )
 	end
 
 end

data/spec/hglib/repo_spec.rb

@@ -19,29 +19,52 @@ RSpec.describe Hglib::Repo do
 	end
 
 
+	it "returns an empty Array if the working directory is clean" do
+		repo = described_class.new( repo_dir )
+
+		expect( server ).to receive( :run_with_json_template ).
+			with( :status, {} ).
+			and_return( [] )
+
+		result = repo.status
+
+		expect( result ).to be_an( Array ).and be_empty
+	end
+
+
 	it "can fetch the status of the working directory" do
 		repo = described_class.new( repo_dir )
 
-		expect( server ).to receive( :run ).with( :status, {} ).
+		expect( server ).to receive( :run_with_json_template ).
+			with( :status, {} ).
 			and_return([
-				"M ",
-				".gems\n",
-				"M ",
-				"lib/hglib/repo.rb\n",
-				"M ",
-				"lib/hglib/server.rb\n",
-				"? ",
-				"coverage/assets/0.10.2/magnify.png\n"
+				{
+					path: "lib/hglib/repo.rb",
+					status: "!"
+				},
+				{
+					path: "a_new_file.txt",
+					status: "?"
+				},
+				{
+					path: "doc/created.rid",
+					status: "?"
+				},
+				{
+					path: "lib/hglib/bepo.rb",
+					status: "?"
+				}
 			])
 
 		result = repo.status
 
-		expect( result ).to be_a( Hash )
-		expect( result ).to include(
-			Pathname('.gems') => 'M',
-			Pathname('lib/hglib/repo.rb') => 'M',
-			Pathname('lib/hglib/server.rb') => 'M',
-			Pathname('coverage/assets/0.10.2/magnify.png') => '?'
+		expect( result ).to be_an( Array )
+		expect( result ).to all( be_a Hglib::Repo::StatusEntry )
+		expect( result.map(&:path) ).to include(
+			Pathname('lib/hglib/repo.rb'),
+			Pathname('a_new_file.txt'),
+			Pathname('doc/created.rid'),
+			Pathname('lib/hglib/bepo.rb'),
 		)
 	end
 
@@ -49,52 +72,56 @@ RSpec.describe Hglib::Repo do
 	it "can fetch the identification of the repository's current revision" do
 		repo = described_class.new( repo_dir )
 
-		expect( server ).to receive( :run ).with( :id, {} ).
-			and_return( ["80d775fc1d2c+ qbase/qtip/repo-features.patch/tip master\n"] )
+		expect( server ).to receive( :run_with_json_template ).
+			with( :identify, nil, {} ).
+			and_return( [{
+				bookmarks: ["v1.1", "live", "master"],
+				branch: "default",
+				dirty: "+",
+				id: "720c115412188539039b87baf57931fb5415a0bf+",
+				node: "ffffffffffffffffffffffffffffffffffffffff",
+				parents: ["720c115412188539039b87baf57931fb5415a0bf"],
+				tags: ["tip"]
+			}] )
 
 		result = repo.id
 
-		expect( result ).to be_a( Hglib::Repo::Id ).and( eq '80d775fc1d2c' )
-		expect( result.tags ).to eq( %w[qbase qtip repo-features.patch tip] )
-		expect( result.bookmarks ).to eq( %w[master] )
+		expect( result ).to be_a( Hglib::Repo::Id ).and( eq '720c115412188539039b87baf57931fb5415a0bf' )
+		expect( result.tags ).to eq( %w[tip] )
+		expect( result.bookmarks ).to eq( %w[v1.1 live master] )
 	end
 
 
 	it "can fetch the log of the repository" do
 		repo = described_class.new( repo_dir )
 
-		expect( server ).to receive( :run ).with( :log, {T: 'json', graph: false} ).
+		expect( server ).to receive( :run_with_json_template ).
+			with( :log, {graph: false} ).
 			and_return([
-				"[",
-				"\n {\n  \"bookmarks\": [],\n  \"branch\": \"default\",\n  \"date\": " +
-				"[1516812073, 28800],\n  \"desc\": \"Make ruby-version less specific\"," +
-				"\n  \"node\": \"81f357f730d9f22d560e4bd2790e7cf5aa5b7ec7\",\n  \"parents\":" +
-				" [\"d6c97f99b012199d9088e85bb0940147446c6a87\"],\n  \"phase\": \"public\",\n " +
-				" \"rev\": 1,\n  \"tags\": [],\n  \"user\": \"Michael Granger" +
-				" <ged@FaerieMUD.org>\"\n }",
-				",",
-				"\n {\n",
-				"  \"bookmarks\": []",
-				",\n",
-				"  \"branch\": \"default\"",
-				",\n",
-				"  \"date\": [1516811121, 28800]",
-				",\n",
-				"  \"desc\": \"Initial commit.\"",
-				",\n",
-				"  \"node\": \"d6c97f99b012199d9088e85bb0940147446c6a87\"",
-				",\n",
-				"  \"parents\": [\"0000000000000000000000000000000000000000\"]",
-				",\n",
-				"  \"phase\": \"public\"",
-				",\n",
-				"  \"rev\": 0",
-				",\n",
-				"  \"tags\": []",
-				",\n",
-				"  \"user\": \"Michael Granger <ged@FaerieMUD.org>\"",
-				"\n }",
-				"\n]\n"
+				{
+					bookmarks: [],
+					branch: "default",
+					date: [1516812073, 28800],
+					desc: "Make ruby-version less specific",
+					node: "81f357f730d9f22d560e4bd2790e7cf5aa5b7ec7",
+					parents: ["d6c97f99b012199d9088e85bb0940147446c6a87"],
+					phase: "public",
+					rev: 1,
+					tags: [],
+					user: "Michael Granger <ged@FaerieMUD.org>"
+				},
+				{
+					bookmarks: [],
+					branch: "default",
+					date: [1516811121, 28800],
+					desc: "Initial commit.",
+					node: "d6c97f99b012199d9088e85bb0940147446c6a87",
+					parents: ["0000000000000000000000000000000000000000"],
+					phase: "public",
+					rev: 0,
+					tags: [],
+					user: "Michael Granger <ged@FaerieMUD.org>"
+				}
 			])
 
 		result = repo.log
@@ -102,5 +129,172 @@ RSpec.describe Hglib::Repo do
 		expect( result ).to be_an( Array ).and( all be_a(Hglib::Repo::LogEntry) )
 	end
 
+
+	it "can fetch a diff of the current working copy of the repository" do
+		repo = described_class.new( repo_dir )
+
+		expect( server ).to receive( :run ).with( :diff, {} ).
+			and_return( "the diff" )
+
+		result = repo.diff
+
+		expect( result ).to eq( "the diff" )
+	end
+
+
+	it "can fetch a diff of particular files" do
+		repo = described_class.new( repo_dir )
+
+		expect( server ).to receive( :run ).with( :diff, 'README.md', 'Rakefile', {} ).
+			and_return( "two files diff" )
+
+		result = repo.diff( 'README.md', 'Rakefile' )
+
+		expect( result ).to eq( "two files diff" )
+	end
+
+
+	it "can add all new files to the repository" do
+		repo = described_class.new( repo_dir )
+
+		expect( server ).to receive( :run ).with( :add, {} )
+
+		result = repo.add
+		expect( result ).to be_truthy
+	end
+
+
+	it "can return the current Mercurial configuration" do
+		repo = described_class.new( repo_dir )
+
+		expect( server ).to receive( :run_with_json_template ).
+			with( :showconfig, {untrusted: false} ).
+			and_return([
+				{
+					name: "progress.delay",
+					source: "/home/jrandom/.hgrc:96",
+					value: "0.1"
+				},
+				{
+					name: "progress.refresh",
+					source: "/home/jrandom/.hgrc:97",
+					value: "0.1"
+				},
+				{
+					name: "progress.format",
+					source: "/home/jrandom/.hgrc:98",
+					value: "topic bar number"
+				},
+				{
+					name: "progress.clear-complete",
+					source: "/home/jrandom/.hgrc:99",
+					value: "True"
+				}
+			])
+
+		result = repo.config
+
+		expect( result ).to be_a( Hglib::Config )
+		expect( result['progress.delay'] ).to eq( '0.1' )
+		expect( result['progress.format'] ).to eq( 'topic bar number' )
+	end
+
+
+	it "can fetch repo aliases" do
+		repo = described_class.new( repo_dir )
+
+		expect( server ).to receive( :run_with_json_template ).
+			with( :paths ).
+			and_return([
+				{name: 'sourcehut', url: 'ssh://hg@hg.sr.ht/~ged/hglib'},
+				{name: 'default', url: 'ssh://hg@deveiate.org/hglib'},
+				{name: 'github', url: 'git+ssh://git@github.com/ged/hglib.git'}
+			])
+
+		result = repo.paths
+
+		expect( result ).to be_a( Hash )
+		expect( result ).to eq(
+			sourcehut: URI('ssh://hg@hg.sr.ht/~ged/hglib'),
+			default: URI('ssh://hg@deveiate.org/hglib'),
+			github: URI('git+ssh://git@github.com/ged/hglib.git')
+		)
+	end
+
+
+	it "can sign revisions" do
+		repo = described_class.new( repo_dir )
+
+		expect( server ).to receive( :run ).
+			with( :sign, nil, {} ).
+			and_return( "signing 47:66d4e21b7018\n" )
+
+		result = repo.sign
+
+		expect( result ).to eq( "signing 47:66d4e21b7018" )
+	end
+
+	describe "version info" do
+
+		let( :version_info ) {[{
+			extensions: [
+				{bundled: true, name: "churn", ver: nil},
+				{bundled: true, name: "convert", ver: nil},
+				{bundled: false, name: "evolve", ver: "9.2.0"},
+				{bundled: true, name: "extdiff", ver: nil},
+				{bundled: true, name: "gpg", ver: nil},
+				{bundled: false, name: "hggit", ver: "0.8.12 (dulwich 0.19.10)"},
+				{bundled: true, name: "strip", ver: nil},
+				{bundled: true, name: "mq", ver: nil},
+				{bundled: false, name: "prompt", ver: nil},
+				{bundled: true, name: "purge", ver: nil},
+				{bundled: true, name: "rebase", ver: nil},
+				{bundled: false, name: "topic", ver: "0.17.0"},
+				{bundled: true, name: "histedit", ver: nil}
+			],
+			ver: "5.1.1"
+		}]}
+
+		before( :each ) do
+			expect( server ).to receive( :run_with_json_template ).
+				with( :version ).
+				and_return( version_info )
+		end
+
+
+		it "can fetch the versions of Mercurial and loaded extensions" do
+			repo = described_class.new( repo_dir )
+
+			result = repo.versions
+
+			expect( result ).to eq( version_info.first )
+		end
+
+
+		it "can fetch the simple version of Mercurial" do
+			repo = described_class.new( repo_dir )
+
+			result = repo.version
+
+			expect( result ).to eq( version_info.first[:ver] )
+		end
+
+
+		it "can fetch the versions of all loaded Mercurial extensions" do
+			repo = described_class.new( repo_dir )
+
+			result = repo.extension_versions
+
+			expect( result ).to be_a( Hash )
+			expect( result ).to include(
+				churn: {bundled: true, ver: nil},
+				evolve: {bundled: false, ver: '9.2.0'},
+				topic: {bundled: false, ver: '0.17.0'},
+				hggit: {bundled: false, ver: "0.8.12 (dulwich 0.19.10)"}
+			)
+		end
+
+	end
+
 end