hglib 0.1.pre20180129173049 → 0.1.0

data/lib/hglib/repo/log_entry.rb

@@ -0,0 +1,128 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'time'
+
+require 'hglib/repo' unless defined?( Hglib::Repo )
+
+
+# An entry in a repository's revision log.
+class Hglib::Repo::LogEntry
+	extend Loggability
+
+
+	# Loggability API -- output to the hglib logger
+	log_to :hglib
+
+
+	# {
+	# 	"bookmarks" => [],
+	# 	"branch" => "default",
+	# 	"date" => [1527021225, 25200],
+	# 	"desc" => "Add Assemblage commit script",
+	# 	"node" => "4a1cbb9f8d56abd4e72aa2860eecef718dad48dd",
+	# 	"parents" => ["ac2b07cce0fc307e787a91b9e74b4514f7b71f09"],
+	# 	"phase" => "draft",
+	# 	"rev" => 7,
+	# 	"tags" => [],
+	# 	"user" => "Michael Granger <ged@FaerieMUD.org>"
+	# }
+
+	### Create a new log entry from the raw +entryhash+.
+	def initialize( entryhash )
+		@bookmarks = entryhash[ "bookmarks" ]
+		@branch    = entryhash[ "branch" ]
+		@date      = entryhash[ "date" ]
+		@desc      = entryhash[ "desc" ]
+		@node      = entryhash[ "node" ]
+		@parents   = entryhash[ "parents" ]
+		@phase     = entryhash[ "phase" ]
+		@rev       = entryhash[ "rev" ]
+		@tags      = entryhash[ "tags" ]
+		@user      = entryhash[ "user" ]
+		@date      = entryhash[ "date" ]
+		@files     = entryhash[ "files" ] || []
+	end
+
+
+	######
+	public
+	######
+
+	##
+	# Return the Array of bookmarks corresponding to the entry (if any)
+	attr_reader :bookmarks
+
+	##
+	# Return the name of the branch the commit is on
+	attr_reader :branch
+
+	##
+	# Return the description from the entry
+	attr_reader :desc
+	alias_method :summary, :desc
+
+	##
+	# Return the node (changeset ID) from the entry
+	attr_reader :node
+
+	##
+	# Return the changeset IDs of the parents of the entry
+	attr_reader :parents
+
+	##
+	# Return the phase from the entry
+	attr_reader :phase
+
+	##
+	# Return the revision number from the entry
+	attr_reader :rev
+
+	##
+	# Return the Array of the entry's tags
+	attr_reader :tags
+
+	##
+	# Return the name and email of the committing user
+	attr_reader :user
+
+	##
+	# The diff of the commit, if --patch was specified.
+	attr_reader :diff
+
+	##
+	# The files affected by the commit, if run with `verbose: true`.
+	attr_reader :files
+
+
+	### The Time the revision associated with the entry was committed
+	def date
+		return Time.at( @date[0] )
+	end
+	alias_method :time, :date
+
+
+	### Return the shortened changeset ID (in the form {rev}:{shortnode})
+	def changeset
+		return "%d:%s" % [ self.rev, self.node[0,12] ]
+	end
+
+
+	### Return a human-readable representation of the LogEntry as a String.
+	def inspect
+		parts = []
+		parts += self.tags.map {|t| "##{t}" }
+		parts += self.bookmarks.map {|b| "@#{b}" }
+
+		return "#<%p:#%x %s {%s} %p%s>" % [
+			self.class,
+			self.object_id * 2,
+			self.changeset,
+			self.date,
+			self.summary,
+			parts.empty? ? '' : " " + parts.join(' ')
+		]
+	end
+
+end # class Hglib::Repo::LogEntry
+

data/lib/hglib/server.rb

