ver 2010.02 → 2010.08

data/lib/ver/action.rb

@@ -1,43 +1,52 @@
 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
-
+  class Action < Struct.new(:invocation, :handler, :mode)
     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
+      case handler
+      when Symbol
+        widget.send(handler).send(*invocation, *given_args)
+      when Module
+        method, *args = *invocation
+        handler.send(method, widget, *args, *given_args)
+      when nil
+        widget.send(*invocation, *given_args)
+      else
+        raise ArgumentError
       end
     rescue => ex
-      puts self
-      pp ex, ex.backtrace
+      VER.error("Exception from %p" % [self])
+      VER.error(ex)
     end
 
     def combine(action)
-      new_args = [*args, action].compact
-      self.class.new(receiver, method, new_args, &block)
+      invocation = [*self.invocation, action]
+      self.class.new(invocation, handler, mode)
     end
 
-    def to_s
-      receiver, method, widget, *args = last
-      joined = [widget, *args.map{|arg| arg.inspect }].compact.join(' ')
+    def to_proc
+      Proc.new{|widget, *args| call(widget, *args) }
+    end
 
-      "%s.%s(%s)" % [receiver, method, joined]
+    def to_method(widget)
+      case handler
+      when Symbol
+        method = [*invocation].first
+        widget.send(handler).method(method)
+      when Module
+        method, *args = *invocation
+        handler.method(method)
+      when nil
+        method = [*invocation].first
+        widget.method(method)
+      else
+        raise ArgumentError
+      end
     end
+
+    def to_a
+      [mode, self]
+    end
+  end
+
+  class Fallback < Action
   end
 end

data/lib/ver/buffer.rb

@@ -1,229 +1,1047 @@
 module VER
-  class Buffer < Tk::Tile::Frame
-    autoload :Console, 'ver/buffer/console'
+  class Buffer < Text
+    include Keymapped
+    extend Forwardable
 
-    def self.[](name, line = nil, column = nil)
-      find_or_create(name, line, column)
+    autoload :Frame,                     'ver/buffer/frame'
+    autoload :InvalidTrailingWhitespace, 'ver/buffer/invalid_trailing_whitespace'
+    autoload :MarkupUnderlineLink,       'ver/buffer/markup_underline_link'
+    autoload :MatchingBrace,             'ver/buffer/matching_brace'
+
+    OPTIONS = {
+      autoseparators:      false,
+      background:          '#000',
+      blockcursor:         false,
+      borderwidth:         0,
+      exportselection:     true,   # provide selection to X automatically
+      foreground:          '#fff', # when first showing, it's not highlighted...
+      highlightbackground: '#000', # this specifies the colors
+      highlightcolor:      '#fff', # that are used when the widget
+      highlightthickness:  1,      # has input focus.
+      insertbackground:    '#fff',
+      relief:              :solid,
+      setgrid:             false,
+      tabstyle:            :wordprocessor,
+      takefocus:           true,
+      undo:                false,
+      wrap:                :word
+    }
+
+    MODE_STYLES = {
+      :control  => {blockcursor: false},
+      :insert   => {blockcursor: false, insertbackground: 'red'},
+      /select/  => {blockcursor: true,  insertbackground: 'yellow'},
+      /replace/ => {blockcursor: true,  insertbackground: 'orange'},
+    }
+
+    TAG_ALL_MATCHING_OPTIONS = { from: '1.0', to: 'end - 1 chars' }
+
+    PROJECT_DIRECTORY_GLOB = '{.git/,.hg/,_darcs/,_FOSSIL_}'
+
+    MODELINES = {
+      /\s+(?:ver|vim?|ex):\s*.*$/ => /\s+(?:ver|vim?|ex):\s*(.*)$/,
+      /\s+(?:ver|vim?|ex):[^:]+:/ => /\s+(?:ver|vim?|ex):([^:]+):/,
+      /^(?:ver|vim?):[^:]+:/      => /^(?:ver|vim?):([^:]+):/,
+    }
+
+    REPEAT_BREAK_CMD = [
+      :repeat_action,
+      :undo,
+      :redo,
+    ]
+
+    REPEAT_BREAK_MODE = [
+      :move,
+      :search,
+    ]
+
+    None = Object.new
+
+    def self.[](uri, line = nil, char = nil)
+      find_or_create(uri, line, char)
     end
 
