tty-screen 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17a06a8743f9b9c8201505e62561368c0ee30173
-  data.tar.gz: 5076f6033f0be8495506a2585bd551697eeff316
+  metadata.gz: 0796330d2cffb4c8486e6648f98cbb37a56b0d89
+  data.tar.gz: d1f15d6630f40dcda049190a07c431d6b750f161
 SHA512:
-  metadata.gz: 8659b0a56e2b205ebcd8793a0005ab7c48c91eb32fb336c96dff63ea1823ab02cbb74e9a0451e19246b13924ecd545b9366c3efc7fb7dfc97e3aaebd985c9cdd
-  data.tar.gz: 1f8600f8c43ae74fb85862abb98fae26537551db81b1f35a086d3cfee2b53a44c62fcc208ec72222ce38a1065cb94a4c7d7580676279c4a0d8c967e3b934b93c
+  metadata.gz: bca4c5c2e18579c49788196cf445b63bcb1b3ba4269e7e551f931181ff03e3a90a55f8c3a6ac959d4bb90914b69d61c878b309a4eabe51d30af3d6268d3c59d7
+  data.tar.gz: ca7fd84dd32d005f9bdadb9d8fc69a7d0cacb42b57e4155aa3f6292ff89c582ac0de9bf0e029813000613823d1c2ed0df4a0044c29689495285e736c37336ba9

data/CHANGELOG.md

@@ -1,4 +1,8 @@
-0.3.0 (Sept 12, 2015)
+0.4.0 (Sept 12, 2015)
+
+* Add terminal color support detection
+
+0.3.0 (Sept 11, 2015)
 
 * Fix bug loading standard library
 

data/README.md

@@ -11,9 +11,9 @@
 [coverage]: https://coveralls.io/r/peter-murach/tty-screen
 [inchpages]: http://inch-ci.org/github/peter-murach/tty-screen
 