@@ -0,0 +1,320 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'shellwords'
+require 'loggability'
+require 'hglib' unless defined?( Hglib )
+
+
+# A mercurial server object. This uses the Mercurial Command Server protocol to
+# execute Mercurial commands.
+#
+# Refs:
+# - https://www.mercurial-scm.org/wiki/CommandServer
+#
+class Hglib::Server
+	extend Loggability
+
+
+	# String#unpack template for message headers from the command server
+	HEADER_TEMPLATE = 'aI>'
+
+	# Array#pack template for commands sent to the command server
+	COMMAND_TEMPLATE = 'A*I>A*'
+
+	# Array#pack template for plain messages sent to the command server
+	MESSAGE_TEMPLATE = 'I>A*'
+
+
+	# Loggability API -- send logs to the logger in the top-level module
+	log_to :hglib
+
+
+	### Turn the specified +opthash+ into an Array of command line options.
+	def self::mangle_options( **options )
+		return options.flat_map do |name, val|
+			prefix = name.length > 1 ? '--' : '-'
+			optname = "%s%s" % [ prefix, name.to_s.gsub(/_/, '-') ]
+
+			case val
+			when TrueClass
+				[ optname ]
+			when FalseClass, NilClass
+				[ optname.sub(/\A--/, '--no-') ] if optname.start_with?( '--' )
+			when String
+				if optname.start_with?( '--' )
+					[ "#{optname}=#{val}" ]
+				else
+					[ optname, val ]
+				end
+			else
+				raise ArgumentError, "can't handle command option: %p" % [{ name => val }]
+			end
+		end.compact
+	end
+
+
+	### Create a new Hglib::Server that will be invoked for the specified +repo+.
+	### Any additional +args+ given will be passed to the `hg serve` command
+	### on startup.
+	def initialize( repo=nil, **args )
+		@repo = Pathname( repo ) if repo
+
+		@reader = nil
+		@writer = nil
+
+		@pid = nil
+
+		@byte_input_callback = nil
+		@line_input_callback = nil
+	end
+
+
+	######
+	public
+	######
+
+	##
+	# The Pathname to the repository the server should target
+	attr_reader :repo
+
+	##
+	# The additional arguments to send to the command server on startup
+	attr_reader :args
+
+	##
+	# The reader end of the pipe used to communicate with the command server.
+	attr_accessor :reader
+
+	##
+	# The writer end of the pipe used to communicate with the command server.
+	attr_accessor :writer
+
+	##
+	# The PID of the running command server if there is one
+	attr_accessor :pid
+
+	##
+	# The callable used to fetch byte-oriented input
+	attr_accessor :byte_input_callback
+	protected :byte_input_callback=
+
+	##
+	# The callable used to fetch line-oriented input
+	attr_accessor :line_input_callback
+	protected :line_input_callback=
+
+
+	### Register a +callback+ that will be called when the command server asks for
+	### byte-oriented input. The callback will be called with the (maximum) number
+	### of bytes to return.
+	def on_byte_input( &callback )
+		raise LocalJumpError, "no block given" unless callback
+		self.byte_input_callback = callback
+	end
+
+
+	### Register a +callback+ that will be called when the command server asks for
+	### line-oriented input. The callback will be called with the (maximum) number
+	### of bytes to return.
+	def on_line_input( &callback )
+		raise LocalJumpError, "no block given" unless callback
+		self.line_input_callback = callback
+	end
+
+
+	### Register the callbacks necessary to read both line and byte input from the
+	### specified +io+, which is expected to respond to #gets and #read.
+	def register_input_callbacks( io=$stdin )
+		self.on_byte_input( &io.method(:read) )
+		self.on_line_input( &io.method(:gets) )
+	end
+
+
+	### Run the specified +command+ with the given +args+ via the server and return
+	### the result. If the command requires +input+, the callbacks registered with
+	### #on_byte_input and #on_line_input will be used to read it. If one of these
+	### callbacks is not registered, an IOError will be raised.
+	def run( command, *args, **options )
+		self.log.debug "Running command: %p" % [ Shellwords.join([command.to_s] + args) ]
+		self.start unless self.started?
+
+		done = false
+		output = []
+
+		args.compact!
+		args += self.class.mangle_options( options )
+
+		self.write_command( 'runcommand', command, *args )
+
+		until done
+			channel, data = self.read_message
+
+			case channel
+			when 'o'
+				# self.log.debug "Got command output: %p" % [ data ]
+				output << data
+			when 'r'
+				done = true
+			when 'e'
+				self.log.error "Got command error: %p" % [ data ]
+				raise Hglib::CommandError, data
+			when 'L'
+				self.log.debug "Server requested line input (%d bytes)" % [ data ]
+				input = self.get_line_input( data.to_i )
+				self.write_message( input.chomp + "\n" )
+			when 'I'
+				self.log.debug "Server requested byte input (%d bytes)" % [ data ]
+				input = self.get_byte_input( data.to_i )
+				self.write_message( input )
+			else
+				msg = "Unexpected channel %p" % [ channel ]
+				self.log.error( msg )
+				raise( msg ) if channel =~ /\p{Upper}/ # Mandatory
+			end
+		end
+
+		return output
+	end
+
+
+	### Returns +true+ if the underlying command server has been started.
+	def is_started?
+		return self.pid ? true : false
+	end
+	alias_method :started?, :is_started?
+
+
+	### Open a pipe and start the command server.
+	def start
+		self.log.debug "Starting."
+		self.spawn_server
+		self.read_hello
+	end
+
+
+	### Stop the command server and clean up the pipes.
+	def stop
+		return unless self.started?
+
+		self.log.debug "Stopping."
+		self.writer.close if self.writer
+		self.writer = nil
+		self.reader.close if self.reader
+		self.reader = nil
+		self.stop_server
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Call the #on_line_input callback to read at most +max_bytes+. Raises an
+	### IOError if no callback is registered.
+	def get_line_input( max_bytes )
+		callback = self.line_input_callback or
+			raise IOError, "cannot read input: no line input callback registered"
+
+		return callback.call( max_bytes )
+	end
+
+
+	### Call the #on_byte_input callback to read at most +max_bytes+. Raises an
+	### IOError if no callback is registered.
+	def get_byte_input( max_bytes )
+		callback = self.byte_input_callback or
+			raise IOError, "cannot read input: no byte input callback registered"
+
+		return callback.call( max_bytes )
+	end
+
+
+	### Fork a child and run Mercurial in command-server mode.
+	def spawn_server
+		self.reader, child_writer = IO.pipe
+		child_reader, self.writer = IO.pipe
+
+		cmd = self.server_start_command
+		self.pid = Process.spawn( *cmd, out: child_writer, in: child_reader, close_others: true )
+		self.log.debug "Spawned command server at PID %d" % [ self.pid ]
+
+		child_writer.close
+		child_reader.close
+	end
+
+
+	### Kill the command server if it's running
+	def stop_server
+		if self.pid
+			self.log.debug "Stopping command server at PID %d" % [ self.pid ]
+			Process.kill( :TERM, self.pid )
+			Process.wait( self.pid, Process::WNOHANG )
+			self.pid = nil
+		end
+	end
+
+
+	### Write the specified message to the command server. Raises an exception if
+	### the server is not yet started.
+	def write_command( command, *args )
+		data = args.map( &:to_s ).join( "\0" )
+		message = [ command + "\n", data.bytesize, data ].pack( COMMAND_TEMPLATE )
+		self.log.debug "Writing command %p to command server." % [ message ]
+		self.writer.write( message )
+	end
+
+
+	### Write the specified +message+ to the command server.
+	def write_message( data )
+		message = [ data.bytesize, data ].pack( MESSAGE_TEMPLATE )
+		self.log.debug "Writing message %p to command server." % [ message ]
+		self.writer.write( message )
+	end
+
+
+	### Read the cmdserver's banner.
+	def read_hello
+		_, message = self.read_message
+		self.log.debug "Hello message:\n%s" % [ message ]
+	end
+
+
+	### Read a single channel identifier and message from the command server. Raises
+	### an exception if the server is not yet started.
+	def read_message
+		raise "Server is not yet started" unless self.started?
+		header = self.reader.read( 5 ) or raise "Server aborted."
+		channel, bytes = header.unpack( HEADER_TEMPLATE )
+		self.log.debug "Read channel %p message (%d bytes)" % [ channel, bytes ]
+
+		# Input requested; return the requested length as the message
+		if channel == 'I' || channel == 'L'
+			return channel, bytes
+		end
+
+		self.log.debug "Reading %d more bytes of the message" % [ bytes ]
+		message = self.reader.read( bytes ) unless bytes.zero?
+		self.log.debug "  read message: %p" % [ message ]
+		return channel, message
+	end
+
+
+	### Return the command-line command for starting the command server.
+	def server_start_command
+		cmd = [
+			Hglib.hg_path.to_s,
+			'--config',
+			'ui.interactive=True',
+			'serve',
+			'--cmdserver',
+			'pipe',
+		]
+
+		cmd << '--repository' << self.repo.to_s if self.repo
+
+		return cmd
+	end
+
+
+end # class Hglib::Server

