dispel 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 43be2a0f31061504e3924a3dfc5f3b0ce4fb7de2
+  data.tar.gz: 3935dc92f5658964747ffe18b87d8bc15aa42cf0
+SHA512:
+  metadata.gz: 76f2f8a256c4a07ab5e2c2df074d8ef04a1f43707b6a980bec6d7ef10ad46bad4158935c87acf1cc3fbf03be24edcb6263854b87a625366b5d21a3b6b76dc029
+  data.tar.gz: f6ad5c7ab269a2e402b842224de4c9436f84ebdaf6b37cffcc82d38d569ebfef9a07715eaca5f9716c52694e439234e0a6931ec341f351e6bdf1dc5f6cd08c08

data.tar.gz.sig

@@ -0,0 +1,2 @@
+"�
+���l�s ';֮/��ٝ���.XB��@����S\���
˻I����sJg��.M��Z�
qUo�J��t�u��$�0�Z�*�7�<D4ct��o�=�u��>m�����8>��

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (C) 2013 Michael Grosser <michael@grosser.it>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/dispel.rb

@@ -0,0 +1,8 @@
+require "dispel/version"
+
+module Dispel
+  autoload :Keyboard, 'dispel/keyboard'
+  autoload :Screen, 'dispel/screen'
+  autoload :Tools, 'dispel/tools'
+  autoload :StyleMap, 'dispel/style_map'
+end

data/lib/dispel/keyboard.rb

