ver 2009.12.14 → 2010.02

data/lib/ver/action.rb

@@ -0,0 +1,43 @@
+module VER
+  class Action < Struct.new(:receiver, :method, :args, :block, :last)
+    def initialize(receiver = nil, method = nil, args = [], &block)
+      self.receiver = receiver
+      self.method = method || :call
+      self.args = args
+      self.block = block
+      self.last = [self.receiver, self.method, self.args]
+    end
+
+    def call(widget, *given_args)
+      args = [*self.args, *given_args]
+
+      if receiver = self.receiver
+        self.last = [receiver, method, widget.tk_pathname, args]
+        receiver.send(method, widget, *args)
+      elsif receiver = widget
+        if widget.respond_to?(:event)
+          self.last = [widget.tk_pathname, method, widget.event, args]
+          widget.send(method, widget.event, *args)
+        else
+          self.last = [widget.tk_pathname, method, widget, args]
+          widget.send(method, widget, *args)
+        end
+      end
+    rescue => ex
+      puts self
+      pp ex, ex.backtrace
+    end
+
+    def combine(action)
+      new_args = [*args, action].compact
+      self.class.new(receiver, method, new_args, &block)
+    end
+
+    def to_s
+      receiver, method, widget, *args = last
+      joined = [widget, *args.map{|arg| arg.inspect }].compact.join(' ')
+
+      "%s.%s(%s)" % [receiver, method, joined]
+    end
+  end
+end

data/lib/ver/buffer.rb