data/spec/.status

@@ -0,0 +1,39 @@
+example_id                               | status | run_time        |
+---------------------------------------- | ------ | --------------- |
+./spec/hglib/repo/id_spec.rb[1:1]        | passed | 0.00013 seconds |
+./spec/hglib/repo/id_spec.rb[1:2]        | passed | 0.00068 seconds |
+./spec/hglib/repo/id_spec.rb[1:3]        | passed | 0.00012 seconds |
+./spec/hglib/repo/id_spec.rb[1:4]        | passed | 0.00011 seconds |
+./spec/hglib/repo/id_spec.rb[1:5]        | passed | 0.00007 seconds |
+./spec/hglib/repo/id_spec.rb[1:6]        | passed | 0.00008 seconds |
+./spec/hglib/repo/id_spec.rb[1:7:1]      | passed | 0.00004 seconds |
+./spec/hglib/repo/id_spec.rb[1:7:2]      | passed | 0.00004 seconds |
+./spec/hglib/repo/id_spec.rb[1:8:1]      | passed | 0.00009 seconds |
+./spec/hglib/repo/id_spec.rb[1:8:2]      | passed | 0.00008 seconds |
+./spec/hglib/repo/id_spec.rb[1:8:3]      | passed | 0.00109 seconds |
+./spec/hglib/repo/id_spec.rb[1:8:4]      | passed | 0.00006 seconds |
+./spec/hglib/repo/id_spec.rb[1:8:5]      | passed | 0.00005 seconds |
+./spec/hglib/repo/id_spec.rb[1:8:6]      | passed | 0.00005 seconds |
+./spec/hglib/repo/id_spec.rb[1:9:1]      | passed | 0.00005 seconds |
+./spec/hglib/repo/id_spec.rb[1:9:2]      | passed | 0.00004 seconds |
+./spec/hglib/repo/id_spec.rb[1:9:3]      | passed | 0.00004 seconds |
+./spec/hglib/repo/id_spec.rb[1:9:4]      | passed | 0.00004 seconds |
+./spec/hglib/repo/log_entry_spec.rb[1:1] | passed | 0.0025 seconds  |
+./spec/hglib/repo/log_entry_spec.rb[1:2] | passed | 0.00022 seconds |
+./spec/hglib/repo_spec.rb[1:1]           | passed | 0.00117 seconds |
+./spec/hglib/repo_spec.rb[1:2]           | passed | 0.00052 seconds |
+./spec/hglib/repo_spec.rb[1:3]           | passed | 0.00748 seconds |
+./spec/hglib/server_spec.rb[1:1:1]       | passed | 0.00038 seconds |
+./spec/hglib/server_spec.rb[1:1:2]       | passed | 0.00164 seconds |
+./spec/hglib/server_spec.rb[1:1:3]       | passed | 0.00039 seconds |
+./spec/hglib/server_spec.rb[1:1:4]       | passed | 0.00039 seconds |
+./spec/hglib/server_spec.rb[1:1:5]       | passed | 0.00076 seconds |
+./spec/hglib/server_spec.rb[1:1:6]       | passed | 0.00052 seconds |
+./spec/hglib/server_spec.rb[1:2]         | passed | 0.00148 seconds |
+./spec/hglib/server_spec.rb[1:3]         | passed | 0.00057 seconds |
+./spec/hglib/server_spec.rb[1:4]         | passed | 0.00139 seconds |
+./spec/hglib/server_spec.rb[1:5]         | passed | 0.00099 seconds |
+./spec/hglib/server_spec.rb[1:6]         | passed | 0.00121 seconds |
+./spec/hglib_spec.rb[1:1:1]              | passed | 0.00104 seconds |
+./spec/hglib_spec.rb[1:1:2]              | passed | 0.0013 seconds  |
+./spec/hglib_spec.rb[1:2:1]              | passed | 0.00097 seconds |