@@ -0,0 +1,210 @@
+require 'curses'
+
+module Dispel
+  class Keyboard
+    MAX_CHAR = 255
+    ENTER = 13
+    ESCAPE = 27
+    IS_18 = RUBY_VERSION =~ /^1\.8/
+    SEQUENCE_TIMEOUT = 0.005
+    NOTHING = (2**32 - 1) # getch returns this as 'nothing' on 1.8 but nil on 1.9.2
+    A_TO_Z = ('a'..'z').to_a
+
+    def self.input(&block)
+      @input = block
+    end
+
+    def self.output
+      input { Curses.getch } unless @input # keep input replaceable for tests, but default to curses
+
+      @sequence = []
+      @started = Time.now.to_f
+
+      loop do
+        key = fetch_user_input
+        if sequence_finished?
+          sequence_to_keys(@sequence).each{|k| yield k }
+          @sequence = []
+        end
+        next unless key
+        append_to_sequence key
+      end
+    end
+
+    private
+
+    def self.translate_key_to_code(key)
+      case key
+
+      # move
+      when Curses::Key::UP then :up
+      when Curses::Key::DOWN then :down
+      when Curses::Key::RIGHT then :right
+      when Curses::Key::LEFT then :left
+
+      # code, unix, iTerm
+      when 337, '^[1;2A', "^[A" then :"Shift+up"
+      when 336, '^[1;2B', "^[B" then :"Shift+down"
+      when 402, '^[1;2C' then :"Shift+right"
+      when 393, '^[1;2D' then :"Shift+left"
+
+      when 558, '^[1;3A' then :"Alt+up"
+      when 517, '^[1;3B' then :"Alt+down"
+      when 552, '^[1;3C' then :"Alt+right"
+      when 537, '^[1;3D' then :"Alt+left"
+
+      when 560, '^[1;5A' then :"Ctrl+up"
+      when 519, '^[1;5B' then :"Ctrl+down"
+      when 554, '^[1;5C' then :"Ctrl+right"
+      when 539, '^[1;5D' then :"Ctrl+left"
+
+      when 561, '^[1;6A' then :"Ctrl+Shift+up"
+      when 520, '^[1;6B' then :"Ctrl+Shift+down"
+      when 555, '^[1;6C', "^[C" then :"Ctrl+Shift+right"
+      when 540, '^[1;6D', "^[D" then :"Ctrl+Shift+left"
+
+      when 562, '^[1;7A' then :"Alt+Ctrl+up"
+      when 521, '^[1;7B' then :"Alt+Ctrl+down"
+      when 556, '^[1;7C' then :"Alt+Ctrl+right"
+      when 541, '^[1;7D' then :"Alt+Ctrl+left"
+
+      when      '^[1;8A' then :"Alt+Ctrl+Shift+up"
+      when      '^[1;8B' then :"Alt+Ctrl+Shift+down"
+      when      '^[1;8C' then :"Alt+Ctrl+Shift+right"
+      when      '^[1;8D' then :"Alt+Ctrl+Shift+left"
+
+      when      '^[1;10A' then :"Alt+Shift+up"
+      when      '^[1;10B' then :"Alt+Shift+down"
+      when      '^[1;10C' then :"Alt+Shift+right"
+      when      '^[1;10D' then :"Alt+Shift+left"
+
+      when      '^[F'     then :"Shift+end"
+      when      '^[H'     then :"Shift+home"
+
+      when      '^[1;9F'  then :"Alt+end"
+      when      '^[1;9H'  then :"Alt+home"
+
+      when      '^[1;10F' then :"Alt+Shift+end"
+      when      '^[1;10H' then :"Alt+Shift+home"
+
+      when      '^[1;13F' then :"Alt+Ctrl+end"
+      when      '^[1;13H' then :"Alt+Ctrl+home"
+
+      when      '^[1;14F' then :"Alt+Ctrl+Shift+end"
+      when      '^[1;14H' then :"Alt+Ctrl+Shift+home"
+
+      when 527            then :"Ctrl+Shift+end"
+      when 532            then :"Ctrl+Shift+home"
+
+      when Curses::KEY_END then :end
+      when Curses::KEY_HOME then :home
+      when Curses::KEY_NPAGE then :page_down
+      when Curses::KEY_PPAGE then :page_up
+      when Curses::KEY_IC then :insert
+      when Curses::KEY_F0..Curses::KEY_F63 then :"F#{key - Curses::KEY_F0}"
+
+      # modify
+      when 9 then :tab
+      when 353 then :"Shift+tab"
+      when ENTER then :enter # shadows Ctrl+m
+      when 263, 127 then :backspace
+      when '^[3~', Curses::KEY_DC then :delete
+
+      # misc
+      when 0 then :"Ctrl+space"
+      when 1..26 then :"Ctrl+#{A_TO_Z[key-1]}"
+      when ESCAPE then :escape
+      when Curses::KEY_RESIZE then :resize
+      else
+        if key.is_a? Fixnum
+          key > MAX_CHAR ? key : key.chr
+        elsif is_alt_key_code?(key)
+          :"Alt+#{key.slice(1,1)}"
+        else
+          key
+        end
+      end
+    end
+
+    def self.fetch_user_input
+      key = @input.call or return
+      key = key.ord unless IS_18
+      if key >= NOTHING
+        # nothing happening -> sleep a bit to save cpu
+        sleep SEQUENCE_TIMEOUT
+        return
+      end
+      key
+    end
+
+    def self.append_to_sequence(key)
+      @started = Time.now.to_f
+      @sequence << key
+    end
+
+    def self.bytes_to_string(bytes)
+      bytes.pack('c*').gsub("\r","\n").force_encoding('utf-8')
+    end
+
+    # split a text so fast-typers do not get bugs like ^B^C in output
+    def self.bytes_to_key_codes(bytes)
+      result = []
+      multi_byte = []
+
+      append_multibyte = lambda{
+        unless multi_byte.empty?
+          result << bytes_to_string(multi_byte)
+          multi_byte = []
+        end
+      }
+
+      bytes.each do |byte|
+        if multi_byte_part?(byte)
+          multi_byte << byte
+        else
+          append_multibyte.call
+          result << translate_key_to_code(byte)
+        end
+      end
+
+      append_multibyte.call
+      result
+    end
+
+    # not ascii and not control-char
+    def self.multi_byte_part?(byte)
+      127 < byte and byte < 256
+    end
+
+    def self.sequence_finished?
+      @sequence.size != 0 and (Time.now.to_f - @started) > SEQUENCE_TIMEOUT
+    end
+
+    # paste of multiple \n or \n in text would cause weird indentation
+    def self.needs_paste_fix?(sequence)
+      sequence.size > 1 and sequence.include?(ENTER)
+    end
+
+    def self.sequence_to_keys(sequence)
+      if needs_paste_fix?(sequence)
+        [bytes_to_string(sequence)]
+      else
+        # when connected via ssh escape sequences are used
+        if escape_sequence?(sequence)
+          stringified = bytes_to_string(sequence).sub(/\e+/,'^').sub('[[','[')
+          [translate_key_to_code(stringified)]
+        else
+          bytes_to_key_codes(sequence)
+        end
+      end
+    end
+
+    def self.escape_sequence?(sequence)
+      sequence[0] == ESCAPE and sequence.size.between?(2,7)
+    end
+
+    def self.is_alt_key_code?(sequence)
+      sequence.slice(0,1) == "^" and sequence.size == 2
+    end
+  end
+end