-    def self.create(path = nil, line = nil, column = nil)
+    def self.create(path = nil, line = nil, char = 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
+        buffer.open(path, line, char)
         yield(buffer) if block_given?
         buffer
       end
     end
 
-    def self.find_or_create(name, line = nil, column = nil, &block)
-      case name
+    def self.find_or_create(uri, line = nil, char = nil, &block)
+      case uri
       when Pathname, Symbol
-        if buffer = VER.buffers[name]
-          buffer.after_found(line, column)
+        if buffer = VER.buffers.find{|buf| buf.uri == uri }
+          buffer.show
+          buffer.focus
+          buffer.at_insert.go_line_char(line, char)
+          yield buffer if block_given?
+          buffer
         else
-          create(name, line, column, &block)
+          create(uri, line, char, &block)
         end
       when String
-        path = Pathname(name.to_str).expand_path
-        find_or_create(path, line, column, &block)
+        path = Pathname(uri.to_str).expand_path
+        find_or_create(path, line, char, &block)
       else
         raise ArgumentError, "Invalid path: %p" % [path]
       end
     end
 
-    attr_reader :layout, :text, :status, :shown
+    attr_reader :frame, :status, :options, :at_current, :at_insert, :at_end,
+                :theme_config, :matching_brace, :layout, :syntax, :minibuf,
+                :snippets
+    attr_accessor :uri, :project_root, :project_repo, :undoer, :pristine,
+                  :prefix_arg, :readonly, :encoding, :filename, :at_sel,
+                  :symbolic, :locked, :register, :skip_prefix_count_once
 
-    def initialize(layout, options = {})
-      peer = options.delete(:peer)
-      options[:style] ||= VER.obtain_style_name('Buffer', 'TFrame')
-      super
+    # Hack for smoother minibuf completion
+    public :binding, :local_variables, :global_variables
 
-      @layout = layout
-      @text = @status = @ybar = @xbar = nil
-      @shown = true
-      setup(peer)
+    alias pristine? pristine
+    alias symbolic? symbolic
+    alias locked? locked
 
-      configure takefocus: false, padding: 2, border: 0, relief: :solid
-    end
+    def initialize(parent = VER.layout, given_options = {})
+      @layout = parent
+      @frame = Frame.new(parent, self)
+
+      font, tabstop = VER.options.font, VER.options.tabstop
+      tabs = font.measure('0') * tabstop
+
+      default_options = OPTIONS.merge(
+        font:            font,
+        insertofftime:   VER.options.insertofftime,
+        insertontime:    VER.options.insertontime,
+        tabs:            tabs
+      )
 
-    # this should be customized when neccesary
-    def name
-      text.filename || text.name
+      super(frame, default_options.merge(given_options))
+
+      setup
     end
 
-    # +-------+---+
-    # |       | @ |
-    # |       | y |
-    # | @text | b |
-    # |       | a |
-    # |       | r |
-    # +-------+---+
-    # | @xbar |   |
-    # +-------+---+
-    # |  @status  |
-    # +-----------+
-    def setup(peer)
-      setup_widgets(peer)
-      setup_grid
+    def setup
+      setup_tags
       setup_misc
+      setup_widgets
+      setup_layout
+      setup_binds
+      layout.bind('<Map>'){ Tk.update }
+    end
+
+    def setup_widgets
+      @status    = Status.new(frame, self)
+      @minibuf   = VER.minibuf.peer_create(frame, self)
+
+      if options.horizontal_scrollbar
+        @xbar = Tk::Tile::XScrollbar.new(frame)
+        xscrollbar(@xbar)
+      end
+
+      if options.vertical_scrollbar
+        @ybar = Tk::Tile::YScrollbar.new(frame)
+        yscrollbar(@ybar)
+      end
+    end
+
+    def setup_layout
+      self.    grid_configure row: 0, column: 0, sticky: :nsew
+      @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
+      @minibuf.grid_configure row: 3, column: 0, sticky: :ew
+
+      frame.grid_columnconfigure 0, weight: 1
+      frame.grid_columnconfigure 1, weight: 0
+      frame.grid_rowconfigure    0, weight: 1
+      frame.grid_rowconfigure    1, weight: 0
+      frame.grid_rowconfigure    2, weight: 0
+      frame.grid_rowconfigure    3, weight: 0
     end
 
-    def setup_widgets(peer)
-      if peer
-        setup_peer(peer)
+    def setup_misc
+      @store_hash     = Hash.new{|h,k| h[k] = {} }
+      @options        = Options.new(:text, VER.options)
+      @at_current     = Mark.new(self, :current)
+      @at_insert      = Insert.new(self)
+      @at_end         = End.new(self)
+      @at_sel         = Selection::Char.new(self, false)
+      @theme_config   = nil
+      @highlighter    = nil
+      @pristine       = true
+      self.register   = Register['*']
+      self.major_mode = :Fundamental
+    end
+
+    def setup_binds
+      bind('<<EnterMinorMode>>', &method(:on_enter_minor_mode))
+      bind('<<Modified>>',       &method(:on_modified))
+      bind('<<Movement>>',       &method(:on_movement))
+      bind('<FocusIn>',          &method(:on_focus_in))
+      bind('<FocusOut>',         &method(:on_focus_out))
+      bind('<Destroy>',          &method(:on_destroy))
+    end
+
+    def setup_tags
+      @invalid_trailing_whitespace = InvalidTrailingWhitespace.new(self)
+      @markup_underline_link       = MarkupUnderlineLink.new(self)
+      @matching_brace              = MatchingBrace.new(self)
+    end
+
+    def on_enter_minor_mode(event)
+      sync_mode_status
+      sync_mode_style(event.detail)
+    end
+
+    def on_modified(event)
+      on_movement(event)
+    end
+
+    def on_movement(event)
+      at_insert.see
+      at_sel.refresh
+      @matching_brace.refresh
+      sync_position_status
+    end
+
+    def on_focus_in(event)
+      if @minibuf.asking
+        @minibuf.focus
       else
-        setup_text
+        Dir.chdir(filename.dirname.to_s) if filename && options.auto_chdir
+        on_movement(event)
       end
 
-      setup_vertical_scrollbar if VER.options.vertical_scrollbar
-      setup_horizontal_scrollbar if VER.options.horizontal_scrollbar
-      setup_status
+      Tk.callback_break
     end
 
-    def setup_peer(peer)
-      @text = peer.peer_create(self)
+    def on_focus_out(event)
+      Tk.callback_break
     end
 
-    def setup_text
-      font, tabstop = VER.options.font, VER.options.tabstop
-      tabs = font.measure('0') * tabstop
+    def on_destroy(event)
+      @lock = true
+      frame.destroy
+      VER.cancel_block(@highlighter)
+      VER.buffers.delete(self)
+      unlock_uri(uri)
+    ensure
+      VER.defer{ VER.exit if VER.buffers.empty? }
+    end
 
-      @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
-      )
+    # This has to be called _before_ <Destroy> is received, otherwise the Buffer
+    # is half-dead.
+    def persist_info
+      file = VER.loadpath.first/'buffer_info.json'
+      l "Persisting Buffer info into: #{file}"
+
+      JSON::Store.new(file.to_s, true).transaction do |buffer_info|
+        syntax_name = @syntax.name if @syntax
+
+        buffer_info[uri.to_s] = {
+          'insert' => index('insert').to_s,
+          'syntax' => syntax_name
+        }
+      end
     end
 
