screen.rb

# fronzen_string_literal: true

require_relative 'screen/version'

module TTY
  # Used for detecting screen properties
  #
  # @api public
  module Screen
    # Helper to define private functions
    def self.private_module_function(name)
      module_function(name)
      private_class_method(name)
    end

    # Default terminal size
    #
    # @api public
    DEFAULT_SIZE = [27, 80].freeze

    @env = ENV
    @output = $stderr

    class << self
      attr_accessor :env

      # Specifies an output stream
      #
      # @api public
      attr_accessor :output
    end

    # Get terminal rows and columns
    #
    # @return [Array[Integer, Integer]]
    #   return rows & columns
    #
    # @api public
    def size
      size = size_from_java
      size ||= size_from_win_api
      size ||= size_from_ioctl
      size ||= size_from_io_console
      size ||= size_from_readline
      size ||= size_from_tput
      size ||= size_from_stty
      size ||= size_from_env
      size ||= size_from_ansicon
      size ||  DEFAULT_SIZE
    end
    module_function :size

    def width
      size[1]
    end
    module_function :width

    alias columns width
    alias cols width
    module_function :columns
    module_function :cols

    def height
      size[0]
    end
    module_function :height

    alias rows height
    alias lines height
    module_function :rows
    module_function :lines

    STDOUT_HANDLE = 0xFFFFFFF5

    # Determine terminal size with a Windows native API
    #
    # @return [nil, Array[Integer, Integer]]
    #
    # @api private
    def size_from_win_api(verbose: nil)
      require 'fiddle'

      kernel32 = Fiddle::Handle.new('kernel32')
      get_std_handle = Fiddle::Function.new(kernel32['GetStdHandle'],
                        [-Fiddle::TYPE_INT], Fiddle::TYPE_INT)
      get_console_buffer_info = Fiddle::Function.new(
        kernel32['GetConsoleScreenBufferInfo'],
        [Fiddle::TYPE_LONG, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)

      format        = 'SSSSSssssSS'
      buffer        = ([0] * format.size).pack(format)
      stdout_handle = get_std_handle.(STDOUT_HANDLE)

      get_console_buffer_info.(stdout_handle, buffer)
      _, _, _, _, _, left, top, right, bottom, = buffer.unpack(format)
      size = [bottom - top + 1, right - left + 1]
      return size if nonzero_column?(size[1] - 1)
    rescue LoadError
      warn 'no native fiddle module found' if verbose
    rescue Fiddle::DLError
      # non windows platform or no kernel32 lib
    end
    module_function :size_from_win_api

    # Determine terminal size on jruby using native Java libs
    #
    # @return [nil, Array[Integer, Integer]]
    #
    # @api private
    def size_from_java(verbose: nil)
      return unless jruby?
      require 'java'
      java_import 'jline.TerminalFactory'
      terminal = TerminalFactory.get
      size = [terminal.get_height, terminal.get_width]
      return size if nonzero_column?(size[1])
    rescue
      warn 'failed to import java terminal package' if verbose
    end
    module_function :size_from_java

    # Detect screen size by loading io/console lib
    #
    # On Windows io_console falls back to reading environment
    # variables. This means any user changes to the terminal
    # size won't be reflected in the runtime of the Ruby app.
    #
    # @return [nil, Array[Integer, Integer]]
    #
    # @api private
    def size_from_io_console(verbose: nil)
      return if jruby?
      require 'io/console'

      begin
        if @output.tty? && IO.method_defined?(:winsize)
          size = @output.winsize
          size if nonzero_column?(size[1])
        end
      rescue Errno::EOPNOTSUPP
        # no support for winsize on output
      end
    rescue LoadError
      warn 'no native io/console support or io-console gem' if verbose
    end
    module_function :size_from_io_console

    TIOCGWINSZ = 0x5413
    TIOCGWINSZ_PPC = 0x40087468

    # Read terminal size from Unix ioctl
    #
    # @return [nil, Array[Integer, Integer]]
    #
    # @api private
    def size_from_ioctl
      return if jruby?
      return unless @output.respond_to?(:ioctl)

      format = 'SSSS'
      buffer = ([0] * format.size).pack(format)
      if ioctl?(TIOCGWINSZ, buffer) || ioctl?(TIOCGWINSZ_PPC, buffer)
        rows, cols, = buffer.unpack(format)[0..1]
        return [rows, cols] if nonzero_column?(cols)
      end
    end
    module_function :size_from_ioctl

    # Check if ioctl can be called and the device is attached to terminal
    #
    # @api private
    def ioctl?(control, buf)
      @output.ioctl(control, buf) >= 0
    rescue SystemCallError
      false
    end
    module_function :ioctl?

    # Detect screen size using Readline
    #
    # @api private
    def size_from_readline
      if defined?(Readline) && Readline.respond_to?(:get_screen_size)
        size = Readline.get_screen_size
        size if nonzero_column?(size[1])
      end
    rescue NotImplementedError
    end
    module_function :size_from_readline

    # Detect terminal size from tput utility
    #
    # @api private
    def size_from_tput
      return unless @output.tty?
      lines = run_command('tput', 'lines').to_i
      cols  = run_command('tput', 'cols').to_i
      [lines, cols] if nonzero_column?(lines)
    rescue IOError, SystemCallError
    end
    module_function :size_from_tput

    # Detect terminal size from stty utility
    #
    # @api private
    def size_from_stty
      return unless @output.tty?
      out = run_command('stty', 'size')
      return unless out
      size = out.split.map(&:to_i)
      size if nonzero_column?(size[1])
    rescue IOError, SystemCallError
    end
    module_function :size_from_stty

    # Detect terminal size from environment
    #
    # After executing Ruby code if the user changes terminal
    # dimensions during code runtime, the code won't be notified,
    # and hence won't see the new dimensions reflected in its copy
    # of LINES and COLUMNS environment variables.
    #
    # @return [nil, Array[Integer, Integer]]
    #
    # @api private
    def size_from_env
      return unless @env['COLUMNS'] =~ /^\d+$/
      size = [(@env['LINES'] || @env['ROWS']).to_i, @env['COLUMNS'].to_i]
      size if nonzero_column?(size[1])
    end
    module_function :size_from_env

    # Detect terminal size from Windows ANSICON
    #
    # @api private
    def size_from_ansicon
      return unless @env['ANSICON'] =~ /\((.*)x(.*)\)/
      size = [$2, $1].map(&:to_i)
      size if nonzero_column?(size[1])
    end
    module_function :size_from_ansicon

    # Runs command silently capturing the output
    #
    # @api private
    def run_command(*args)
      require 'tempfile'
      out = Tempfile.new('tty-screen')
      result = system(*args, out: out.path, err: File::NULL)
      return if result.nil?
      out.rewind
      out.read
    ensure
      out.close if out
    end
    private_module_function :run_command

    # Check if number is non zero
    #
    # return [Boolean]
    #
    # @api private
    def nonzero_column?(column)
      column.to_i > 0
    end
    private_module_function :nonzero_column?

    def jruby?
      RbConfig::CONFIG['ruby_install_name'] == 'jruby'
    end
    private_module_function :jruby?
  end # Screen
end # TTY