scoot 0.0.4

data/.bundle/gems/ruby/2.2.0/gems/highline-1.7.2/lib/highline/style.rb

@@ -0,0 +1,192 @@
+# color_scheme.rb
+#
+# Created by Richard LeBer on 2011-06-27.
+# Copyright 2011.  All rights reserved
+#
+# This is Free Software.  See LICENSE and COPYING for details
+
+class HighLine
+
+  def self.Style(*args)
+    args = args.compact.flatten
+    if args.size==1
+      arg = args.first
+      if arg.is_a?(Style)
+        Style.list[arg.name] || Style.index(arg)
+      elsif arg.is_a?(::String) && arg =~ /^\e\[/ # arg is a code
+        if styles = Style.code_index[arg]
+          styles.first
+        else
+          Style.new(:code=>arg)
+        end
+      elsif style = Style.list[arg]
+        style
+      elsif HighLine.color_scheme && HighLine.color_scheme[arg]
+        HighLine.color_scheme[arg]
+      elsif arg.is_a?(Hash)
+        Style.new(arg)
+      elsif arg.to_s.downcase =~ /^rgb_([a-f0-9]{6})$/
+        Style.rgb($1)
+      elsif arg.to_s.downcase =~ /^on_rgb_([a-f0-9]{6})$/
+        Style.rgb($1).on
+      else
+        raise NameError, "#{arg.inspect} is not a defined Style"
+      end
+    else
+      name = args
+      Style.list[name] || Style.new(:list=>args)
+    end
+  end
+
+  class Style
+
+    def self.index(style)
+      if style.name
+        @@styles ||= {}
+        @@styles[style.name] = style
+      end
+      if !style.list
+        @@code_index ||= {}
+        @@code_index[style.code] ||= []
+        @@code_index[style.code].reject!{|indexed_style| indexed_style.name == style.name}
+        @@code_index[style.code] << style
+      end
+      style
+    end
+
+    def self.rgb_hex(*colors)
+      colors.map do |color|
+        color.is_a?(Numeric) ? '%02x'%color : color.to_s
+      end.join
+    end
+
+    def self.rgb_parts(hex)
+      hex.scan(/../).map{|part| part.to_i(16)}
+    end
+
+    def self.rgb(*colors)
+      hex = rgb_hex(*colors)
+      name = ('rgb_' + hex).to_sym
+      if style = list[name]
+        style
+      else
+        parts = rgb_parts(hex)
+        new(:name=>name, :code=>"\e[38;5;#{rgb_number(parts)}m", :rgb=>parts)
+      end
+    end
+
+    def self.rgb_number(*parts)
+      parts = parts.flatten
+      16 + parts.inject(0) {|kode, part| kode*6 + (part/256.0*6.0).floor}
+    end
+
+    def self.ansi_rgb_to_hex(ansi_number)
+      raise "Invalid ANSI rgb code #{ansi_number}" unless (16..231).include?(ansi_number)
+      parts = (ansi_number-16).to_s(6).rjust(3,'0').scan(/./).map{|d| (d.to_i*255.0/6.0).ceil}
+      rgb_hex(*parts)
+    end
+
+    def self.list
+      @@styles ||= {}
+    end
+
+    def self.code_index
+      @@code_index ||= {}
+    end
+
+    def self.uncolor(string)
+      string.gsub(/\e\[\d+(;\d+)*m/, '')
+    end
+
+    attr_reader :name, :list
+    attr_accessor :rgb, :builtin
+
+    # Single color/styles have :name, :code, :rgb (possibly), :builtin
+    # Compound styles have :name, :list, :builtin
+    def initialize(defn = {})
+      @definition = defn
+      @name    = defn[:name]
+      @code    = defn[:code]
+      @rgb     = defn[:rgb]
+      @list    = defn[:list]
+      @builtin = defn[:builtin]
+      if @rgb
+        hex = self.class.rgb_hex(@rgb)
+        @name ||= 'rgb_' + hex
+      elsif @list
+        @name ||= @list
+      end
+      self.class.index self unless defn[:no_index]
+    end
+
+    def dup
+      self.class.new(@definition)
+    end
+
+    def to_hash
+      @definition
+    end
+
+    def color(string)
+      code + string + HighLine::CLEAR
+    end
+
+    def code
+      if @list
+        @list.map{|element| HighLine.Style(element).code}.join
+      else
+        @code
+      end
+    end
+
+    def red
+      @rgb && @rgb[0]
+    end
+
+    def green
+      @rgb && @rgb[1]
+    end
+
+    def blue
+      @rgb && @rgb[2]
+    end
+
+    def variant(new_name, options={})
+      raise "Cannot create a variant of a style list (#{inspect})" if @list
+      new_code = options[:code] || code
+      if options[:increment]
+        raise "Unexpected code in #{inspect}" unless new_code =~ /^(.*?)(\d+)(.*)/
+        new_code = $1 + ($2.to_i + options[:increment]).to_s + $3
+      end
+      new_rgb = options[:rgb] || @rgb
+      self.class.new(self.to_hash.merge(:name=>new_name, :code=>new_code, :rgb=>new_rgb))
+    end
+
+    def on
+      new_name = ('on_'+@name.to_s).to_sym
+      self.class.list[new_name] ||= variant(new_name, :increment=>10)
+    end
+
+    def bright
+      create_bright_variant(:bright)
+    end
+
+    def light
+      create_bright_variant(:light)
+    end
+
+    private
+
+    def create_bright_variant(variant_name)
+      raise "Cannot create a #{name} variant of a style list (#{inspect})" if @list
+      new_name = ("#{variant_name}_"+@name.to_s).to_sym
+      new_rgb = @rgb == [0,0,0] ? [128, 128, 128] : @rgb.map {|color|  color==0 ? 0 : [color+128,255].min }
+
+      find_style(new_name) or variant(new_name, :increment=>60, :rgb=>new_rgb)
+    end
+
+    def find_style(name)
+      self.class.list[name]
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/highline-1.7.2/lib/highline/system_extensions.rb

@@ -0,0 +1,251 @@
+# system_extensions.rb
+#
+#  Created by James Edward Gray II on 2006-06-14.
+#  Copyright 2006 Gray Productions. All rights reserved.
+#
+#  This is Free Software.  See LICENSE and COPYING for details.
+
+require "highline/compatibility"
+
+class HighLine
+  module SystemExtensions
+    JRUBY = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+    if JRUBY
+      def initialize_system_extensions
+        require 'java'
+        require 'readline'
+        if JRUBY_VERSION =~ /^1.7/
+          java_import 'jline.console.ConsoleReader'
+
+          input = @input && @input.to_inputstream
+          output = @output && @output.to_outputstream
+
+          @java_console = ConsoleReader.new(input, output)
+          @java_console.set_history_enabled(false)
+          @java_console.set_bell_enabled(true)
+          @java_console.set_pagination_enabled(false)
+          @java_terminal = @java_console.getTerminal
+        elsif JRUBY_VERSION =~ /^1.6/
+          java_import 'java.io.OutputStreamWriter'
+          java_import 'java.nio.channels.Channels'
+          java_import 'jline.ConsoleReader'
+          java_import 'jline.Terminal'
+
+          @java_input = Channels.newInputStream(@input.to_channel)
+          @java_output = OutputStreamWriter.new(Channels.newOutputStream(@output.to_channel))
+          @java_terminal = Terminal.getTerminal
+          @java_console = ConsoleReader.new(@java_input, @java_output)
+          @java_console.setUseHistory(false)
+          @java_console.setBellEnabled(true)
+          @java_console.setUsePagination(false)
+        end
+      end
+    end
+
+    extend self
+
+    #
+    # This section builds character reading and terminal size functions
+    # to suit the proper platform we're running on.  Be warned:  Here be
+    # dragons!
+    #
+    if RUBY_PLATFORM =~ /mswin(?!ce)|mingw|bccwin/i
+      begin
+        require "fiddle"
+
+        module WinAPI
+          include Fiddle
+          Handle = RUBY_VERSION >= "2.0.0" ? Fiddle::Handle : DL::Handle
+          Kernel32 = Handle.new("kernel32")
+          Crt = Handle.new("msvcrt") rescue Handle.new("crtdll")
+
+          def self._getch
+            @@_m_getch ||= Function.new(Crt["_getch"], [], TYPE_INT)
+            @@_m_getch.call
+          end
+
+          def self.GetStdHandle(handle_type)
+            @@get_std_handle ||= Function.new(Kernel32["GetStdHandle"], [-TYPE_INT], -TYPE_INT)
+            @@get_std_handle.call(handle_type)
+          end
+
+          def self.GetConsoleScreenBufferInfo(cons_handle, lp_buffer)
+            @@get_console_screen_buffer_info ||=
+              Function.new(Kernel32["GetConsoleScreenBufferInfo"], [TYPE_LONG, TYPE_VOIDP], TYPE_INT)
+            @@get_console_screen_buffer_info.call(cons_handle, lp_buffer)
+          end
+        end
+      rescue LoadError
+        require "dl/import"
+
+        module WinAPI
+          if defined?(DL::Importer)
+            # Ruby 1.9
+            extend DL::Importer
+          else
+            # Ruby 1.8
+            extend DL::Importable
+          end
+          begin
+            dlload "msvcrt", "kernel32"
+          rescue DL::DLError
+            dlload "crtdll", "kernel32"
+          end
+          extern "unsigned long _getch()"
+          extern "unsigned long GetConsoleScreenBufferInfo(unsigned long, void*)"
+          extern "unsigned long GetStdHandle(unsigned long)"
+
+          # Ruby 1.8 DL::Importable.import does mname[0,1].downcase so FooBar becomes fooBar
+          if defined?(getConsoleScreenBufferInfo)
+            alias_method :GetConsoleScreenBufferInfo, :getConsoleScreenBufferInfo
+            module_function :GetConsoleScreenBufferInfo
+          end
+          if defined?(getStdHandle)
+            alias_method :GetStdHandle, :getStdHandle
+            module_function :GetStdHandle
+          end
+        end
+      end
+
+      CHARACTER_MODE = "Win32API"    # For Debugging purposes only.
+
+      #
+      # Windows savvy getc().
+      #
+      # *WARNING*:  This method ignores <tt>input</tt> and reads one
+      # character from +STDIN+!
+      #
+      def get_character( input = STDIN )
+        WinAPI._getch
+      end
+
+      # We do not define a raw_no_echo_mode for Windows as _getch turns off echo
+      def raw_no_echo_mode
+      end
+
+      def restore_mode
+      end
+
+      # A Windows savvy method to fetch the console columns, and rows.
+      def terminal_size
+        format        = 'SSSSSssssSS'
+        buf           = ([0] * format.size).pack(format)
+        stdout_handle = WinAPI.GetStdHandle(0xFFFFFFF5)
+
+        WinAPI.GetConsoleScreenBufferInfo(stdout_handle, buf)
+        _, _, _, _, _,
+        left, top, right, bottom, _, _ = buf.unpack(format)
+        return right - left + 1, bottom - top + 1
+      end
+    else                  # If we're not on Windows try...
+      begin
+        require "termios"             # Unix, first choice termios.
+
+        CHARACTER_MODE = "termios"    # For Debugging purposes only.
+
+        def raw_no_echo_mode
+          @state = Termios.getattr(@input)
+          new_settings                     =  @state.dup
+          new_settings.c_lflag             &= ~(Termios::ECHO | Termios::ICANON)
+          new_settings.c_cc[Termios::VMIN] =  1
+          Termios.setattr(@input, Termios::TCSANOW, new_settings)
+        end
+
+        def restore_mode
+          Termios.setattr(@input, Termios::TCSANOW, @state)
+        end
+      rescue LoadError                # If our first choice fails, try using JLine
+        if JRUBY                      # if we are on JRuby. JLine is bundled with JRuby.
+          CHARACTER_MODE = "jline"    # For Debugging purposes only.
+
+          def terminal_size
+            if JRUBY_VERSION =~ /^1.7/
+              [ @java_terminal.get_width, @java_terminal.get_height ]
+            else
+              [ @java_terminal.getTerminalWidth, @java_terminal.getTerminalHeight ]
+            end
+          end
+
+          def raw_no_echo_mode
+            @state = @java_console.getEchoCharacter
+            @java_console.setEchoCharacter 0
+          end
+
+          def restore_mode
+            @java_console.setEchoCharacter @state
+          end
+        else                          # If we are not on JRuby, try ncurses
+          begin
+            require 'ffi-ncurses'
+            CHARACTER_MODE = "ncurses"    # For Debugging purposes only.
+
+            def raw_no_echo_mode
+              FFI::NCurses.initscr
+              FFI::NCurses.cbreak
+            end
+
+            def restore_mode
+              FFI::NCurses.endwin
+            end
+
+            #
+            # A ncurses savvy method to fetch the console columns, and rows.
+            #
+            def terminal_size
+              size = [80, 40]
+              FFI::NCurses.initscr
+              begin
+                size = FFI::NCurses.getmaxyx(FFI::NCurses.stdscr).reverse
+              ensure
+                FFI::NCurses.endwin
+              end
+              size
+            end
+          rescue LoadError            # Finally, if all else fails, use stty
+                                      # *WARNING*:  This requires the external "stty" program!
+            CHARACTER_MODE = "stty"   # For Debugging purposes only.
+
+            def raw_no_echo_mode
+              @state = `stty -g`
+              system "stty raw -echo -icanon isig"
+            end
+
+            def restore_mode
+              system "stty #{@state}"
+            end
+          end
+        end
+      end
+
+      # For termios and stty
+      if not method_defined?(:terminal_size)
+        # A Unix savvy method using stty to fetch the console columns, and rows.
+        # ... stty does not work in JRuby
+        def terminal_size
+          begin
+            require "io/console"
+            winsize = IO.console.winsize.reverse rescue nil
+            return winsize if winsize
+          rescue LoadError
+          end
+
+          if /solaris/ =~ RUBY_PLATFORM and
+            `stty` =~ /\brows = (\d+).*\bcolumns = (\d+)/
+            [$2, $1].map { |c| x.to_i }
+          elsif `stty size` =~ /^(\d+)\s(\d+)$/
+            [$2.to_i, $1.to_i]
+          else
+            [ 80, 24 ]
+          end
+        end
+      end
+    end
+
+    if not method_defined?(:get_character)
+      def get_character( input = STDIN )
+        input.getbyte
+      end
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/highline-1.7.2/lib/highline/version.rb

@@ -0,0 +1,4 @@
+class HighLine
+  # The version of the installed library.
+  VERSION = "1.7.2".freeze
+end