data/lib/dispel/screen.rb

@@ -0,0 +1,159 @@
+require 'curses'
+
+module Dispel
+  class Screen
+    attr_accessor :options
+
+    def initialize(options)
+      @options = options
+      @cache = []
+    end
+
+    def self.open(options={}, &block)
+      new(options).open(&block)
+    end
+
+    def open(&block)
+      Curses.noecho # do not show typed chars
+      Curses.nonl # turn off newline translation
+      Curses.stdscr.keypad(true) # enable arrow keys
+      Curses.raw # give us all other keys
+      Curses.stdscr.nodelay = 1 # do not block -> we can use timeouts
+      Curses.init_screen
+      Curses.start_color if color?
+      yield self
+    ensure
+      Curses.clear # needed to clear the menu/status bar on windows
+      Curses.close_screen
+    end
+
+    def columns
+      Curses.stdscr.maxx
+    end
+
+    def lines
+      Curses.stdscr.maxy
+    end
+
+    def clear_cache
+      @cache.clear
+    end
+
+    def draw(view, style_map=[], cursor=nil)
+      draw_view(view, style_map)
+      Curses.setpos(*cursor) if cursor
+    end
+
+    def debug_key(key)
+      @key_line ||= -1
+      @key_line = (@key_line + 1) % lines
+      write(@key_line, 0, "#{key.inspect}---")
+    end
+
+    def color?
+      @options[:colors] and Curses.has_colors?
+    end
+
+    private
+
+    def write(line,row,text)
+      Curses.setpos(line,row)
+      Curses.addstr(text);
+    end
+
+    def draw_view(view, style_map)
+      lines = Tools.naive_split(view, "\n")
+      style_map = style_map.flatten
+
+      lines.each_with_index do |line, line_number|
+        styles = style_map[line_number]
+
+        # expand line with whitespace to overwrite previous content
+        missing = columns - line.size
+        raise line if missing < 0
+        line += " " * missing
+
+        # display tabs as single-space -> nothing breaks
+        line.gsub!("\t",' ')
+
+        if_line_changes line_number, [line, styles] do
+          # position at start of line and draw
+          Curses.setpos(line_number,0)
+          Dispel::StyleMap.styled(line, styles).each do |style, part|
+            Curses.attrset self.class.curses_style(style, color?, options)
+            Curses.addstr part
+          end
+
+          if @options[:debug_cache]
+            write(line_number, 0, (rand(899)+100).to_s)
+          end
+        end
+      end
+    end
+
+    def if_line_changes(key, args)
+      return if @cache[key] == args # would not change the line -> nothing to do
+      @cache[key] = args # store current line
+      yield # render the line
+    end
+
+    class << self
+      # TODO maybe instance and simpler caching...
+      def curses_style(style, colors, options={})
+        Tools.memoize(:curses_style, style, colors) do
+          if colors
+            foreground = options[:foreground] || '#ffffff'
+            background = options[:background] || '#000000'
+
+            foreground, background = if style == :normal
+              [foreground, background]
+            elsif style == :reverse
+              ['#000000', '#ffffff']
+            else
+              # :red or [:red, :blue]
+              f,b = style
+              [f || foreground, b || background]
+            end
+
+            foreground = html_to_terminal_color(foreground)
+            background = html_to_terminal_color(background)
+            color_id(foreground, background)
+          else # no colors
+            if style == :reverse
+              Curses::A_REVERSE
+            else
+              Curses::A_NORMAL
+            end
+          end
+        end
+      end
+
+      # create a new color from foreground+background or reuse old
+      # and return color-id
+      def color_id(foreground, background)
+        Tools.memoize(:color_id, foreground, background) do
+          # make a new pair with a unique id
+          @@max_color_id ||= 0
+          id = (@@max_color_id += 1)
+          unless defined? RSpec # stops normal text-output, do not use in tests
+            Curses::init_pair(id, foreground, background)
+          end
+          Curses.color_pair(id)
+        end
+      end
+
+      COLOR_SOURCE_VALUES = 256
+      COLOR_TARGET_VALUES = 5
+      COLOR_DIVIDE = COLOR_SOURCE_VALUES / COLOR_TARGET_VALUES
+      TERM_COLOR_BASE = 16
+
+      def html_to_terminal_color(html_color)
+        return unless html_color
+        r = (html_color[1..2].to_i(16) / COLOR_DIVIDE) * 36
+        g = (html_color[3..4].to_i(16) / COLOR_DIVIDE) * 6
+        b = (html_color[5..6].to_i(16) / COLOR_DIVIDE) * 1
+        TERM_COLOR_BASE + r + g + b
+      end
+    end
+  end
+end