@@ -0,0 +1,229 @@
+module VER
+  class Buffer < Tk::Tile::Frame
+    autoload :Console, 'ver/buffer/console'
+
+    def self.[](name, line = nil, column = nil)
+      find_or_create(name, line, column)
+    end
+
+    def self.create(path = nil, line = nil, column = nil)
+      VER.layout.create_buffer do |buffer|
+        case path
+        when nil
+          buffer.open_empty
+        when Symbol
+          buffer.open_symbolic(path, line, column)
+        when Pathname
+          buffer.open_path(path, line, column)
+        else
+          raise ArgumentError, "invalid path: %p" % [path]
+        end
+
+        VER.buffers[buffer.name] = buffer
+        yield(buffer) if block_given?
+        buffer
+      end
+    end
+
+    def self.find_or_create(name, line = nil, column = nil, &block)
+      case name
+      when Pathname, Symbol
+        if buffer = VER.buffers[name]
+          buffer.after_found(line, column)
+        else
+          create(name, line, column, &block)
+        end
+      when String
+        path = Pathname(name.to_str).expand_path
+        find_or_create(path, line, column, &block)
+      else
+        raise ArgumentError, "Invalid path: %p" % [path]
+      end
+    end
+
+    attr_reader :layout, :text, :status, :shown
+
+    def initialize(layout, options = {})
+      peer = options.delete(:peer)
+      options[:style] ||= VER.obtain_style_name('Buffer', 'TFrame')
+      super
+
+      @layout = layout
+      @text = @status = @ybar = @xbar = nil
+      @shown = true
+      setup(peer)
+
+      configure takefocus: false, padding: 2, border: 0, relief: :solid
+    end
+
+    # this should be customized when neccesary
+    def name
+      text.filename || text.name
+    end
+
+    # +-------+---+
+    # |       | @ |
+    # |       | y |
+    # | @text | b |
+    # |       | a |
+    # |       | r |
+    # +-------+---+
+    # | @xbar |   |
+    # +-------+---+
+    # |  @status  |
+    # +-----------+
+    def setup(peer)
+      setup_widgets(peer)
+      setup_grid
+      setup_misc
+    end
+
+    def setup_widgets(peer)
+      if peer
+        setup_peer(peer)
+      else
+        setup_text
+      end
+
+      setup_vertical_scrollbar if VER.options.vertical_scrollbar
+      setup_horizontal_scrollbar if VER.options.horizontal_scrollbar
+      setup_status
+    end
+
+    def setup_peer(peer)
+      @text = peer.peer_create(self)
+    end
+
+    def setup_text
+      font, tabstop = VER.options.font, VER.options.tabstop
+      tabs = font.measure('0') * tabstop
+
+      @text = VER::Text.new(
+        self,
+        borderwidth:      0,
+        exportselection:  true, # copy into X11 buffer automatically
+        foreground:       '#fff', # when first showing, it's not highlighted...
+        background:       '#000',
+        font:             font,
+        insertofftime:    VER.options.insertofftime,
+        insertontime:     VER.options.insertontime,
+        setgrid:          false,
+        takefocus:        true,
+        tabs:             tabs,
+        tabstyle:         :wordprocessor,
+        wrap:             :word
+      )
+    end
+
+    def setup_vertical_scrollbar
+      @ybar = Tk::Tile::YScrollbar.new(self)
+      @text.yscrollbar(@ybar)
+    end
+
+    def setup_horizontal_scrollbar
+      @xbar = Tk::Tile::XScrollbar.new(self)
+      @text.xscrollbar(@xbar)
+    end
+
+    def setup_status
+      @status = Status.new(self)
+    end
+
+    def setup_grid
+      @text.grid_configure   row: 0, column: 0, sticky: :nsew              if @text
+      @ybar.grid_configure   row: 0, column: 1, sticky: :ns                if @ybar
+      @xbar.grid_configure   row: 1, column: 0, sticky: :ew                if @xbar
+      @status.grid_configure row: 2, column: 0, sticky: :ew, columnspan: 2 if @status
+
+      grid_columnconfigure 0, weight: 1
+      grid_columnconfigure 1, weight: 0
+      grid_rowconfigure    0, weight: 1
+      grid_rowconfigure    1, weight: 0
+      grid_rowconfigure    2, weight: 0
+    end
+
+    def setup_misc
+      @text.status = @status
+      @text.buffer = self
+    end
+
+    def open_path(path, line = 1, column = 0)
+      Methods::Open.open_path(text, path, line, column)
+    end
+
+    def open_symbolic(name, line = 1, column = 0)
+      Methods::Open.open_symbolic(text, name, line, column)
+    end
+
+    def open_empty
+      Methods::Open.open_empty(text)
+    end
+
+    def focus
+      text.focus
+    end
+
+    def after_found(line, column, &block)
+      layout.push_top(self)
+      focus
+      go_line_column(line, column)
+      yield(self) if block_given?
+      self
+    end
+
+    def go_line_column(line, column)
+      insert = text.index(:insert)
+      text.mark_set(:insert, "#{line || insert.y}.#{column || insert.x}")
+    end
+
+    def create_peer
+      layout.create_buffer(peer: text) do |buffer|
+        yield(buffer) if block_given?
+      end
+    end
+
+    def close
+      Methods::Save.may_close text do
+        layout.close_buffer(self)
+      end
+    end
+
+    def shown?
+      @shown
+    end
+
+    def hidden?
+      not @shown
+    end
+
+    def show
+      @shown = true
+      layout.apply
+    end
+
+    def hide
+      @shown = false
+      layout.apply
+    end
+
+    def destroy
+      style_name = style
+      buffer_name = name
+      [@text, @ybar, @xbar, @status].compact.each(&:destroy)
+
+      super
+    ensure
+      VER.buffers.delete(buffer_name)
+      VER.return_style_name(style_name)
+    end
+
+    def style
+      style = cget(:style)
+      style.first if style
+    end
+
+    def filename
+      text.filename
+    end
+  end
+end

data/lib/ver/buffer/console.rb

@@ -0,0 +1,171 @@
+require 'eventmachine'
+
+module VER
+  class Buffer
+    class Console
+      class Process < EventMachine::Connection
+        attr_accessor :callback
+
+        def receive_data(data)
+          callback.on_stdout(data)
+        end
+
+        def unbind
+          callback.closed
+        end
+      end
+
+      class Stderr < EventMachine::Connection
+        attr_accessor :callback
+
+        def initialize(stderr)
+          @stderr = stderr
+        end
+
+        def receive_data(data)
+          callback.on_stderr(data)
+        end
+      end
+
+      def initialize(parent, *cmd)
+        @parent = parent
+        setup_widgets
+        setup_events
+        setup_terminal(*cmd)
+      end
+
+      def setup_widgets
+        font = VER.options[:font]
+        tab_width = font.measure('0') * 2
+
+        @text = Tk::Text.new(
+          @parent,
+          borderwidth: 0,
+          exportselection: true,
+          font: font,
+          insertofftime: 0,
+          setgrid: true,
+          tabs: tab_width,
+          tabstyle: :wordprocessor,
+          background: 'black',
+          foreground: 'white',
+          wrap: :word
+        )
+        @text.tag_configure :stdin,  foreground: 'green', background: 'black'
+        @text.tag_configure :stdout, foreground: 'white', background: 'black'
+        @text.tag_configure :stderr, foreground: 'red',   background: 'black'
+
+        @entry = Tk::Tile::Entry.new(@parent)
+        @entry.pack fill: :x, side: :bottom
+        @text.pack fill: :both, side: :bottom, after: @entry, expand: true
+      end
+
+      def setup_events
+        @entry.bind('<Control-q>'){ Tk.exit }
+        # @entry.bind('Escape'){ closed }
+        @entry.bind('<Return>'){
+          send_data @entry.value
+          @entry.clear
+        }
+      end
+
+      def closed
+        @entry.bind('<Return>'){}
+        @entry.bind('<Key>'){ Tk.callback_break }
+        @entry.bind('<Escape>'){ destroy }
+        @entry.value = 'Session ended. Press Escape to close console'
+      rescue => ex
+        VER.error(ex)
+      end
+
+      def destroy
+        @text.destroy
+        @entry.destroy
+        @parent.focus
+      end
+
+      def shell_config
+        buffer = []
+
+        shell = ENV['SHELL'] || 'sh'
+        opts = [shell]
+
+        case shell
+        when /zsh/
+          opts << '-s'
+          buffer << 'echo $ZSH $ZSH_VERSION'
+        when /bash/
+          opts << '-s'
+          buffer << 'echo $BASH $BASH_VERSION'
+        end
+
+        return buffer, opts
+      end
+
+      def setup_terminal(*cmd)
+        if cmd.empty?
+          @buffer, opts = shell_config
+        else
+          @buffer = []
+          opts = cmd
+        end
+
+        # FIXME: this should have proper shell escapes
+        popen3(opts.join(' '), self) do |stdin|
+          begin
+            @entry.focus
+            @stdin = stdin
+
+            while line = @buffer.shift
+              send_data(line)
+            end
+          rescue => ex
+            VER.error(ex)
+          end
+        end
+      end
+
+      # the callback should have #on_stdout and #on_stderr
+      # The method yields the stdin and you can use #send_data on it.
+      # This seems to have the side-effect of messing with the original $stderr,
+      # maybe there are other solutions.
+      def popen3(cmd, callback)
+        old_stderr = $stderr.dup
+        rd, wr = IO::pipe
+        $stderr.reopen(wr)
+
+        popen_stdin = EM.popen(cmd, Process)
+        popen_stdin.callback = callback
+
+        popen_stderr = EM.attach(rd, Stderr, rd)
+        popen_stderr.callback = callback
+
+        yield(popen_stdin) if block_given?
+
+        $stderr.reopen old_stderr
+      end
+
+      def send_data(string)
+        @stdin.send_data("#{string}\n")
+        on_stdin(string)
+      end
+
+      def on_stdin(string)
+        output "i> #{string}\n", :stdin
+      end
+
+      def on_stdout(string)
+        output "#{string}", :stdout
+      end
+
+      def on_stderr(string)
+        output "e> #{string}", :stderr
+      end
+
+      def output(string, tag)
+        @text.insert(:end, string, tag)
+        @text.see(:end)
+      end
+    end
+  end
+end

data/lib/ver/buffer/term.rb

@@ -0,0 +1,255 @@
+require 'thread'
+require 'strscan'
+require 'pty'
+
+class VER::Buffer::Terminal
+  def initialize(parent)
+    @parent = parent
+    setup_widgets
+    pty
+  end
+
+  def bench(name, &block)
+    require 'benchmark'
+    p name => Benchmark.realtime(&block)
+  end
+
+  def setup_widgets
+    Tk.set_palette('black') # maybe use themes instead?
+
+    @option_cache ||= {}
+    @font ||= VER.options[:font]
+    @font_actual ||= @font.actual_hash
+
+    @text = Tk::Text.new(font: @font, insertofftime: 1)
+    @text.pack expand: true, fill: :both
+    @text.focus
+
+    @text.bind('<Key>'){|event|
+      @pty_queue << event.unicode
+      Tk.callback_break
+    }
+
+    @text.bind('<Return>'){|event|
+      @pty_queue << event.unicode
+      # Tk.callback_break
+    }
+  end
+
+  def destroy
+    @text.destroy
+  rescue Errno::EIO, PTY::ChildExited
+  ensure
+    @parent.focus
+  end
+
+  def pty
+    @pty_queue = queue = Queue.new
+
+    Thread.new do
+      shell = ENV['SHELL'] || 'bash'
+
+      PTY.spawn(shell) do |r_pty, w_pty, pid|
+        Thread.new do
+          while chunk = queue.shift
+            w_pty.print chunk
+            w_pty.flush
+          end
+        end
+
+        begin
+          loop do
+            c = r_pty.sysread(1 << 15)
+            on_chunk(c) if c
+          end
+        rescue Errno::EIO, PTY::ChildExited
+          destroy
+        end
+      end
+    end
+  rescue Errno::EIO, PTY::ChildExited
+    destroy
+  end
+
+  ANSI_CODES = []
+  ANSI_CODES[0]  = :reset
+  ANSI_CODES[1]  = :bold
+  ANSI_CODES[2]  = :dark
+  ANSI_CODES[3]  = :italic
+  ANSI_CODES[4]  = :underline
+  ANSI_CODES[5]  = :blink
+  ANSI_CODES[6]  = :rapid_blink
+  ANSI_CODES[7]  = :reverse
+  ANSI_CODES[8]  = :concealed
+  ANSI_CODES[9]  = :strikethrough
+  ANSI_CODES[30] = :black
+  ANSI_CODES[31] = :red
+  ANSI_CODES[32] = :green
+  ANSI_CODES[33] = :yellow
+  ANSI_CODES[34] = :blue
+  ANSI_CODES[35] = :magenta
+  ANSI_CODES[36] = :cyan
+  ANSI_CODES[37] = :white
+  ANSI_CODES[40] = :on_black
+  ANSI_CODES[41] = :on_red
+  ANSI_CODES[42] = :on_green
+  ANSI_CODES[43] = :on_yellow
+  ANSI_CODES[44] = :on_blue
+  ANSI_CODES[45] = :on_magenta
+  ANSI_CODES[46] = :on_cyan
+  ANSI_CODES[47] = :on_white
+
+  # Trying to build a little dictionary of escape sequences:
+  #
+  # | Sequence       | Meaning         |
+  # | \e]0;          | reset fg/bg     |
+  # | \e[?1034h      | ???             |
+  # | \e[01;34mbin\e | fg: 1, bg: 34   |
+
+  def on_chunk(chunk)
+    @buffer ||= ''
+    @buffer << chunk
+    s = StringScanner.new(@buffer)
+
+    until s.eos?
+      pos = s.pos
+
+      case s.peek(1)
+      when "\e"
+        if    s.scan(/\e\](\d+);/)
+          color s[1]
+        elsif s.scan(/\e\[(\d+)([A-Z])/)
+          color s[1]
+        elsif s.scan(/\e\[\?(\d+h)/)
+          color s[1]
+        elsif s.scan(/\e\[(\d+);(\d+)m/) # \e[01;34m
+          color s[1], s[2]
+        elsif s.scan(/\e\[(\d+)[m;]/)
+          color s[1]
+        elsif s.scan(/\e\[([A-Z])/)
+          color s[1]
+        elsif s.scan(/\e\[m/)
+          # nothing?
+        elsif s.scan(/\e=\r/)
+          delete 'insert linestart', 'insert lineend'
+        else
+          p s.rest
+        end
+      when "\r"
+        if s.scan(/\r\n/)
+          insert :end, "\n"
+        elsif s.scan(/\r\r/)
+          delete 'insert linestart', 'insert lineend'
+        elsif s.scan(/\r[^\n\r]/)
+          p :no_rn => s.matched
+        else
+          p :r_fail => s.rest
+        end
+      when "\x07"
+        s.pos += 1
+        delete 'insert linestart', 'insert lineend'
+      when "\x08"
+        s.pos += 1
+        delete 'insert - 1 chars'
+      else
+        if s.scan(/\A[^\e\r\x08\x07]+/)
+          insert :end, s.matched
+        end
+      end
+     #  p s.matched
+
+      if s.pos == pos
+        warn("Scanner stopped at: %p" % [s])
+        @buffer = s.rest
+        return
+      end
+    end
+
+    @buffer = ''
+    @text.see :end
+  rescue StringScanner::Error => ex
+    VER.error(ex)
+  rescue => ex
+    puts "#{ex.class}: #{ex}", *ex.backtrace
+    @buffer = ''
+    destroy
+  end
+
+  def color(fg, bg = nil)
+    if bg
+      fg, bg = ANSI_CODES[fg.to_i], ANSI_CODES[bg.to_i]
+
+      @tag = [:ansi, fg, bg].join('_')
+      @text.tag_configure @tag, options_for(@tag, fg, bg)
+    else
+      fg = ANSI_CODES[fg.to_i]
+
+      @tag = [:ansi, fg].join('_')
+      @text.tag_configure @tag, options_for(@tag, fg)
+    end
+  end
+
+  FG_COLORS = [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white]
+  BG_COLORS = [:on_black, :on_red, :on_green, :on_yellow, :on_blue, :on_magenta, :on_cyan, :on_white]
+
+  def options_for(tag, fg, bg = nil)
+
+    if found = @option_cache[tag]
+      return found
+    end
+
+    options = {}
+
+    case fg
+    when nil
+    when :reset
+      options[:font] = @font
+      options[:background] = nil
+      options[:foreground] = nil
+    when :bold
+      options[:font] = font_for(@font_actual.merge(weight: :bold))
+    when *FG_COLORS
+      options[:foreground] = fg
+    when *BG_COLORS
+      options[:background] = bg.to_s.sub(/on_/, '')
+    else
+      p fg: fg
+    end
+
+    case bg
+    when nil
+    when :reset
+      options[:font] = @font
+      options[:background] = nil
+      options[:foreground] = nil
+    when *FG_COLORS
+      options[:foreground] = bg
+    when *BG_COLORS
+      options[:background] = bg.to_s.sub(/on_/, '')
+    else
+      p bg: bg
+    end
+
+    @option_cache[options] = options
+    options
+  end
+
+  def font_for(options)
+    @fonts ||= {}
+    @fonts[options] ||= Tk::Font.new(options)
+  end
+
+  def ansi2sym(ansi)
+    COLORS[ansi.to_i]
+  end
+
+  def insert(index, chars)
+    # p insert: [index, chars]
+    @text.insert(index, chars, @tag)
+  end
+
+  def delete(*indices)
+    # p delete: indices
+    @text.delete(*indices)
+  end
+end