# File lib/lrun.rb, line 272
def self.available!
  raise LrunError, "#{LRUN_BINARY} not found in PATH. Please install lrun first." unless available?
end

# File lib/lrun.rb, line 267
def self.available?
  !LRUN_PATH.nil?
end

# File lib/lrun.rb, line 148
def self.merge_options(*options)
  # Remove nil
  options.compact!

  # Check type of options
  raise TypeError, 'options should be Hash' unless options.all? { |o| o.is_a? Hash }

  # Merge options
  options.inject({}) do |result, option|
    option.each do |k, v|
      # Remove an option using nil
      if v.nil?
        result.delete k
        next
      end

      # Append to or Replace an option
      case LRUN_OPTIONS[k]
      when 2
        # Append to previous options
        result[k] ||= []
        result[k] += [*v]
      else
        # Overwrite previous option
        result[k] = v
      end
    end
    result
  end
end

# File lib/lrun.rb, line 231
def self.run(commands, options = {})
  # Make sure lrun binary is available
  available!

  # Temp files storing stdout and stderr of target process
  tmp_out = tmp_err = nil

  # Create temp stdout, stderr files if user does not redirect them
  options = options.dup
  options[:stdout] ||= (tmp_out = Tempfile.new("lrun.#{$$}.out")).path
  options[:stderr] ||= (tmp_err = Tempfile.new("lrun.#{$$}.err")).path

  IO.pipe do |rfd, wfd|
    # Keep pid of lrun process for checking its status
    pid = spawn_lrun commands, options, wfd

    # Read fd 3, where lrun write its report
    wfd.close
    report = rfd.read

    # Check if lrun exits normally
    stat = Process.wait2(pid)[-1]
    if stat.signaled? || stat.exitstatus != 0
      raise LrunError, "lrun exits abnormally: #{stat}. #{tmp_err.read unless tmp_err.nil?}"
    end

    # Build and return result
    build_result report, tmp_out, tmp_err, options[:truncate]
  end
ensure
  clean_tmpfile [tmp_out, tmp_err]
end

# File lib/lrun.rb, line 344
def self.build_result(lrun_report, stdout = nil, stderr = nil, truncate = TRUNCATE_OUTPUT_LENGTH)
  report = Hash[lrun_report.lines.map{ |l| l.chomp.split(' ', 2)}]

  # Collect information
  memory = report['MEMORY'].to_i
  cputime = report['CPUTIME'].to_f
  exceed = parse_exceed(report['EXCEED'])
  exitcode = report['EXITCODE'].to_i
  signal = report['SIGNALED'].to_i == 0 ? nil : report['TERMSIG'].to_i
  stdout &&= stdout.read(truncate) || ''
  stderr &&= stderr.read(truncate) || ''

  # Build Result
  Result.new(memory, cputime, exceed, exitcode, signal, stdout, stderr)
end

# File lib/lrun.rb, line 281
def self.clean_tmpfile(temp_files)
  temp_files.each do |file|
    file.unlink rescue nil
  end
end

# File lib/lrun.rb, line 311
def self.expand_option(key, values)
  return nil unless LRUN_OPTIONS.has_key? key

  [*values].map do |value|
    ["--#{key.to_s.gsub('_', '-')}", *value]
  end
end

# File lib/lrun.rb, line 296
def self.expand_options(options)
  raise TypeError, 'expect options to be a Hash' unless options.is_a? Hash

  command_arguments = options.map do |key, values|
    expand_option key, values
  end

  command_arguments.compact.flatten.map(&:to_s)
end

# File lib/lrun.rb, line 364
def self.parse_exceed(report_exceed)
  case report_exceed
  when 'none'
    nil
  when /TIME/
    :time
  when /OUTPUT/
    :output
  when /MEMORY/
    :memory
  else
    raise LrunError, "unexpected EXCEED returned by lrun: #{report['EXCEED']}"
  end
end

# File lib/lrun.rb, line 325
def self.spawn_lrun(commands, options, report_fd)
  # Expand commands if commands is a string
  commands = Shellwords.split(commands) if commands.is_a? String
  raise ArgumentError, 'commands should not be empty' if commands.nil? || commands.empty?

  # Build command line
  command_line = [LRUN_PATH, *expand_options(options), *commands]
  spawn_options = {0 => options[:stdin] || :close,
                   1 => options[:stdout] || (tmp_out = Tempfile.new("lrun.#{$$}.out")).path,
                   2 => options[:stderr] || (tmp_err = Tempfile.new("lrun.#{$$}.err")).path,
                   3 => report_fd.fileno}

  # Keep pid of lrun process for checking its status
  Process.spawn(*command_line, spawn_options)
end