-> Terminal screen size detection which works both on Linux, OS X and Windows/Cygwin platforms and supports MRI, JRuby and Rubinius interpreters.
+> Terminal screen size and color detection which works both 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/peter-murach/tty) toolkit.
+**TTY::Screen** provides independent screen size and color detection component for [TTY](https://github.com/peter-murach/tty) toolkit.
 
 ## Installation
 
@@ -43,12 +43,21 @@ screen.width    # => 280
 screen.height   # => 51
 ```
 
+Using the `color?` method, you can check whether terminal has color capabilities like so
+
+```ruby
+screen = TTY::Screen.new
+screen.color?   # => true
+```
+
 You can also use above methods as class instance methods:
 
 ```ruby
 TTY::Screen.size     # => [51, 280]
 TTY::Screen.width    # => 280
 TTY::Screen.height   # => 51
+
+TTY::Screen.color?   # => true
 ```
 
 ## Contributing

data/lib/tty/screen.rb

@@ -1,5 +1,7 @@
 # coding: utf-8
 
+require 'tty/screen/color'
+require 'tty/screen/size'
 require 'tty/screen/version'
 
 module TTY
@@ -16,6 +18,8 @@ module TTY
     # @api public
     def initialize(options = {})
       @output = options.fetch(:output) { $stderr }
+      @color  = Color.new(output: @output)
+      @size   = Size.new(output: @output)
     end
 
     # @api public
@@ -33,14 +37,12 @@ module TTY
       size[0]
     end
 
-    # Default terminal size
-    #
-    # @api public
-    def default_size
-      [
-        ENV['LINES'].to_i.nonzero? || 27,
-        ENV['COLUMNS'].to_i.nonzero? || 80
-      ]
+    def self.color?
+      new.color?
+    end
+
+    def size
+      @size.size
     end
 
     # Terminal lines count
@@ -63,129 +65,14 @@ module TTY
     end
     alias_method :columns, :width
 
-    # Get terminal rows and columns
+    # Check if terminal has color support
     #
-    # @return [Array[Integer, Integer]]
-    #   return rows & columns
+    # @return [Boolean]
+    #   true if can display color, false otherwise
     #
     # @api public
-    def size
-      @size ||= begin
-        size =   from_io_console
-        size ||= from_readline
-        size ||= from_tput
-        size ||= from_stty
-        size ||= from_env
-        size ||= from_ansicon
-        size ||  default_size
-      end
-    end
-
-    # Detect screen size by loading io/console lib
-    #
-    # @return [Array[Integer, Integer]]
-    #
-    # @api private
-    def from_io_console
-      return false 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
-      begin
-        require 'io/console'
-
-        begin
-          if output.tty? && IO.method_defined?(:winsize)
-            yield output.winsize
-          else
-            false
-          end
-        rescue Errno::EOPNOTSUPP
-          false
-        end
-      rescue LoadError
-        warn 'no native io/console support' if $VERBOSE
-        false
-      end
-    end
-
-    # Detect screen size using Readline
-    #
-    # @api private
-    def from_readline
-      return unless defined?(Readline)
-      size = Readline.get_screen_size
-      size if nonzero_column?(size[1])
-    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?
-      size = run_command('stty', 'size').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
-
-    private
-
-    # Specifies an output stream object
-    #
-    # @api public
-    attr_reader :output
-
-    # Runs command in subprocess
-    #
-    # @api private
-    def run_command(command, *args)
-      `#{command} #{args.join(' ')} 2>/dev/null`
-    end
-
-    def nonzero_column?(column)
-      column.to_i > 0
-    end
-
-    def jruby?
-      RbConfig::CONFIG['ruby_install_name'] == 'jruby'
+    def color?
+      @color.supports?
     end
   end # Screen
 end # TTY

data/lib/tty/screen/color.rb

@@ -0,0 +1,77 @@
+# coding: utf-8
+
+module TTY
+  class Screen
+    class Color
+      # Initialize color support
+      #
+      # @api public
+      def initialize(options = {})
+        @output = options.fetch(:output) { $stderr }
+      end
+
+      # Detect if terminal supports color
+      #
+      # @return [Boolean]
+      #   true when terminal supports color, false otherwise
+      #
+      # @api public
+      def supports?
+        return false unless tty?
+
+        from_curses || from_tput || from_term || from_env
+      end
+
+      # Attempt to load curses to check color support
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def from_curses(curses_class = nil)
+        require 'curses'
+
+        begin
+          curses_class ||= Curses
+          curses_class.init_screen
+          curses_class.has_colors?
+        ensure
+          curses_class.close_screen
+        end
+      rescue LoadError
+        warn 'no native curses support' if $VERBOSE
+        false
+      end
+
+      # Shell out to tput to check color support
+      #
+      # @api private
+      def from_tput
+        %x(tput colors 2>/dev/null).to_i > 2
+      rescue Errno::ENOENT
+        false
+      end
+
+      # Inspect environment $TERM variable for color support
+      #
+      # @api private
+      def from_term
+        if ENV['TERM'] == 'dumb'
+          false
+        elsif ENV['TERM'] =~ /^screen|^xterm|^vt100|color|ansi|cygwin|linux/i
+          true
+        else false
+        end
+      end
+
+      def from_env
+        ENV.include?('COLORTERM')
+      end
+
+      attr_reader :output
+
+      def tty?
+        output.tty?
+      end
+    end # Color
+  end # Screen
+end # TTY

data/lib/tty/screen/size.rb

@@ -0,0 +1,147 @@
+# coding: utf-8
+
+module TTY
+  class Screen
+    class Size
+      # Initialize terminal size detection
+      #
+      # @api public
+      def initialize(options = {})
+        @output = options.fetch(:output) { $stderr }
+      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 false 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
+        begin
+          require 'io/console'
+
+          begin
+            if output.tty? && IO.method_defined?(:winsize)
+              yield output.winsize
+            else
+              false
+            end
+          rescue Errno::EOPNOTSUPP
+            false
+          end
+        rescue LoadError
+          warn 'no native io/console support' if $VERBOSE
+          false
+        end
+      end
+
+      # Detect screen size using Readline
+      #
+      # @api private
+      def from_readline
+        return unless defined?(Readline)
+        size = Readline.get_screen_size
+        size if nonzero_column?(size[1])
+      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?
+        size = run_command('stty', 'size').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
+
+      private
+
+      # Specifies an output stream object
+      #
+      # @api public
+      attr_reader :output
+
+      # Runs command in subprocess
+      #
+      # @api private
+      def run_command(command, *args)
+        `#{command} #{args.join(' ')} 2>/dev/null`
+      end
+
+      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

@@ -2,6 +2,6 @@
 
 module TTY
   class Screen
-    VERSION = "0.3.0"
+    VERSION = "0.4.0"
   end # Screen
 end # TTY

data/spec/unit/color_spec.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Screen::Color, '.supports?' do
+  let(:output) { StringIO.new('', 'w+') }
+
+  subject(:color) { described_class.new(output: output) }
+
+  it "doesn't check color support for non tty terminal" do
+    allow(output).to receive(:tty?).and_return(false)
+
+    expect(color.supports?).to eq(false)
+  end
+
+  it "fails to load curses for color support" do
+    allow(color).to receive(:require).with('curses').
+      and_raise(LoadError)
+
+    expect(color.from_curses).to eq(false)
+  end
+
+  it "loads curses for color support" do
+    allow(color).to receive(:require).with('curses').and_return(true)
+    curses = double(:curses)
+    allow(curses).to receive(:init_screen)
+    allow(curses).to receive(:has_colors?).and_return(true)
+    allow(curses).to receive(:close_screen)
+
+    expect(color.from_curses(curses)).to eql(true)
+    expect(curses).to have_received(:has_colors?)
+  end
+
+  it "fails to find color for dumb terminal" do
+    allow(ENV).to receive(:[]).with('TERM').and_return('dumb')
+
+    expect(color.from_term).to eq(false)
+  end
+
+  it "inspects term variable for color capabilities" do
+    allow(ENV).to receive(:[]).with('TERM').and_return('xterm')
+
+    expect(color.from_term).to eq(true)
+  end
+
+  it "inspects color terminal variable for support" do
+    allow(ENV).to receive(:include?).with('COLORTERM').and_return(true)
+
+    expect(color.from_env).to eq(true)
+  end
+end

data/spec/unit/new_spec.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Screen, '.new' do
+  let(:output) { StringIO.new('', 'w+') }
+
+  it "initializes size and color detection" do
+    allow(TTY::Screen::Color).to receive(:new).with(output: output)
+    allow(TTY::Screen::Size).to receive(:new).with(output: output)
+
+    TTY::Screen.new(output: output)
+
+    expect(TTY::Screen::Color).to have_received(:new).with(output: output)
+    expect(TTY::Screen::Size).to have_received(:new).with(output: output)
+  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 "allows to call size as class instance" 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.width).to eq(280)
+    expect(TTY::Screen.height).to eq(51)
+    expect(TTY::Screen::Size).to have_received(:new).exactly(3).times
+  end
+
+  it "delegates color call" do
+    color_instance = spy(:color)
+    allow(TTY::Screen::Color).to receive(:new).and_return(color_instance)
+
+    screen = described_class.new
+    screen.color?
+
+    expect(color_instance).to have_received(:supports?)
+  end
+
+  it "allows to call color as class instance" do
+    color_instance = double(:size, supports?: false)
+    allow(TTY::Screen::Color).to receive(:new).and_return(color_instance)
+
+    expect(TTY::Screen.color?).to eq(false)
+    expect(TTY::Screen::Color).to have_received(:new).exactly(1).times
+  end
+end