-    def setup_vertical_scrollbar
-      @ybar = Tk::Tile::YScrollbar.new(self)
-      @text.yscrollbar(@ybar)
+    def load_info
+      file = VER.loadpath.first/'buffer_info.json'
+      l "Loading Buffer info from: #{file}"
+      JSON::Store.new(file.to_s, true).transaction do |buffer_info|
+        if info = buffer_info[uri.to_s]
+          return info
+        end
+      end
+
+      return {}
     end
 
-    def setup_horizontal_scrollbar
-      @xbar = Tk::Tile::XScrollbar.new(self)
-      @text.xscrollbar(@xbar)
+    def sync_mode_status
+      status.event :mode
     end
 
-    def setup_status
-      @status = Status.new(self)
+    def sync_position_status
+      status.event :position, :percent
     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
+    def sync_encoding_status
+      status.event :encoding
+    end
 
-      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
+    def sync_percent_status
+      status.event :percent
     end
 
-    def setup_misc
-      @text.status = @status
-      @text.buffer = self
+    def sync_mode_style(given_mode = nil)
+      config = (theme_config || {}).merge(blockcursor: false)
+
+      modes = given_mode ? [given_mode] : major_mode.minors
+
+      modes.each do |mode|
+        mode = MinorMode[mode]
+
+        MODE_STYLES.each do |pattern, style|
+          config.merge!(style) if pattern === mode.name
+        end
+      end
+
+      configure(config)
+      return unless status && color = config[:insertbackground]
+
+      status.style = {
+        background: cget(:background),
+        foreground: color,
+      }
     end
 
