tty-screen 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a63a2019e73caf56b233666335b21ec5f0f5200
-  data.tar.gz: c01de14e847e44852e352a7a916379f82c657560
+  metadata.gz: dae2d40de8e2675bc91d26ec698d333bce317169
+  data.tar.gz: 2b26bc3794b5a6b05ff230b9202a11b59c60a8f3
 SHA512:
-  metadata.gz: 9c7da830b7bfcc5c08f061d27e5ced6593fe39c26e503adee00364937531b7cee77a1eda6134eec8d344dd8e2fe412b28fd6de12edd56e37aa586ac401a453df
-  data.tar.gz: 474a96f5cfe40c0d4cae44be6bbc928d2f350adc4aa96bfe32f399409f851b3dae50c266b135463410e7cc263f2146cad5bb726e0fd874a7c63dded3d5663b16
+  metadata.gz: d16dba65921f31a54f1c5528e89597ab223c6aecc1dccec83d3c588ae6e7b341b643f98746be1236e5135513752a07fad79c2eccda26218fce8585742430d5d4
+  data.tar.gz: 4083a1c8b373ff2dbb64fb2856f8ab5c8c9bcab29974194666ab5db02cd206876027e44a80473625bdad4827fe6571134fe1cee15ad1953c7fe7ab75f076f40e

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Change log
 
+## [v0.6.0] - 2017-10-29
+
+### Added
+* Add #size_from_ioctl check for reading terminal size with Unix ioctl
+* Add #size_from_java check for reading terminal size from Java on JRuby
+* Add #size_from_win_api check for reading terminal size from Windows C API
+
+### Changed
+* Change TTY::Screen to a module without any state
+* Change to prefix all checks with `size` keyword
+* Change gemspec to require ruby >= 2.0.0
+* Remove #try_io_console and inline with io-console check
+* Remove #default_size and replace with constant
+* Remove TTY::Screen::Size class
+
 ## [v0.5.1] - 2017-10-26
 
 ### Changed
@@ -56,6 +71,7 @@
 ### Fixed
 * Fix bug with screen detection from_io_console by @luxflux
 
+[v0.6.0]: https://github.com/peter-murach/tty-screen/compare/v0.5.1...v0.6.0
 [v0.5.1]: https://github.com/peter-murach/tty-screen/compare/v0.5.0...v0.5.1
 [v0.5.0]: https://github.com/peter-murach/tty-screen/compare/v0.4.3...v0.5.0
 [v0.4.3]: https://github.com/peter-murach/tty-screen/compare/v0.4.2...v0.4.3

data/README.md

@@ -17,7 +17,7 @@
 
 > Terminal screen size detection which works on Linux, OS X and Windows/Cygwin platforms and supports MRI, JRuby and Rubinius interpreters.
 