data/lib/dispel/style_map.rb

@@ -0,0 +1,108 @@
+module Dispel
+  class StyleMap
+    attr_accessor :lines, :foreground, :background
+
+    def initialize(lines)
+      @lines = Array.new(lines)
+    end
+
+    def add(style, line, columns)
+      @lines[line] ||= []
+      @lines[line] << [style, columns]
+    end
+
+    def prepend(style, line, columns)
+      @lines[line] ||= []
+      @lines[line].unshift [style, columns]
+    end
+
+    def flatten
+      @lines.map do |styles|
+        next unless styles
+
+        # change to style at start and recalculate one after the end
+        points_of_change = styles.map{|s,c| [c.first, Tools.last_element(c)+1] }.flatten.uniq
+
+        flat = []
+
+        points_of_change.each do |point|
+          flat[point] = :normal # set default
+          styles.each do |style, columns|
+            next unless columns.include?(point)
+            flat[point] = style
+          end
+        end
+
+        flat
+      end
+    end
+
+    def left_pad!(offset)
+      @lines.compact.each do |styles|
+        next unless styles
+        styles.map! do |style, columns|
+          [style, (columns.first + offset)..(columns.last + offset)]
+        end
+      end
+    end
+
+    def invert!
+      map = {:reverse => :normal, :normal => :reverse}
+      @lines.compact.each do |styles|
+        styles.map! do |style, columns|
+          [map[style] || style, columns]
+        end
+      end
+    end
+
+    def +(other)
+      lines = self.lines + other.lines
+      new = StyleMap.new(0)
+      new.lines = lines
+      new
+    end
+
+    def slice!(*args)
+      sliced = lines.slice!(*args)
+      new = StyleMap.new(0)
+      new.lines = sliced
+      new
+    end
+
+    def shift
+      slice!(0, 1)
+    end
+
+    def pop
+      slice!(-1, 1)
+    end
+
+    def self.styled(content, styles)
+      styles ||= []
+      content = content.dup
+
+      build = []
+      build << [:normal]
+
+      buffered = ''
+      styles.each do |style|
+        if style
+          build[-1] << buffered
+          buffered = ''
+
+          # set new style
+          build << [style]
+        end
+        buffered << (content.slice!(0,1) || '')
+      end
+      build[-1] << buffered + content
+      build
+    end
+
+    def self.single_line_reversed(columns)
+      map = StyleMap.new(1)
+      map.add(:reverse, 0, 0...columns)
+      map
+    end
+  end
+end

data/lib/dispel/tools.rb