-    def open_path(path, line = 1, column = 0)
-      Methods::Open.open_path(text, path, line, column)
+    def events
+      major_mode.event_history
     end
 
-    def open_symbolic(name, line = 1, column = 0)
-      Methods::Open.open_symbolic(text, name, line, column)
+    def actions
+      major_mode.action_history
     end
 
-    def open_empty
-      Methods::Open.open_empty(text)
+    def message(*args)
+      @minibuf.message(*args)
     end
 
-    def focus
-      text.focus
+    def warn(*args)
+      @minibuf.warn(*args)
     end
 
-    def after_found(line, column, &block)
-      layout.push_top(self)
-      focus
-      go_line_column(line, column)
-      yield(self) if block_given?
-      self
+    def persisted?
+      return false unless filename
+      return false unless filename.file?
+      require 'digest/md5'
+
+      on_disk = Digest::MD5.hexdigest(filename.read)
+      in_memory = Digest::MD5.hexdigest(value)
+      on_disk == in_memory
     end
 
-    def go_line_column(line, column)
-      insert = text.index(:insert)
-      text.mark_set(:insert, "#{line || insert.y}.#{column || insert.x}")
+    def type(string)
+      major_mode.fake(string)
     end
 
-    def create_peer
-      layout.create_buffer(peer: text) do |buffer|
-        yield(buffer) if block_given?
+    def short_filename
+      if filename
+        if root = @project_root
+          filename.relative_path_from(root).to_s
+        else
+          filename.sub(Dir.pwd + '/', '').to_s
+        end
+      elsif uri
+        uri.to_s
       end
     end
 
-    def close
-      Methods::Save.may_close text do
-        layout.close_buffer(self)
+    def filename=(path)
+      @filename = Pathname(path.to_s).expand_path
+      status.event :filename if status
+    end
+
+    def encoding=(enc)
+      @encoding = enc
+      status.event :encoding if enc && status
+    end
+
+    def name=(name)
+      @name = name
+      status.event :filename if status
+    end
+
+    def syntax=(syn)
+      @syntax = syn
+      status.event :syntax if syn && status
+    end
+
+    def insert=(position)
+      at_insert.index = position
+    end
+
+    def delete(*indices)
+      return super unless undoer
+
+      undo_record do |record|
+        record.delete(*indices)
+      end
+    end
+
+    def replace(*args)
+      return super unless undoer
+
+      undo_record do |record|
+        record.replace(*args)
       end
     end
 
-    def shown?
-      @shown
+    def insert(*args)
+      return super unless undoer
+
+      undo_record do |record|
+        record.insert(*args)
+      end
     end
 
-    def hidden?
-      not @shown
+    def open(uri, line = 1, char = 0)
+      case uri
+      when Symbol
+        open_symbolic(uri, line, char)
+      when Pathname
+        open_pathname(uri, line, char)
+      when String, URI
+        open_uri(uri, line, char)
+      else
+        raise ArgumentError, "Invalid uri: %p" % [uri]
+      end
+
+      true
     end
 