-**TTY::Screen** provides independent screen size detection component for [TTY](https://github.com/piotrmurach/tty) toolkit.
+**TTY::Screen** provides independent terminal screen size detection component for [TTY](https://github.com/piotrmurach/tty) toolkit.
 
 ## Installation
 
@@ -40,19 +40,23 @@ Or install it yourself as:
 **TTY::Screen** allows you to detect terminal screen size by calling `size` method which returns [height, width] tuple.
 
 ```ruby
-screen = TTY::Screen.new
-
-screen.size     # => [51, 280]
-screen.width    # => 280
-screen.height   # => 51
+TTY::Screen.size     # => [51, 280]
 ```
 
-You can also use above methods as class instance methods:
+To read terminal width do:
 
 ```ruby
-TTY::Screen.size     # => [51, 280]
 TTY::Screen.width    # => 280
+TTY::Screen.columns  # => 280
+TTY::Screen.cols     # => 280
+```
+
+Similarly, to read terminal height do:
+
+```ruby
 TTY::Screen.height   # => 51
+TTY::Screen.rows     # => 51
+TTY::Screen.lines    # => 51
 ```
 
 ## Contributing

data/lib/tty/screen.rb

@@ -1,66 +1,272 @@
-require_relative 'screen/size'
-require_relative 'screen/version'
+# fronzen_string_literal: true
+
+require_relative 'version'
 
 module TTY
   # Used for detecting screen properties
   #
   # @api public
-  class Screen
-    # Create terminal screen
-    #
-    # @param [Hash] options
-    # @option options [Object] :output
-    #   the object that responds to print call defaulting to stderr
+  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
-    def initialize(options = {})
-      @output  = options.fetch(:output) { $stderr }
-      @verbose = options.fetch(:verbose) { false }
-      @size    = Size.new(ENV, output: @output, verbose: @verbose)
+    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 self.size
-      new.size
+    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
 
-    # @api public
-    def self.width
+    def width
       size[1]
     end
+    module_function :width
 
-    # @api public
-    def self.height
+    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
 
-    # Terminal size as tuple
+    STDOUT_HANDLE = 0xFFFFFFF5
+
+    # Determine terminal size with a Windows native API
     #
-    # @return [Array[Integer]]
+    # @return [nil, Array[Integer, Integer]]
     #
-    # @api public
-    def size
-      @size.size
+    # @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)
+      [bottom - top + 1, right - left + 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
 
-    # Terminal lines count
+    # Determine terminal size on jruby using native Java libs
     #
-    # @return [Integer]
+    # @return [nil, Array[Integer, Integer]]
     #
-    # @api public
-    def height
-      size[0]
+    # @api private
+    def size_from_java(verbose: nil)
+      return unless jruby?
+      require 'java'
+      java_import 'jline.TerminalFactory'
+      terminal = TerminalFactory.get
+      [terminal.get_height, terminal.get_width]
+    rescue
+      warn 'failed to import java terminal package' if verbose
     end
-    alias_method :rows, :height
+    module_function :size_from_java
 
-    # Terminal columns count
+    # Detect screen size by loading io/console lib
     #
-    # @return [Integer]
+    # 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.
     #
-    # @api public
-    def width
-      size[1]
+    # @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]
+      end
+    end
+    module_function :size_from_ioctl
+
+    def ioctl?(control, buf)
+      @output.ioctl(control, buf) >= 0
+    rescue Errno::ENOTTY
+      # wrong processor architecture
+      false
+    rescue Errno::EINVAL
+      # ioctl failed to recognise processor type(not Intel)
+      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 Errno::ENOENT
+    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 Errno::ENOENT
+    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)
+      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
-    alias_method :columns, :width
+    private_module_function :jruby?
   end # Screen
 end # TTY

data/lib/tty/version.rb

@@ -0,0 +1,5 @@
+module TTY
+  module Screen
+    VERSION = "0.6.0"
+  end # Screen
+end # TTY

data/lib/tty-screen.rb

@@ -1 +1 @@
-require 'tty/screen'
+require_relative 'tty/screen'

data/spec/unit/height_width_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe TTY::Screen, '#height,#width' do
+  it "calcualtes screen width" do
+    allow(TTY::Screen).to receive(:size).and_return([51, 280])
+    expect(TTY::Screen.width).to eq(280)
+  end
+
+  it "aliases width to columns" do
+    allow(TTY::Screen).to receive(:size).and_return([51, 280])
+    expect(TTY::Screen.columns).to eq(280)
+  end
+
+  it "aliases width to cols" do
+    allow(TTY::Screen).to receive(:size).and_return([51, 280])
+    expect(TTY::Screen.cols).to eq(280)
+  end
+
+  it "calcualtes screen height" do
+    allow(TTY::Screen).to receive(:size).and_return([51, 280])
+    expect(TTY::Screen.height).to eq(51)
+  end
+
+  it "aliases width to rows" do
+    allow(TTY::Screen).to receive(:size).and_return([51, 280])
+    expect(TTY::Screen.rows).to eq(51)
+  end
+
+  it "aliases width to lines" do
+    allow(TTY::Screen).to receive(:size).and_return([51, 280])
+    expect(TTY::Screen.lines).to eq(51)
+  end
+end

data/spec/unit/size_spec.rb

@@ -1,34 +1,77 @@
 require 'delegate'
 
-RSpec.describe TTY::Screen::Size, '#size' do
+RSpec.describe TTY::Screen, '#size' do
   class Output < SimpleDelegator
     def winsize
       [100, 200]
     end
+
+    def ioctl(control, buf)
+      buf.replace("3\x00\xD3\x00\xF2\x04\xCA\x02\x00")
+      0
+    end
   end
 
   let(:output) { Output.new(StringIO.new('', 'w+')) }
 
   context 'size' do
     it "correctly falls through choices" do
-      screen = described_class.new({}, output: output)
-      allow(screen).to receive(:from_io_console).and_return([51, 280])
-      allow(screen).to receive(:from_readline).and_return(nil)
+      screen = TTY::Screen
+      old_output = screen.output
+      screen.output = output
+
+      allow(screen).to receive(:size_from_java).and_return(nil)
+      allow(screen).to receive(:size_from_win_api).and_return(nil)
+      allow(screen).to receive(:size_from_ioctl).and_return(nil)
+      allow(screen).to receive(:size_from_io_console).and_return([51, 280])
+      allow(screen).to receive(:size_from_readline).and_return(nil)
 
       expect(screen.size).to eq([51, 280])
-      expect(screen).to_not have_received(:from_readline)
+      expect(screen).to have_received(:size_from_java)
+      expect(screen).to have_received(:size_from_win_api)
+      expect(screen).to have_received(:size_from_ioctl)
+      expect(screen).to_not have_received(:size_from_readline)
+
+      screen.output = old_output
+    end
+  end
+
+  context "size from java" do
+    it "doesn't import java on non-jruby platform" do
+      screen = TTY::Screen
+      allow(screen).to receive(:jruby?).and_return(false)
+      expect(screen.size_from_java).to eq(nil)
+    end
+
+    it "imports java library on jruby" do
+      screen = TTY::Screen
+      class << screen
+        def java_import(*args); end
+      end
+      terminal = double(:terminal, get_height: 51, get_width: 211)
+      factory = double(:factory, get: terminal)
+      stub_const("TTY::Screen::TerminalFactory", factory)
+
+      allow(screen).to receive(:jruby?).and_return(true)
+      allow(screen).to receive(:require).with('java').and_return(true)
+      allow(screen).to receive(:java_import)
+
+      expect(screen.size_from_java).to eq([51, 211])
     end
   end
 
   context 'from io console' do
     it "doesn't calculate size if jruby " do
-      screen = described_class.new({})
+      screen = TTY::Screen
       allow(screen).to receive(:jruby?).and_return(true)
-      expect(screen.from_io_console).to eq(nil)
+      expect(screen.size_from_io_console).to eq(nil)
     end
 
     it "calcualtes the size" do
-      screen = described_class.new({}, output: output)
+      screen = TTY::Screen
+      old_output = screen.output
+      screen.output = output
+
       allow(screen).to receive(:jruby?).and_return(false)
       allow(screen).to receive(:require).with('io/console').
         and_return(true)
@@ -36,118 +79,146 @@ RSpec.describe TTY::Screen::Size, '#size' do
       allow(IO).to receive(:method_defined?).with(:winsize).and_return(true)
       allow(output).to receive(:winsize).and_return([100, 200])
 
-      expect(screen.from_io_console).to eq([100, 200])
+      expect(screen.size_from_io_console).to eq([100, 200])
       expect(output).to have_received(:winsize)
+
+      screen.output = old_output
     end
 
     it "doesn't calculate size if io/console not available" do
-      screen = described_class.new({})
+      screen = TTY::Screen
       allow(screen).to receive(:jruby?).and_return(false)
       allow(screen).to receive(:require).with('io/console').
         and_raise(LoadError)
-      expect(screen.from_io_console).to eq(nil)
+      expect(screen.size_from_io_console).to eq(nil)
     end
 
     it "doesn't calculate size if it is run without a console" do
-      screen = described_class.new({}, output: output)
+      screen = TTY::Screen
       allow(screen).to receive(:jruby?).and_return(false)
       allow(screen).to receive(:require).with('io/console').
         and_return(true)
-      allow(output).to receive(:tty?).and_return(true)
+      allow(screen.output).to receive(:tty?).and_return(true)
       allow(IO).to receive(:method_defined?).with(:winsize).and_return(false)
-      expect(screen.from_io_console).to eq(nil)
+      expect(screen.size_from_io_console).to eq(nil)
+    end
+  end
+
+  context "from ioctl" do
+    it "reads terminal size" do
+      screen = TTY::Screen
+      old_output = screen.output
+      screen.output = output
+      allow(screen).to receive(:jruby?).and_return(false)
+      expect(screen.size_from_ioctl).to eq([51, 211])
+      screen.output = old_output
+    end
+
+    it "skips reading on jruby" do
+      allow(TTY::Screen).to receive(:jruby?).and_return(true)
+      expect(TTY::Screen.size_from_ioctl).to eq(nil)
     end
   end
 
   context 'from tput' do
     it "doesn't run command if outside of terminal" do
-      screen = described_class.new({}, output: output)
-      allow(output).to receive(:tty?).and_return(false)
-      expect(screen.from_tput).to eq(nil)
+      allow(TTY::Screen.output).to receive(:tty?).and_return(false)
+      expect(TTY::Screen.size_from_tput).to eq(nil)
     end
 
     it "runs tput commands" do
-      screen = described_class.new({}, output: output)
-      allow(output).to receive(:tty?).and_return(true)
+      screen = TTY::Screen
+      allow(screen.output).to receive(:tty?).and_return(true)
       allow(screen).to receive(:run_command).with('tput', 'lines').and_return(51)
       allow(screen).to receive(:run_command).with('tput', 'cols').and_return(280)
-      expect(screen.from_tput).to eq([51, 280])
+      expect(screen.size_from_tput).to eq([51, 280])
     end
 
     it "doesn't return zero size" do
-      screen = described_class.new({}, output: output)
-      allow(output).to receive(:tty?).and_return(true)
+      screen = TTY::Screen
+      allow(screen.output).to receive(:tty?).and_return(true)
       allow(screen).to receive(:run_command).with('tput', 'lines').and_return(0)
       allow(screen).to receive(:run_command).with('tput', 'cols').and_return(0)
-      expect(screen.from_tput).to eq(nil)
+      expect(screen.size_from_tput).to eq(nil)
     end
   end
 
-  context 'from stty' do
+  context 'size from stty' do
     it "doesn't run command if outside of terminal" do
-      screen = described_class.new({}, output: output)
-      allow(output).to receive(:tty?).and_return(false)
-      expect(screen.from_stty).to eq(nil)
+      allow(TTY::Screen.output).to receive(:tty?).and_return(false)
+      expect(TTY::Screen.size_from_stty).to eq(nil)
     end
 
     it "runs stty commands" do
-      screen = described_class.new({}, output: output)
-      allow(output).to receive(:tty?).and_return(true)
+      screen = TTY::Screen
+      allow(screen.output).to receive(:tty?).and_return(true)
       allow(screen).to receive(:run_command).with('stty', 'size').and_return("51 280")
-      expect(screen.from_stty).to eq([51, 280])
+      expect(screen.size_from_stty).to eq([51, 280])
     end
 
     it "doesn't return zero size" do
-      screen = described_class.new({}, output: output)
-      allow(output).to receive(:tty?).and_return(true)
+      screen = TTY::Screen
+      allow(screen.output).to receive(:tty?).and_return(true)
       allow(screen).to receive(:run_command).with('stty', 'size').and_return("0 0")
-      expect(screen.from_stty).to eq(nil)
+      expect(screen.size_from_stty).to eq(nil)
     end
   end
 
-  context 'from env' do
+  context 'size from env' do
     it "doesn't calculate size without COLUMNS key" do
-      screen = described_class.new({'COLUMNS' => nil})
-      expect(screen.from_env).to eq(nil)
+      screen = TTY::Screen
+      old_env = screen.env
+      screen.env = {'COLUMNS' => nil}
+      expect(screen.size_from_env).to eq(nil)
+      screen.env = old_env
     end
 
     it "extracts lines and columns from environment" do
-      screen = described_class.new({'COLUMNS' => '280', 'LINES' => '51'})
-      expect(screen.from_env).to eq([51, 280])
+      screen = TTY::Screen
+      old_env = screen.env
+      screen.env = {'COLUMNS' => '280', 'LINES' => '51'}
+      expect(screen.size_from_env).to eq([51, 280])
+      screen.env = old_env
     end
 
     it "doesn't return zero size" do
-      screen = described_class.new({'COLUMNS' => '0', 'LINES' => '0'})
-      expect(screen.from_env).to eq(nil)
+      screen = TTY::Screen
+      old_env = screen.env
+      screen.env = {'COLUMNS' => '0', 'LINES' => '0'}
+      expect(screen.size_from_env).to eq(nil)
+      screen.env = old_env
     end
   end
 
   context 'from ansicon' do
     it "doesn't calculate size without ANSICON key" do
-      screen = described_class.new({'ANSICON' => nil})
-      expect(screen.from_ansicon).to eq(nil)
+      screen = TTY::Screen
+      old_env = screen.env
+      screen.env = {'ANSICON' => nil}
+      expect(screen.size_from_ansicon).to eq(nil)
+      screen.env = old_env
     end
 
     it "extracts lines and columns from environment" do
-      screen = described_class.new({'ANSICON' => '(280x51)'})
-      expect(screen.from_ansicon).to eq([51, 280])
+      screen = TTY::Screen
+      old_env = screen.env
+      screen.env = {'ANSICON' => '(280x51)'}
+      expect(screen.size_from_ansicon).to eq([51, 280])
+      screen.env = old_env
     end
 
     it "doesn't return zero size" do
-      screen = described_class.new({'ANSICON' => '(0x0)'})
-      expect(screen.from_ansicon).to eq(nil)
+      screen = TTY::Screen
+      old_env = screen.env
+      screen.env = {'ANSICON' => '(0x0)'}
+      expect(screen.size_from_ansicon).to eq(nil)
+      screen.env = old_env
     end
   end
 
   context 'default size' do
     it "suggests default terminal size" do
-      screen = described_class.new({'LINES' => 0, 'COLUMNS' => 0})
-      expect(screen.default_size).to eq([27, 80])
-    end
-
-    it "attempts to get default terminal size from environment" do
-      screen = described_class.new({'LINES' => 52, 'COLUMNS' => 200})
-      expect(screen.default_size).to eq([52, 200])
+      expect(TTY::Screen::DEFAULT_SIZE).to eq([27, 80])
     end
   end
 end

data/tasks/console.rake

@@ -8,3 +8,4 @@ task :console do
   ARGV.clear
   IRB.start
 end
+task :c => :console

data/tty-screen.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'tty/screen/version'
+require 'tty/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'tty-screen'
@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(spec)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = '>= 2.0.0'
+
   spec.add_development_dependency 'bundler', '>= 1.5.0', '< 2.0'
   spec.add_development_dependency 'rake',    '~> 10.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tty-screen
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-26 00:00:00.000000000 Z
+date: 2017-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -64,10 +64,9 @@ files:
 - appveyor.yml
 - lib/tty-screen.rb
 - lib/tty/screen.rb
-- lib/tty/screen/size.rb
-- lib/tty/screen/version.rb
+- lib/tty/version.rb
 - spec/spec_helper.rb
-- spec/unit/new_spec.rb
+- spec/unit/height_width_spec.rb
 - spec/unit/size_spec.rb
 - tasks/console.rake
 - tasks/coverage.rake
@@ -85,7 +84,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -100,5 +99,5 @@ summary: Terminal screen size detection which works on Linux, OS X and Windows/C
   platforms and supports MRI, JRuby and Rubinius interpreters.
 test_files:
 - spec/spec_helper.rb
-- spec/unit/new_spec.rb
+- spec/unit/height_width_spec.rb
 - spec/unit/size_spec.rb

data/lib/tty/screen/size.rb

@@ -1,155 +0,0 @@
-module TTY
-  class Screen
-    class Size
-      # Initialize terminal size detection
-      #
-      # @api public
-      def initialize(env, options = {})
-        @env     = env
-        @output  = options.fetch(:output) { $stderr }
-        @verbose = options.fetch(:verbose) { false }
-      end
-
-      # Get terminal rows and columns
-      #
-      # @return [Array[Integer, Integer]]
-      #   return rows & columns
-      #
-      # @api public
-      def size
-        size =   from_io_console
-        size ||= from_readline
-        size ||= from_tput
-        size ||= from_stty
-        size ||= from_env
-        size ||= from_ansicon
-        size ||  default_size
-      end
-
-      # Detect screen size by loading io/console lib
-      #
-      # @return [Array[Integer, Integer]]
-      #
-      # @api private
-      def from_io_console
-        return if jruby?
-        try_io_console { |size| size if nonzero_column?(size[1]) }
-      end
-
-      # Attempts to load native console extension
-      #
-      # @return [Boolean, Array]
-      #
-      # @api private
-      def try_io_console
-        require 'io/console'
-
-        begin
-          if output.tty? && IO.method_defined?(:winsize)
-            yield output.winsize
-          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
-
-      # Detect screen size using Readline
-      #
-      # @api private
-      def 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
-
-      # Detect terminal size from tput utility
-      #
-      # @api private
-      def 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 Errno::ENOENT
-      end
-
-      # Detect terminal size from stty utility
-      #
-      # @api private
-      def 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 Errno::ENOENT
-      end
-
-      # Detect terminal size from environment
-      #
-      # @api private
-      def 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
-
-      # Detect terminal size on windows
-      #
-      # @api private
-      def from_ansicon
-        return unless @env['ANSICON'] =~ /\((.*)x(.*)\)/
-        size = [$2, $1].map(&:to_i)
-        size if nonzero_column?(size[1])
-      end
-
-      # Default terminal size
-      #
-      # @api public
-      def default_size
-        [
-          @env['LINES'].to_i.nonzero? || 27,
-          @env['COLUMNS'].to_i.nonzero? || 80
-        ]
-      end
-
-      # Specifies an output stream object
-      #
-      # @api public
-      attr_reader :output
-
-      private
-
-      # 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)
-        return if result.nil?
-        out.rewind
-        out.read
-      ensure
-        out.close if out
-      end
-
-      # Check if number is non zero
-      #
-      # return [Boolean]
-      #
-      # @api private
-      def nonzero_column?(column)
-        column.to_i > 0
-      end
-
-      def jruby?
-        RbConfig::CONFIG['ruby_install_name'] == 'jruby'
-      end
-    end # Size
-  end # Screen
-end # TTY

data/lib/tty/screen/version.rb

@@ -1,5 +0,0 @@
-module TTY
-  class Screen
-    VERSION = "0.5.1"
-  end # Screen
-end # TTY

data/spec/unit/new_spec.rb

@@ -1,50 +0,0 @@
-RSpec.describe TTY::Screen, '.new' do
-
-  it "initializses size with defaults" do
-    allow(TTY::Screen::Size).to receive(:new)
-    TTY::Screen.new
-    expect(TTY::Screen::Size).to have_received(:new).
-      with(ENV, {output: $stderr, verbose: false})
-  end
-
-  it "initializes size with values" do
-    allow(TTY::Screen::Size).to receive(:new)
-
-    TTY::Screen.new(output: :output, verbose: true)
-
-    expect(TTY::Screen::Size).to have_received(:new).
-      with(ENV, output: :output, verbose: true)
-  end
-
-  it "delegates size call" do
-    size_instance = spy(:size)
-    allow(TTY::Screen::Size).to receive(:new).and_return(size_instance)
-
-    screen = described_class.new
-    screen.size
-
-    expect(size_instance).to have_received(:size)
-  end
-
-  it "calls size" do
-    size_instance = double(:size, size: [51, 280])
-    allow(TTY::Screen::Size).to receive(:new).and_return(size_instance)
-
-    expect(TTY::Screen.size).to eq([51, 280])
-    expect(TTY::Screen::Size).to have_received(:new).once
-  end
-
-  it "calls width" do
-    size_instance = double(:size, size: [51, 280])
-    allow(TTY::Screen::Size).to receive(:new).and_return(size_instance)
-
-    expect(TTY::Screen.width).to eq(280)
-    expect(TTY::Screen::Size).to have_received(:new).once
-  end
-
-  it "calls height" do
-    size_instance = double(:size, size: [51, 280])
-    allow(TTY::Screen::Size).to receive(:new).and_return(size_instance)
-    expect(TTY::Screen.height).to eq(51)
-  end
-end