# This file is not a standalone script. It is a kind

# of lightweight Mercurial library used by other scripts.

require 'uri'

require 'open3'

require 'shellwords'

# Following hack is to make hglib.rb working wit both jv:scripts and

# Smalltalk/X rakefiles.

begin

  require 'rakelib/inifile'

rescue

  begin

    require 'inifile'

  rescue LoadError => ex

    $LOGGER.error(%q{Cannot load package 'inifile'})

    $LOGGER.error(%q{Run 'gem install inifile' to install it})

    exit 1

  end

end

unless $LOGGER

  if STDOUT.tty? or win32?

    require 'logger'

    $LOGGER = Logger.new(STDOUT)

    if defined? VERBOSE and !VERBOSE.nil?

      $LOGGER.level = Logger::DEBUG

    else

      $LOGGER.level = Logger::INFO

    end

  else

    require 'syslog/logger'

    $LOGGER = Syslog::Logger.new($0)

  end

end

module HG

  @@config = nil

  class Exception < ::Exception

  end

  class RepositoryNotFoundException < Exception

  end

  # Cross-platform way of finding an executable in the $PATH.

  #

  #   which('ruby') #=> /usr/bin/ruby

  module_function

  def which(cmd)

    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']

    ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|

      exts.each {|ext|

        exe = File.join(path, "#{cmd}#{ext}")

        return exe if File.executable?(exe) && !File.directory?(exe)

      }

    end

    nil

  end

  GLOBAL_OPTIONS = %i(cwd repository noninteractive config debug debugger encoding

                      encodingmode traceback time profile version help hidden

                      )

  # Execute `hg` command with given positional arguments and

  # keyword arguments turned into command options. For example,

  #

  #     HG::hg("heads", "default", cwd: '/tmp/testrepo')

  #

  # will result in executing

  #

  #     hg --cwd '/tmp/testrepo' heads default

  #

  # In addition if block is passed, then the block is evaluate with

  # `hg` command exit status (as Process::Status) and (optionally)

  # with contents of `hg` command stdout and stderr.

  # If no block is given, an exception is raised when `hg` command

  # exit status IS NOT zero.

  def self.hg(command, *args, **options, &block)

    g_opts = []

    c_opts = []

    options.each do |k, v|

      if v != false and !v.nil?

        o = k.size == 1 ? "-#{k}" : "--#{k}"

        if GLOBAL_OPTIONS.include? k

          if v.is_a?(Array)

            v.each do |e|

              g_opts << o << (e == true ? '' : e) # bug ruby: e ? '' : e does not work correctly

            end

          else

            g_opts << o << (v == true ? '' : v)

          end

        else

          if v.is_a?(Array)

            v.each do |e|

              c_opts << o << (e == true ? '' : e)

            end

          else

            c_opts << o << (v == true ? '' : v)

          end

        end

      end

    end

    c_opts.reject! {|e| e.size == 0}

    cmd = ['hg'] + g_opts + [command] + c_opts + args

    cmd_info = cmd.shelljoin.

        gsub(/username\\=\S+/, "username\\=***").

        gsub(/password\\=\S+/, "password\\=***")

    $LOGGER.debug("executing: #{cmd_info}")

    if defined? RakeFileUtils and RakeFileUtils.verbose; puts cmd_info; end

    if block_given?

      stdout, stderr, status = Open3.capture3(*cmd)

      # For command that deal with remotes, handle check whether the failure

      # is because of missing remote repository. If so, raise exception.

      if status.exitstatus == 255

        if stdout =~ /remote:\ *Repository.*not found/ or stderr =~ /abort:.*HTTP.*404/

          raise RepositoryNotFoundException.new("Remote repository not found!")

        end

      end

      case block.arity

      when 1

        STDOUT.print stdout if defined? RakeFileUtils and RakeFileUtils.verbose

        STDERR.print stderr if defined? RakeFileUtils and RakeFileUtils.verbose

        yield status

      when 2

        STDERR.print stderr if defined? RakeFileUtils and RakeFileUtils.verbose

        yield status, stdout

      when 3

        yield status, stdout, stderr

      else

        raise Exception.new("invalid arity of given block")

      end

    else

      raise Exception.new("command failed: #{cmd.join(' ')}") unless system(*cmd)

    end

  end

  def self.config_file(dir, nm)

    path = File.join(dir, nm)

    if File.exist?(path) then

      return [ path ]

    else

      return [ ]

    end

  end

  def self.config_dir(dir, nm)

    path = File.join(dir, nm)

    if File.directory?(path) then

      return Dir.glob("#{path}\\*.rc".gsub('\\', '/'))

    else

      return [ ]

    end

  end

  def self.config

    if @@config.nil?

      files = [] 

      files += HG::config_dir('/etc/mercurial', 'hgrc.d')

      files += HG::config_file('/etc/mercurial', 'hgrc')

      files += [ hgrc ]

      if Gem.win_platform?

        # An excerpt from `hg help config`:

        # On Windows, the following files are consulted:        

        # - "<repo>/.hg/hgrc" (per-repository)                  

        # - "%USERPROFILE%\.hgrc" (per-user)                    

        # - "%USERPROFILE%\Mercurial.ini" (per-user)            

        # - "%HOME%\.hgrc" (per-user)                           

        # - "%HOME%\Mercurial.ini" (per-user)                   

        # - "HKEY_LOCAL_MACHINE\SOFTWARE\Mercurial" (per-system)

        # - "<install-dir>\hgrc.d\*.rc" (per-installation)      

        # - "<install-dir>\Mercurial.ini" (per-installation)    

        # - "%PROGRAMDATA%\Mercurial\hgrc" (per-system)         

        # - "%PROGRAMDATA%\Mercurial\Mercurial.ini" (per-system)

        # - "%PROGRAMDATA%\Mercurial\hgrc.d\*.rc" (per-system)  

        # - "<internal>/*.rc" (defaults)                        

        files += HG::config_file(ENV['USERPROFILE'], '.hgrc')

        files += HG::config_file(ENV['USERPROFILE'], 'Mercurial.ini')

        files += HG::config_file(ENV['HOME'], '.hgrc')

        files += HG::config_file(ENV['HOME'], 'Mercurial.ini')

        install_dir = File.dirname(HG::which("hg"))

        files += HG::config_dir( install_dir, 'hgrc.d')

        files += HG::config_file(install_dir, 'Mercurial.ini')

        files += HG::config_file(ENV['PROGRAMDATA'], '.hgrc')

        files += HG::config_file(ENV['PROGRAMDATA'], 'Mercurial.ini')

        files += HG::config_dir( ENV['PROGRAMDATA'], 'hgrc.d')

        # Following is used by recent TortoiseHg

        files += HG::config_dir( install_dir, 'defaultrc')        

      end

      @@config = IniFile.new

      files.each do |file|

        if File.exist?(file)

          $LOGGER.debug("Loading global config from \"#{file}\"")

          @@config.merge!(IniFile.new(:filename => file))

        end

      end

    end

    return @@config

  end

  def self.hgrc

    return File.expand_path('~/.hgrc')

  end

  class Repository

    @@HOSTS_ON_LAN = {}

    attr_accessor :path, :config

    private

    # Return --ssh config string for use with passed remote url or nil

    # if no special --ssh config is needed.

    #

    # This is used to tweak SSH connection in various ways, but only

    # when `ui.ssh` is not set (or has default value on Windows, see below).

    #

    # Following tweaks are done:

    #

    # 1. On Windows, prefer MSYS2's `ssh.exe` over `plink.exe`.

    #

    #    Most of users tend to use TortoiseHG and hg.exe comming with

    #    it. THG makes hg.exe to use (shipped) plink.exe which is bad for performance

    #    since it uses 16k channel input buffer (!) leading to a pretty slow transfers

    #    (a lot of iowaits...)

    #    OpenSSH OTOH has 2MB input buffer which is good though on Windows bit

    #    oversized as Windows TCP window size is fixed to 65k for all connections with

    #    RTT less than 1ms. Still, 65k better then 16k.

    #    As a workaround, look if MSYS2's OpenSSH client is installed and if so, use that

    #    one - but only if `ui.ssh` config option has the default value.

    #    Ugly, isn't it?

    #

    # 2. If cloning / updating over LAN and using openssh client, add `-C` option to disable compression.

    #

    #    Data transferred by Mercurial are either already compressed or --uncompressed

    #    was given to reduce CPU load in which case passing -C would reduce it further.

    #

    # 3. If cloning / updating non-interactively (from scripts or on CI servers), pass

    #     `-o "StrictHostKeyChecking off"`.

    #

    #    This is to avoid failures on CI due to missing / changed host key. Not the best,

    #    but otherwise we'd have to configure each and every slave's `.ssh/config`

    def self.sshconf(uri_string)

      uri = URI(uri_string)

      ssh = nil

      if uri.scheme == 'ssh'

        ssh_in_path = HG::which('ssh')

        ssh_in_hgrc = HG::config['ui']['ssh']

        if Gem.win_platform?

          # Running on Windows

          #

          # On Windows, MSYS's ssh.exe may not be in the path. Check standard place

          # and update `ssh_in_path`

          if ssh_in_path == nil and File.exist? %q{c:\msys64\usr\bin\ssh.exe} then

            ssh_in_path = %q{"c:\msys64\usr\bin\ssh.exe"}

          end

          # Mercurial uses `ssh` by default, so to use `plink.exe`, `ui.ssh`

          # config option has to be explicitly set.

          #

          # It it's set to `plink.exe`, check whether MSYS's `ssh.exe` is available

          # and if so, change it to `ssh.exe`...

          if /^.*[pP]link.exe"?\s*(-ssh)?\s*(-2)?$/ =~ ssh_in_hgrc

            # Sigh, we should not tamper with SSH configuration wildly. User may have

            # her ssh and mercurial properly configured to use `plink.exe` and `pageant`.

            # If we just start using `ssh.exe` clone/pull might not work beause

            # `ssh.exe` cannot talk to `pageant`. So, if we don't find OpenSSH's

            # style of agent, don't use `ssh.exe` event if available.

            if ssh_in_path

              if ENV['SSH_AUTH_SOCK']

                ssh = ssh_in_path

              else

                # No agent, no fun. Be nice and give user a hit

                $LOGGER.warn("Not using -ssh \"#{ssh}\" option because SSH agent is not running")

                $LOGGER.warn("For faster clone/pull consider using ssh-agent or ssh-pageant (if you want to use PuTTY's pageant)")

                ssh = nil

              end

            end

          end

        else

          # Running on UNIX (actually, anything but Windows)

          #

          # Check if ui.ssh is configured, if not, use custom SSH command.

          # Here we set `ssh` to non-nil value only to pass it through nil-checks

          # below...

          ssh = ssh_in_path

        end

        if ssh

          ssh += " -C" if ssh and HG::Repository::host_on_lan?(uri.host)

          ssh += " -o 'StrictHostKeyChecking off'" if not STDOUT.isatty

        end

      end

      # Be nice and tell the user if SSH configuration has been tampered wirh.

      $LOGGER.info("Passing --ssh \"#{ssh}\" option to 'hg' command for faster transfers") if ssh

      # Done, tricky, wasn't it?

      return ssh

    end

    # Same as class method, but allows for remote aliases

    def sshconf(remote)

      HG::Repository::sshconf(self.paths[remote] || remote)

    end

    # Given a hostname, return true if the host is on local LAN, false

    # otherwise.

    #

    # Results are cached to reduce resolver queries (maybe not worth it,

    # system may cache answers anyways)

    #

    # The detection is rather simplistic - it only checks if host's address

    # is from private IP range - and only for IPv4.

    # This may cause problems when using over VPN that assigns private address

    # (the usuall case). In that case this code will treat is a local

    # which may result in transfer of uncompressed data over WAN. Not nice,

    # This should be fixed, somehow.

    def self.host_on_lan?(hostname)

      unless @@HOSTS_ON_LAN.has_key? hostname

        require 'resolv'

        local = false

        begin

        addr = Resolv.getaddress(hostname)

        # Really poor detection of LAN, but since this is an

        # optimization, getting this wrong does not hurt.

        local = (addr.start_with? '192.168.') or (addr.start_with? '10.10.')

        rescue ArgumentError => ex

          # Maybe not a remote host at all

          local = false

        end

        @@HOSTS_ON_LAN[hostname] = local

      end

      return @@HOSTS_ON_LAN[hostname]

    end

    public

    # Clone a repository from given `uri` to given `directory`.

    # Returns an `HG::Repository` instance representing the repository

    # clone.

    # If `noupdate` is true, working copy is not updated, i.e., will be

    # empty. Use this when you're going to issue `update(rev)` shortly after.

    #

    def self.clone(uri, directory, noupdate: false, publishing: false)

      uri_obj = URI(uri)

      host = uri_obj.host

      scheme = uri_obj.scheme

      # When cloning over LAN, use --uncompressed option

      # as it tends to be faster if bandwidth is good (1GB norm

      # these days) amd saves some CPU cycles.

      local = HG::Repository::host_on_lan?(URI(uri).host)

      ssh = HG::Repository::sshconf(uri)

      HG::hg('clone', uri, directory, ssh: ssh, uncompressed: local, noupdate: noupdate, config: "phases.publish=#{publishing}")

      return HG::Repository.new(directory)

    end

    # Initializes an empty repository in given directory. Returns an

    # `HG::Repository` instance representing the created (empty) repository.

    # TODO: unreachable code!!!

    def self.init(directory)

      HG::hg('init', directory)

      return HG::Repository.new(directory)

    end

    # Like HG::hg, but passes --cwd @path

    def hg(command, *args, **options, &block)

      options[:cwd] = @path

      HG::hg(command, *args, **options, &block)

    end

    def hgrc

      File.join(@path, '.hg', 'hgrc')

    end

    def initialize(directory)

      dir = File.expand_path(directory)

      if not File.exist?(File.join(dir, '.hg'))

        raise Exception.new("Not a Mercurial repository (missing .hg directory): #{dir}")

      end

      @path = dir

      initialize_config

    end

    def initialize_config

      config_file = hgrc

      if File.exist? (config_file)

        $LOGGER.debug("Loading repository config from \"#{config_file}\"")

        @config = HG::config().merge(IniFile.new(:filename => config_file))

      else

        @config = HG::config()

      end

    end

    # Add / replace given config options and write back

    # .hg/hgrc

    def config_set(**options)

      config = IniFile.new(:filename => self.hgrc)

      options.each do |section, keys_and_values|

        keys_and_values.each {|key, value| config[section][key] = value.to_s}

      end

      config.write

      initialize_config

    end

    # Return a hashmap with defined paths (alias => uri)

    def paths

      @config['paths'].clone

    end

    # Set paths for given repository

    def paths=(paths)

      config_set(paths: paths)

    end

    def log(revset, template = "{node|short}\n")

      log = []

      hg('log', rev: revset, template: template) do |status, out|

        if status.success?

          puts out if defined? RakeFileUtils and RakeFileUtils.verbose

          log = out.split("\n")

        end

      end

      return log

    end

    def locate(revset = '.', pattern: '*')

      files = []

      hg('locate', rev: revset, include: pattern) do |status, out|

        if status.success?

          files = out.split("\n")

        end

      end

      return files

    end

    # Return current branch name

    def branch()

      hg('branch') do | status, out |

        if status.success?

          return out.strip()

        end

      end

      raise Exception.new("Failed to retrieve current branch")

    end

    # Return changeset IDs of all head revisions.

    # If `branch` is given, return only heads in given

    # branch.

    # If `secret_secret` is false, then changesets in

    # secret phase are ignored (even if they're heads)

    # If `secret_obsolete` is true, then obsolete changesets

    # are ignored (even if they're heads)

    def heads(branch = nil, include_secret: true, include_obsolete: false)

      revset  = "head()"

      revset += " and branch('#{branch}')" if branch

      revset += " and !secret()" if not include_secret

      revset += " and !obsolete()" if not include_secret

      return log(revset)

    end

    # Return name of an active bookmark or nil if no bookmark

    # is active

    def bookmark

      filename = File.join(@path, '.hg', 'bookmarks.current')

      if File.exist?(filename)

        file = File.open(filename, 'r')

        begin

          bookmark = file.read.chomp

        ensure

          file.close

        end

        bookmark

      else

        nil

      end

    end

    # Return a hash "bookmark => revision" of all