@@ -0,0 +1,30 @@
+module Dispel
+  module Tools
+    class << self
+      # http://grosser.it/2011/08/28/ruby-string-naive-split-because-split-is-to-clever/
+      # "    ".split(' ') == []
+      # "    ".naive_split(' ') == ['','','','']
+      # "".split(' ') == []
+      # "".naive_split(' ') == ['']
+      def naive_split(string, pattern)
+        pattern = /#{Regexp.escape(pattern)}/ unless pattern.is_a?(Regexp)
+        result = string.split(pattern, -1)
+        result.empty? ? [''] : result
+      end
+
+      def memoize(*args)
+        key = args.map(&:to_s).join("-")
+        @memoize ||= {}
+        if @memoize.key?(key)
+          @memoize[key]
+        else
+          @memoize[key] = yield
+        end
+      end
+
+      def last_element(range)
+        range.exclude_end? ? range.last.pred : range.last
+      end
+    end
+  end
+end

data/lib/dispel/version.rb

@@ -0,0 +1,3 @@
+module Dispel
+  VERSION = "0.0.0"
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: dispel
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Michael Grosser
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDMjCCAhqgAwIBAgIBADANBgkqhkiG9w0BAQUFADA/MRAwDgYDVQQDDAdtaWNo
+  YWVsMRcwFQYKCZImiZPyLGQBGRYHZ3Jvc3NlcjESMBAGCgmSJomT8ixkARkWAml0
+  MB4XDTEzMDIwMzE4MTMxMVoXDTE0MDIwMzE4MTMxMVowPzEQMA4GA1UEAwwHbWlj
+  aGFlbDEXMBUGCgmSJomT8ixkARkWB2dyb3NzZXIxEjAQBgoJkiaJk/IsZAEZFgJp
+  dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMorXo/hgbUq97+kII9H
+  MsQcLdC/7wQ1ZP2OshVHPkeP0qH8MBHGg6eYisOX2ubNagF9YTCZWnhrdKrwpLOO
+  cPLaZbjUjljJ3cQR3B8Yn1veV5IhG86QseTBjymzJWsLpqJ1UZGpfB9tXcsFtuxO
+  6vHvcIHdzvc/OUkICttLbH+1qb6rsHUceqh+JrH4GrsJ5H4hAfIdyS2XMK7YRKbh
+  h+IBu6dFWJJByzFsYmV1PDXln3UBmgAt65cmCu4qPfThioCGDzbSJrGDGLmw/pFX
+  FPpVCm1zgYSb1v6Qnf3cgXa2f2wYGm17+zAVyIDpwryFru9yF/jJxE38z/DRsd9R
+  /88CAwEAAaM5MDcwCQYDVR0TBAIwADAdBgNVHQ4EFgQUsiNnXHtKeMYYcr4yJVmQ
+  WONL+IwwCwYDVR0PBAQDAgSwMA0GCSqGSIb3DQEBBQUAA4IBAQAlyN7kKo/NQCQ0
+  AOzZLZ3WAePvStkCFIJ53tsv5Kyo4pMAllv+BgPzzBt7qi605mFSL6zBd9uLou+W
+  Co3s48p1dy7CjjAfVQdmVNHF3MwXtfC2OEyvSQPi4xKR8iba8wa3xp9LVo1PuLpw
+  /6DsrChWw74HfsJN6qJOK684hJeT8lBYAUfiC3wD0owoPSg+XtyAAddisR+KV5Y1
+  NmVHuLtQcNTZy+gRht3ahJRMuC6QyLmkTsf+6MaenwAMkAgHdswGsJztOnNnBa3F
+  y0kCSWmK6D+x/SbfS6r7Ke07MRqziJdB9GuE1+0cIRuFh8EQ+LN6HXCKM5pon/GU
+  ycwMXfl0
+  -----END CERTIFICATE-----
+date: 2013-12-14 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: michael@grosser.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- lib/dispel.rb
+- lib/dispel/keyboard.rb
+- lib/dispel/screen.rb
+- lib/dispel/style_map.rb
+- lib/dispel/tools.rb
+- lib/dispel/version.rb
+homepage: http://github.com/grosser/dispel
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Remove evil curses
+test_files: []