data/spec/unit/size_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 require 'delegate'
 
-RSpec.describe TTY::Screen, '.size' do
+RSpec.describe TTY::Screen::Size, '.size' do
   class Output < SimpleDelegator
     def winsize
       [100, 200]
@@ -32,19 +32,9 @@ RSpec.describe TTY::Screen, '.size' do
     it "correctly falls through choices" do
       allow(screen).to receive(:from_io_console).and_return([51, 280])
       allow(screen).to receive(:from_readline).and_return(nil)
+
       expect(screen.size).to eq([51, 280])
       expect(screen).to_not have_received(:from_readline)
-      expect(screen.width).to eq(280)
-      expect(screen.height).to eq(51)
-    end
-
-    it "allows to call size as class instance" do
-      screen = double(:screen, size: [51, 280])
-      allow(TTY::Screen).to receive(:new).and_return(screen)
-      expect(TTY::Screen.size).to eq([51, 280])
-      expect(TTY::Screen.width).to eq(280)
-      expect(TTY::Screen.height).to eq(51)
-      expect(TTY::Screen).to have_received(:new).exactly(3).times
     end
   end
 
@@ -56,7 +46,7 @@ RSpec.describe TTY::Screen, '.size' do
 
     it "calcualtes the size" do
       allow(screen).to receive(:jruby?).and_return(false)
