ver 2009.12.14 → 2010.02

data/lib/ver/view.rb

@@ -1,190 +0,0 @@
-module VER
-  class View < Tk::Frame
-    autoload :Entry,   'ver/view/entry'
-    autoload :List,    'ver/view/list'
-    autoload :Console, 'ver/view/console'
-
-    attr_reader :layout, :text, :status
-
-    def initialize(layout, options = {})
-      super
-      @layout = layout
-      @text = @status = @ybar = @xbar = nil
-      configure takefocus: false
-      setup
-    end
-
-    # +-------+---+
-    # |       | @ |
-    # |       | y |
-    # | @text | b |
-    # |       | a |
-    # |       | r |
-    # +-------+---+
-    # | @xbar |   |
-    # +-------+---+
-    # |  @status  |
-    # +-----------+
-    def setup
-      setup_widgets
-      setup_grid
-      setup_misc
-      setup_events
-    end
-
-    def setup_widgets
-      setup_text
-      setup_vertical_scrollbar if VER.options.vertical_scrollbar
-      setup_horizontal_scrollbar if VER.options.horizontal_scrollbar
-      setup_status
-    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
-        font:             font,
-        insertofftime:    VER.options.insertofftime,
-        insertontime:     VER.options.insertontime,
-        setgrid:          true, # tell the wm that this is a griddy window
-        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, font: VER.options[:font], takefocus: false)
-    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
-    end
-
-    def setup_misc
-      @text.status = @status
-      @text.view = self
-      @status.mode = :status_query
-    end
-
-    def setup_events
-      %w[Modified Focus Movement].each do |name|
-        @text.bind("<<#{name}>>"){|event| __send__("on_#{name.downcase}", event) }
-      end
-    end
-
-    def open_path(path, line = 1)
-      @text.open_path(path, line)
-    end
-
-    def open_empty
-      @text.open_empty
-    end
-
-    # handling events
-
-    def on_movement(event)
-      @text.see :insert
-      @text.refresh_selection
-      @text.status_projection(@status)
-    end
-
-    def on_modified(event)
-      @text.see :insert
-      # @text.refresh_highlight
-      @text.status_projection(@status)
-    end
-
-    def on_focus(event)
-      @text.set_window_title
-      @text.see(:insert)
-    end
-
-    def focus
-      text.focus
-    end
-
-    def create(path = nil, line = nil)
-      layout.create_view do |view|
-        path ? view.open_path(path, line) : view.open_empty
-        yield(view) if block_given?
-      end
-    end
-
-    def find_or_create(path, line = nil, &block)
-      needle = Pathname(path.to_s).expand_path
-
-      if found = layout.views.find{|view| view.filename == needle }
-        found.push_top
-        found.focus
-        found.text.go_line(line) if line
-        yield(found) if block_given?
-      else
-        create(needle, line, &block)
-      end
-    end
-
-    def close
-      text.may_close do
-        layout.close_view(self)
-      end
-    end
-
-    def focus_next
-      layout.focus_next(self)
-    end
-
-    def focus_prev
-      layout.focus_prev(self)
-    end
-
-    def push_up
-      layout.push_up(self)
-    end
-
-    def push_down
-      layout.push_down(self)
-    end
-
-    def push_top
-      layout.push_top(self)
-    end
-
-    def push_bottom
-      layout.push_bottom(self)
-    end
-
-    def destroy
-      [@text, @ybar, @xbar, @status].compact.each(&:destroy)
-
-      super
-    end
-
-    def filename
-      text.filename
-    end
-  end
-end

data/lib/ver/view/console.rb

@@ -1,171 +0,0 @@
-require 'eventmachine'
-
-module VER
-  class View
-    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/view/entry.rb

@@ -1,32 +0,0 @@
-module VER
-  class View
-    # This sucks, should we go method_missing?
-    class Entry < VER::Entry
-      attr_accessor :list_view
-
-      def pick_first
-        list_view.pick_first
-      end
-
-      def pick_selection
-        list_view.pick_selection
-      end
-
-      def cancel
-        list_view.cancel
-      end
-
-      def line_up
-        list_view.line_up
-      end
-
-      def line_down
-        list_view.line_down
-      end
-
-      def completion
-        list_view.completion
-      end
-    end
-  end
-end

data/lib/ver/view/list.rb

@@ -1,152 +0,0 @@
-module VER
-  class View::List < Struct.new(:parent, :frame, :list, :entry, :tag, :callback)
-    autoload :Buffer,          'ver/view/list/buffer'
-    autoload :Grep,            'ver/view/list/grep'
-    autoload :Methods,         'ver/view/list/methods'
-    autoload :Window,          'ver/view/list/buffer'
-    autoload :FuzzyFileFinder, 'ver/view/list/fuzzy_file_finder'
-    autoload :Syntax,          'ver/view/list/syntax'
-    autoload :Theme,           'ver/view/list/theme'
-    autoload :Ex,              'ver/view/list/ex'
-
-    def initialize(parent, &block)
-      self.parent, self.callback = parent, block
-
-      setup_widgets
-      setup_keymap
-      setup_events
-      on_update
-    end
-
-    def setup_widgets
-      self.frame = Tk::Frame.new.pack fill: :both, expand: true
-
-      self.list = list = Tk::Listbox.new(frame)
-      list.configure(
-        setgrid: true,
-        width: 0,
-        background: '#000',
-        foreground: '#fff',
-        selectforeground: '#000',
-        selectbackground: '#fff',
-        exportselection: false,
-        font: VER.options[:font]
-      )
-      list.pack fill: :both, expand: true
-
-      self.entry = entry = View::Entry.new(frame)
-      entry.configure font: VER.options[:font]
-      entry.pack fill: :x, expand: false
-      entry.focus
-      entry.list_view = self
-    end
-
-    def setup_keymap
-      keymap_name = VER.options.keymap
-
-      @list_keymap = Keymap.get(
-        name: keymap_name, receiver: self, widget: list, mode: :list_view_list)
-
-      @entry_keymap = Keymap.get(
-        name: keymap_name, receiver: entry, widget: entry, mode: :list_view_entry)
-    end
-
-    # Setup this event, because Keymap gets very confused when you bind 'Key' and
-    # we don't want to break the event-chain anyway
-    def setup_events
-      entry.bind('<<Inserted>>'){ on_update }
-    end
-
-    def on_update
-      update
-      list.selection_set(0)
-      list.activate(0)
-    end
-
-    def quit
-      VER.exit
-    end
-
-    def line_up
-      index = list.curselection.first - 1
-
-      if index >= 0
-        list.selection_clear(0, 'end')
-        select_index(index)
-      end
-    end
-
-    def line_down
-      index = list.curselection.first + 1
-      max = list.size
-
-      if index < max
-        list.selection_clear(0, 'end')
-        select_index(index)
-      end
-    end
-
-    def select_index(index)
-      list.selection_set(index)
-      list.activate(index)
-      list.see(index)
-    end
-
-    def cancel
-      destroy
-    end
-
-    def destroy
-      entry.destroy
-      list.destroy
-      frame.destroy
-      parent.focus
-    end
-
-    def sublist(list, input = entry.value)
-      if input == input.downcase
-        list.select{|item| item.to_s.downcase.include?(input) }
-      else
-        list.select{|item| item.to_s.include?(input) }
-      end
-    end
-
-    def pick(item)
-      if list.size > 0
-        pick_action(item)
-        destroy
-      else
-        message "VER is confused, what did you actually want to do?"
-      end
-    end
-
-    def pick_first
-      pick list.get(0)
-    end
-
-    def pick_selection
-      pick list.get(list.curselection.first)
-    end
-
-    def pick_action(*args)
-      callback.call(*args) if callback
-    end
-
-    def completion
-      values = list.get(0, :end)
-
-      if values.size == 1
-        entry.value = values.first
-      elsif values.size > 1
-        require 'abbrev'
-        if found = values.abbrev[entry.value]
-          entry.value = found
-        end
-      end
-    end
-
-    def message(string)
-      parent.status.message(string)
-    end
-  end
-end