-    def show
-      @shown = true
-      layout.apply
+    def open_symbolic(symbol, line, char)
+      self.uri = symbol
+      self.symbolic = true
+
+      case symbol
+      when :Scratch
+        self.value = <<-TEXT
+# This buffer is for notes you don't want to save, and for Ruby evaluation.
+# If you want to create a file, visit that file with :o.
+# then enter the text in that file's own buffer.
+        TEXT
+        syntax = 'Ruby'
+      when :Messages
+        clear
+        tag(:info).configure(foreground: '#aaf')
+        tag(:warn).configure(foreground: '#faa')
+        syntax = 'Plain Text'
+      when :Completions
+        clear
+        self.major_mode = :Completions
+        tag('ver.minibuf.completion').configure(foreground: '#fff')
+        syntax = 'Plain Text'
+      else
+        clear
+        syntax = 'Plain Text'
+      end
+
+      after_open(Syntax.new(syntax), line, char)
+    end
+
+    def open_pathname(pathname, line, char)
+      lock_uri(pathname) do |answer|
+        begin
+          case answer
+          when :single, :shared, :read_only
+            self.uri = self.filename = pathname
+
+            content, encoding = pathname.read_encoded_file
+            self.encoding = encoding
+            self.value = content.chomp
+            self.readonly = answer == :read_only || pathname.readonly?
+            self.locked = answer == :single
+            detect_project_paths
+            update_mtime
+            after_open(nil, line, char)
+          when :abort
+            close
+            :abort
+          when :quit
+            VER.exit
+          end
+        rescue Errno::ENOENT => ex
+          VER.error(ex)
+          open_empty(line, char)
+        end
+      end
+    end
+
+    def open_empty(line, char)
+      self.uri = '<empty>'
+      self.value = ''
+      self.encoding = value.encoding
+      self.readonly = false
+      after_open(nil, line, char)
+    end
+
+    def open_uri(uri, line, char)
+      self.uri = uri
+      self.value = Kernel.open(uri){|io| io.read.chomp }
+      after_open(nil, line, char)
+    end
+
+    def after_open(syntax = nil, line = nil, char = nil)
+      @undoer = VER::Undo::Tree.new(self)
+      VER.opened_file(self)
+      layout.wm_title = uri.to_s
+
+      info = load_info
+
+      if line || char
+        self.insert = "#{line || 1}.#{char || 0}"
+      else
+        self.insert = info['insert'] || '1.0'
+      end
+
+      VER.buffers << self
+      message "Opened #{uri}"
+
+      # Don't rely on the <Map> event, since it's prone to race-conditions.
+      finalize_open(syntax || info['syntax'])
+    rescue => ex
+      VER.error(ex)
+    end
+
+    def finalize_open(syntax)
+      VER.defer do
+        syntax ? setup_highlight_for(syntax) : setup_highlight
+        load_preferences
+        apply_modeline
+      end
+      bind('<Map>'){ at_insert.see }
+    end
+
+    def lock_uri(uri, &block)
+      lock = uri_lockfile(uri)
+
+      if lock.file? # omg, someone is using it!
+        info  = Hash[lock.read.scan(/^(\w+):\s*(.*)$/)]
+        ctime = lock.ctime
+        pid   = info['pid']
+        user  = info['user']
+        uri   = info['uri']
+        alive = info
+
+        prompt = <<-TEXT.chomp
+Found a lock file at: #{lock}
+owned by: #{user}
+used by: #{pid}
+dated: #{ctime}
+for: #{uri}
+
+Another program may be editing the same file.
+If this is the case, be careful not to end up with two different instances of the same file when making changes.
+Close this buffer or continue with caution.
+
+[O]pen Read-Only, [E]dit anyway, [D]elete lock, [Q]uit, [A]bort: 
+        TEXT
+
+        ask(prompt) do |answer, action|
+          case action
+          when :modified
+            case answer
+            when /o/i
+              yield :read_only
+              :abort
+            when /e/i
+              yield :shared
+              :abort
+            when /q/i
+              yield :quit
+              :abort
+            when /a/i
+              yield :abort
+              :abort
+            when /d/i
+              VER.defer do
+                lock.rm
+                lock_uri(uri, &block)
+              end
+              :abort
+            else
+              warn('invalid answer')
+              minibuf.answer = ''
+            end
+          end
+        end
+      else
+        File.open(lock, 'w+') do |file|
+          file.puts(
+            "pid: #{Process.pid}",
+            "uid: #{Process.uid}",
+            "uri: #{uri}"
+          )
+        end
+
+        yield :single
+      end
+    end
+
+    def unlock_uri(uri = self.uri)
+      return unless locked?
+      uri_lockfile(uri).rm_f
+    end
+
+    def uri_lockfile(uri = self.uri)
+      require 'tmpdir'
+      hash = Digest::SHA1.hexdigest(uri.to_s)
+      lock = Pathname.tmpdir/'ver/lock'/hash
+      lock.dirname.mkpath
+      lock
+    end
+
+    def update_mtime
+      store(:stat, :mtime, filename.mtime) if filename
+    rescue Errno::ENOENT
+    end
+
+    def detect_project_paths
+      return unless filename
+      parent = filename.expand_path.dirname
+
+      begin
+        (parent/PROJECT_DIRECTORY_GLOB).glob do |repo|
+          self.project_repo = repo
+          self.project_root = repo.dirname
+          return
+        end
+
+        parent = parent.dirname
+      end until parent.root?
+    end
+
+    def apply_modeline
+      MODELINES.each do |search_pattern, extract_pattern|
+        found = search(search_pattern, 1.0, :end, :count)
+        next if found.empty?
+
+        pos, count = found
+        line = get(pos, "#{pos} + #{count} chars")
+
+        line =~ extract_pattern
+        $1.scan(/[^:\s]+/) do |option|
+          apply_modeline_option(option)
+        end
+      end
+    end
+
+    def apply_modeline_option(option)
+      negative = option.gsub!(/^no/, '')
+      boolean = !negative
+
+      case option
+      when 'ai', 'autoindent'
+        set :autoindent, boolean
+      when 'et', 'expandtab'
+        set :expandtab, boolean
+      when /(?:tw|textwidth)=(\d+)/
+        set :textwidth, $1.to_i
+      when /(?:ts|tabstop)=(\d+)/
+        set :tabstop, $1.to_i
+      when /(?:sw|shiftwidth)=(\d+)/
+        set :shiftwidth, $1.to_i
+      when /(?:ft|filetype)=(\w+)/
+        set :filetype, $1
+      else
+        VER.warn "Unknown modeline: %p" % [option]
+      end
+    end
+
+    def set(option, value)
+      method = "set_#{option}"
+
+      if respond_to?(method)
+        if block_given?
+          __send__(method, value, &Proc.new)
+        else
+          __send__(method, value)
+        end
+      else
+        options[option] = value
+        yield(value) if block_given?
+      end
+    end
+
+    def set_filetype(type)
+      syntax = VER::Syntax.from_filename(Pathname("foo.#{type}"))
+
+      if load_syntax(syntax)
+        options.filetype = type
+      end
     end
 
     def hide
-      @shown = false
-      layout.apply
+      layout.hide
+    end
+
+    def show
+      layout.show
     end
 
-    def destroy
-      style_name = style
-      buffer_name = name
-      [@text, @ybar, @xbar, @status].compact.each(&:destroy)
+    def close
+      may_close do
+        persist_info
+        layout.destroy
+      end
+    end
+
+    def touch!(*indices)
+      tag_add('ver.highlight.pending', *indices.flatten)
+      Tk::Event.generate(self, '<<Modified>>')
+    end
+
+    def undo
+      undoer.undo if undoer
+    end
+
+    def redo
+      undoer.redo if undoer
+    end
 
-      super
+    # Use this method in commands that do multiple insert, delete, replace
+    def undo_record(&block)
+      VER.warn "Buffer is Read-only" if readonly
+      undoer ? undoer.record_multi(&block) : yield(self)
     ensure
-      VER.buffers.delete(buffer_name)
-      VER.return_style_name(style_name)
+      self.pristine = false
     end
 
-    def style
-      style = cget(:style)
-      style.first if style
+    def store(namespace, key, value = None)
+      if None == value
+        @store_hash[namespace][key]
+      else
+        @store_hash[namespace][key] = value
+      end
     end
 
-    def filename
-      text.filename
+    def change_register
+      major_mode.read(1) do |name|
+        if unicode = name.unicode
+          if unicode.empty?
+            warn "invalid name for register: %p" % [name]
+          else
+            self.register = Register[unicode]
+          end
+        else
+          warn "invalid name for register: %p" % [name]
+        end
+      end
+    end
+
+    def with_register
+      @with_register_level ||= 0
+      @with_register_level += 1
+      value = yield(register)
+      @with_register_level -= 1
+    ensure
+      self.register = Register['*'] if @with_register_level == 0
+    end
+
+    def update_prefix_arg
+      numbers = []
+
+      events.reverse_each do |event|
+        break unless event.keysym =~ /^(\d+)$/
+        numbers << $1
+      end
+
+      if numbers.any? && numbers != ['0']
+        self.prefix_arg = numbers.reverse.join.to_i
+      else
+        self.prefix_arg = nil
+      end
+    end
+
+    # Same as [prefix_arg], but returns 1 if there is no argument.
+    #
+    # The return value in case there is no argument can be changed by passing
+    # a +default+ argument.
+    #
+    # Useful for [Move] methods and the like.
+    # Please note that calling this method is destructive.
+    # It will reset the state of the prefix_arg in order to avoid persistent
+    # arguments.
+    # So use it only once while your action is running, and store the result in a
+    # variable if you need it more than once.
+    def prefix_count(default = 1)
+      if skip_prefix_count_once
+        self.skip_prefix_count_once = false
+        update_prefix_arg
+        return default
+      end
+
+      count = prefix_arg || default
+      update_prefix_arg
+      count
+    end
+
+    def repeat_action
+      stack = []
+
+      actions.reverse_each do |event, mode, action|
+        if stack.empty?
+          next if REPEAT_BREAK_CMD.include?(action.to_method(self).name)
+          next if REPEAT_BREAK_MODE.include?(mode.name)
+        else
+          break if REPEAT_BREAK_CMD.include?(action.to_method(self).name)
+          break if REPEAT_BREAK_MODE.include?(mode.name)
+        end
+
+        stack << [event, action]
+      end
+
+      return if stack.empty?
+
+      # make the argument the same for all called actions
+      prefix_arg = self.prefix_arg
+
+      stack.reverse_each do |event, action|
+        self.prefix_arg = prefix_arg
+        action.call(event)
+      end
+    end
+
+    def tag_exists?(given_path)
+      tag_names.include?(given_path)
+    rescue RuntimeError => ex
+      false
+    end
+
+    def tag_all_matching(name, regexp, options = {})
+      name = name.to_s
+      options = TAG_ALL_MATCHING_OPTIONS.merge(options)
+      from, to = options.values_at(:from, :to)
+
+      if tag_exists?(name)
+        tag_remove(name, from, to)
+      else
+        fg, bg = options.values_at(:foreground, :background)
+        tag_configure(name, foreground: fg, background: bg)
+      end
+
+      search_all(regexp, from, to) do |match, match_from, match_to|
+        name = yield(match, match_from, match_to) if block_given?
+        tag_add name, match_from, match_to
+      end
+    end
+
+    def search_all(regexp, start = '1.0', stop = 'end - 1 chars')
+      unless block_given?
+        return Enumerator.new(self, :search_all, regexp, start, stop)
+      end
+
+      while result = search(regexp, start, stop, :count)
+        pos, len = result
+        return if !pos || len == 0
+
+        from  = index(pos)
+        to    = index("#{pos} + #{len} chars")
+        match = get(from, to)
+
+        yield(match, from, to)
+
+        start = to
+      end
+    end
+
+    def rsearch_all(regexp, start = 'end', stop = '1.0')
+      unless block_given?
+        return Enumerator.new(self, :rsearch_all, regexp, start, stop)
+      end
+
+      while result = rsearch(regexp, start, stop, :count)
+        pos, len = result
+        break if !pos || len == 0
+
+        from = index(pos)
+        to   = index("#{pos} + #{len} chars")
+        match = get(from, to)
+
+        yield(match, from, to)
+
+        start = from
+      end
+    end
+
+    # OK, finally found the issue.
+    #
+    # the implementation of tk::TextUpDownLine is smart, but not smart enough.
+    # It doesn't assume large deltas between the start of up/down movement and
+    # the last other modification of the insert mark.
+    #
+    # This means that, after scrolling with up/down for a few hundred lines, it
+    # has to calculate the amount of display lines in between, which is a very
+    # expensive calculation and time increases O(delta_lines).
+    #
+    # We'll try to solve this another way, by assuming that there are at least a
+    # few other lines of same or greater length in between, we simply compare
+    # against a closer position and make delta_lines as small as possible.
+    #
+    #
+    # Now, if you go to, like column 100 of a line, and there is never a line as
+    # long for the rest of the file, the scrolling will still slow down a lot.
+    # This is an issue we can fix if we "forget" the @udl_pos_orig after a
+    # user-defined maximum delta (something around 200 should do), will
+    # implement that on demand.
+    def up_down_displayline(count)
+      insert = at_insert
+
+      @udl_pos_orig = insert if @udl_pos_prev != insert
+
+      lines = count(@udl_pos_orig, insert, :displaylines)
+      target = index("#@udl_pos_orig + #{lines + count} displaylines")
+      @udl_pos_prev = target
+
+      @udl_pos_orig = target if target.char == @udl_pos_orig.char
+      target
+    end
+
+    # This method goes up and down lines, not taking line wrapping into account.
+    # To go a line down, pass 1, to go one up -1, you get the idea.
+    # Tries to maintain the same char position across lines.
+    def up_down_line(count)
+      insert = at_insert
+
+      # if the last movement was not done by up_down_*, set new origin.
+      @udl_pos_orig = insert if @udl_pos_prev != insert
+
+      # count lines between origin and current insert position.
+      lines = count(@udl_pos_orig, insert, :lines)
+      # now get the target count lines below.
+      target = index("#@udl_pos_orig + #{lines + count} lines")
+
+      @udl_pos_prev = target
+
+      # if target has the same char pos as the previous one, use it as origin.
+      @udl_pos_orig = target if target.char == @udl_pos_orig.char
+      target
+    end
+
+    def setup_highlight
+      setup_highlight_for(Syntax.from_filename(filename)) if filename
+    end
+
+    def setup_highlight_for(syntax)
+      return if encoding == Encoding::BINARY
+      return unless syntax
+      syntax = Syntax.new(syntax) unless syntax.is_a?(Syntax)
+
+      self.syntax = syntax
+      VER.cancel_block(@highlighter)
+
+      interval = options.syntax_highlight_interval.to_int
+      @highlighter = VER.when_inactive_for(interval){
+        handle_pending_syntax_highlights
+      }
+
+      touch!('1.0', 'end')
+      handle_pending_syntax_highlights
+
+      sync_mode_status
+    end
+
+    def load_theme(name)
+      return unless syntax
+      return unless found = Theme.find(name)
+
+      syntax.theme = Theme.load(found)
+      touch!('1.0', 'end')
+
+      message "Theme #{found} loaded"
+    end
+
+    def load_syntax(name)
+      return false unless syntax
+
+      theme = syntax.theme
+
+      if name.is_a?(Syntax)
+        self.syntax = Syntax.new(name.name, theme)
+      elsif found = Syntax.find(name)
+        self.syntax = Syntax.new(name, theme)
+      else
+        return false
+      end
+
+      message "Syntax #{syntax.name} loaded"
+    end
+
+    def load_snippets
+      return unless syntax
+
+      name = syntax.name
+      return unless file = VER.find_in_loadpath("snippets/#{name}.rb")
+      @snippets = eval(file.read)
+    rescue Errno::ENOENT, TypeError => ex
+      VER.error(ex)
+    end
+
+    def load_preferences
+      return unless syntax
+
+      name = syntax.name
+      return unless file = VER.find_in_loadpath("preferences/#{name}.rb")
+      @preferences = eval(file.read)
+      apply_preferences
+    rescue Errno::ENOENT, TypeError => ex
+      VER.error(ex)
+    end
+
+    def apply_preferences
+      return unless @preferences
+
+      @preferences.each do |preference|
+        next unless preference[:name] == "Comments"
+        if settings = preference[:settings]
+          if shell_variables = settings[:shellVariables]
+            shell_variables.each do |variable|
+              name, value = variable.values_at(:name, :value)
+              ENV[name] = value
+
+              case name
+              when 'TM_COMMENT_START'
+                options.comment_line = value
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def handle_pending_syntax_highlights
+      ignore_tags = %w[ver.highlight.pending sel]
+
+      tag_ranges('ver.highlight.pending').each do |range|
+        from, to = range.first, range.last
+
+        (tag_names(from) - ignore_tags).each do |tag_name|
+          tag_from, _ = tag_prevrange(tag_name, from)
+          from = tag_from if tag_from && from > tag_from
+        end
+
+        (tag_names(to) - ignore_tags).each do |tag_name|
+          _, tag_to = tag_nextrange(tag_name, to)
+          to = tag_to if tag_to && to < tag_to
+        end
+
+        from, to = index("#{from} linestart"), index("#{to} lineend")
+        syntax.highlight(self, from.line - 1, from, to) if syntax
+        @invalid_trailing_whitespace.refresh(from: from, to: to)
+        @markup_underline_link.refresh(from: from, to: to)
+        tag_remove('ver.highlight.pending', from, to)
+      end
+    end
+
+    def default_theme_config=(config)
+      @theme_config = config
+      sync_mode_style
+    end
+
+    def ask(prompt, options = {}, &action)
+      options[:caller] ||= self
+      @minibuf.ask(prompt, options, &action)
+    end
+
+    class HighlightPending < Tag
+      NAME = 'ver.highlight.pending'.freeze
+
+      def initialize(buffer, name = NAME)
+        super
+      end
     end
   end
 end