-      allow(TTY::Screen).to receive(:require).with('io/console').
+      allow(screen).to receive(:require).with('io/console').
         and_return(true)
       allow(output).to receive(:tty?).and_return(true)
       allow(IO).to receive(:method_defined?).with(:winsize).and_return(true)
@@ -68,14 +58,14 @@ RSpec.describe TTY::Screen, '.size' do
 
     it "doesn't calculate size if io/console not available" do
       allow(screen).to receive(:jruby?).and_return(false)
-      allow(TTY::Screen).to receive(:require).with('io/console').
+      allow(screen).to receive(:require).with('io/console').
         and_raise(LoadError)
       expect(screen.from_io_console).to eq(false)
     end
 
     it "doesn't calculate size if it is run without a console" do
       allow(screen).to receive(:jruby?).and_return(false)
-      allow(TTY::Screen).to receive(:require).with('io/console').
+      allow(screen).to receive(:require).with('io/console').
         and_return(true)
       allow(output).to receive(:tty?).and_return(true)
       allow(IO).to receive(:method_defined?).with(:winsize).and_return(false)

data/tty-screen.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = TTY::Screen::VERSION
   spec.authors       = ["Piotr Murach"]
   spec.email         = [""]
-  spec.summary       = %q{Terminal screen size detection which works both on Linux, OS X and Windows/Cygwin platforms and supports MRI, JRuby and Rubinius interpreters.}
-  spec.description   = %q{Terminal screen size detection which works both on Linux, OS X and Windows/Cygwin platforms and supports MRI, JRuby and Rubinius interpreters.}
+  spec.summary       = %q{Terminal screen size and color detection which works both on Linux, OS X and Windows/Cygwin platforms and supports MRI, JRuby and Rubinius interpreters.}
+  spec.description   = %q{Terminal screen size and color detection which works both on Linux, OS X and Windows/Cygwin platforms and supports MRI, JRuby and Rubinius interpreters.}
   spec.homepage      = ""
   spec.license       = "MIT"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tty-screen
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-11 00:00:00.000000000 Z
+date: 2015-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,8 +24,8 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
-description: Terminal screen size detection which works both on Linux, OS X and Windows/Cygwin
-  platforms and supports MRI, JRuby and Rubinius interpreters.
+description: Terminal screen size and color detection which works both on Linux, OS
+  X and Windows/Cygwin platforms and supports MRI, JRuby and Rubinius interpreters.
 email:
 - ''
 executables: []
@@ -43,8 +43,12 @@ files:
 - Rakefile
 - lib/tty-screen.rb
 - lib/tty/screen.rb
+- lib/tty/screen/color.rb
+- lib/tty/screen/size.rb
 - lib/tty/screen/version.rb
 - spec/spec_helper.rb
+- spec/unit/color_spec.rb
+- spec/unit/new_spec.rb
 - spec/unit/size_spec.rb
 - tasks/console.rake
 - tasks/coverage.rake
@@ -73,9 +77,11 @@ rubyforge_project:
 rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
-summary: Terminal screen size detection which works both on Linux, OS X and Windows/Cygwin
-  platforms and supports MRI, JRuby and Rubinius interpreters.
+summary: Terminal screen size and color detection which works both on Linux, OS X
+  and Windows/Cygwin platforms and supports MRI, JRuby and Rubinius interpreters.
 test_files:
 - spec/spec_helper.rb
+- spec/unit/color_spec.rb
+- spec/unit/new_spec.rb
 - spec/unit/size_spec.rb
 has_rdoc: