ver 2009.12.14 → 2010.02

data/lib/ver/methods/clipboard.rb

@@ -1,46 +1,60 @@
 module VER
   module Methods
     module Clipboard
-      def copy_line
-        copy get('insert linestart', 'insert lineend + 1 chars')
+      module_function
+
+      def copy_line(text)
+        content = text.get('insert linestart', 'insert lineend + 1 chars')
+        copy(text, content)
       end
 
-      def copy_right_word
-        copy get('insert', 'insert wordend')
+      def copy_motion(text, motion, count = 1)
+        movement = Move.virtual(text, motion, count)
+        copy(text, text.get(*movement))
       end
 
-      def copy_left_word
-        copy get('insert', 'insert wordstart')
+      # FIXME: nasty hack or neccesary?
+      def paste(text)
+        content = clipboard_get(text, 'STRING'){
+          array = clipboard_get(text, 'ARRAY')
+          return paste_array(text, array) if array
+        }
+
+        paste_continous(text, content.to_s) if content
       end
 
-      def copy(text)
-        if text.respond_to?(:to_str)
-          copy_string(text)
-        elsif text.respond_to?(:to_ary)
-          copy_array(text)
+      def paste_above(text)
+        text.mark_set(:insert, 'insert - 1 line lineend')
+        paste(text)
+      end
+
+      def copy(text, content)
+        if content.respond_to?(:to_str)
+          copy_string(content.to_str)
+        elsif content.respond_to?(:to_ary)
+          copy_array(content.to_ary)
         else
-          copy_fallback(text)
+          copy_fallback(content)
         end
       end
 
-      def copy_string(text)
-        clipboard_set(text = text.to_str, type: 'STRING')
+      def copy_string(content)
+        Tk::Clipboard.set(content, type: 'STRING')
 
-        copy_message text.count("\n"), text.size
+        copy_message(content.count("\n") + 1, content.size)
       end
 
-      def copy_array(text)
-        array = text.to_ary
-        string = array.map(&:to_tcl).join(' ')
-        clipboard_set(string, type: 'ARRAY')
+      def copy_array(content)
+        marshal = [Marshal.dump(content)].pack('m')
+        Tk::Clipboard.set(marshal, type: 'ARRAY')
 
-        copy_message text.size, text.reduce(0){|s,v| s + v.size }
+        copy_message content.size, content.reduce(0){|s,v| s + v.size }
       end
 
-      def copy_fallback(text)
-        clipboard_set(text)
+      def copy_fallback(content)
+        Tk::Clipboard.set(content)
 
-        message "Copied unkown entity of class %p" % [text.class]
+        VER.message "Copied unkown entity of class %p" % [content.class]
       end
 
       def copy_message(lines, chars)
@@ -48,42 +62,40 @@ module VER
         chars_desc = chars == 1 ? 'character' : 'characters'
 
         msg = "copied %d %s of %d %s" % [lines, lines_desc, chars, chars_desc]
-        message msg
+        VER.message(msg)
       end
 
-      def paste_continous(text)
-        if text =~ /\A([^\n]*)\n\Z/
-          mark_set :insert, 'insert lineend'
-          insert :insert, "\n#{$1}"
-        elsif text =~ /\n/
-          mark_set :insert, 'insert lineend'
-          insert :insert, "\n"
-          text.each_line{|line| insert(:insert, line) }
+      def paste_continous(text, content)
+        if content =~ /\A([^\n]*)\n\Z/
+          text.mark_set :insert, 'insert lineend'
+          text.insert :insert, "\n#{$1}"
+        elsif content =~ /\n/
+          text.mark_set :insert, 'insert lineend'
+          text.insert :insert, "\n"
+          content.each_line{|line| text.insert(:insert, line) }
         else
-          insert :insert, text
+          text.insert :insert, content
         end
       end
 
-      def paste_tk_array(chunks)
-        insert_y, insert_x = index(:insert).split
+      def paste_array(text, marshal_array)
+        array = Marshal.load(marshal_array.unpack('m').first)
+        insert_y, insert_x = text.index(:insert).split
 
-        chunks.each_with_index do |chunk, idx|
-          y = insert_y + idx
-          insert "#{y}.#{insert_x}", chunk
+        Undo.record text do |record|
+          array.each_with_index do |line, index|
+            record.insert("#{insert_y + index}.#{insert_x}", line)
+          end
         end
       end
 
-      # FIXME: nasty hack or neccesary?
-      def paste
-        text = clipboard_get
-        paste_continous text.to_s
-
+      def clipboard_get(text, type = 'STRING')
+        Tk::Clipboard.get(text, type)
       rescue RuntimeError => ex
-        if ex.message =~ /form "STRING" not defined/
-          array = clipboard_get('ARRAY')
-          paste_tk_array array.to_a
+        if ex.message =~ /form "#{type}" not defined/
+          yield if block_given?
         else
-          Kernel.raise ex
+          VER.error(ex)
         end
       end
     end

data/lib/ver/methods/completion.rb

@@ -1,44 +1,104 @@
 module VER
   module Methods
     module Completion
+      module_function
+
       # TODO: use the tag names at the location to customize completion choices
       # the textmate bundles have quite some stuff for that.
-      def smart_tab
-        context = get('insert - 1 chars', 'insert + 1 chars')
+      def smart_tab(text)
+        context = text.get('insert - 1 chars', 'insert + 1 chars')
 
         if context =~ /^\S\W/
-          if @complete_last_used
-            complete_again
+          if text.store(self, :last_used)
+            complete_again(text)
           else
-            complete_word
+            snippet(text)
           end
         else
-          indent = ' ' * options.shiftwidth
-          insert :insert, indent
+          Snippet.jump(text) || complete_fallback(text)
         end
       end
 
-      def complete_again
-        send(@complete_last_used) if @complete_last_used
+      def complete(text, options = {}, &block)
+        Undo.separator(text)
+        VER::HoverCompletion.new(text, options, &block)
       end
 
-      def complete_tm
-        return unless load_preferences
-        require 'set'
-        require 'tempfile'
+      def complete_fallback(text)
+        indent = ' ' * text.options.shiftwidth
+        text.insert(:insert, indent)
+      end
 
-        @complete_last_used = :complete_tm
+      def complete_again(text)
+        if last_used = text.store(self, :last_used)
+          send(last_used, text)
+        end
+      end
+
+      def aspell(text)
+        text.store(self, :last_used, :aspell)
+
+        pos = text.index('insert - 1 chars')
+        from, to = pos.wordstart, pos.wordend
+        word = text.get(from, to)
+
+        complete text do
+          [from, to, aspell_completions(text, word)]
+        end
+      end
+
+      def contextual
+        return unless text.load_preferences
+        text.store(self, :last_used, :contextual)
 
         from, to = 'insert - 1 chars wordstart', 'insert - 1 chars wordend'
 
-        complete{ [from, to, tm_completions(from, to)] }
+        complete(text) do
+          [from, to, contextual_completions(text, from, to)]
+        end
+      end
+
+      def file(text)
+        text.store(self, :last_used, :file)
+
+        complete text, continue: true do
+          file_completions(text, 'insert linestart', 'insert')
+        end
+      end
+
+      def line(text)
+        text.store(self, :last_used, :line)
+
+        from, to = 'insert linestart', 'insert lineend'
+        lines = line_completions(text, from, to)
+
+        complete(text){ [from, to, lines] }
       end
 
-      def tm_completions(from, to)
-        tags  = Set.new(tag_names(to))
+      def snippet(text)
+        return unless text.load_snippets
+        text.store(self, :last_used, :snippet)
+
+        Snippet.dwim(text)
+      end
+
+      def word(text)
+        text.store(self, :last_used, :word)
+
+        y, x = text.index('insert').split
+        x = (x - 1).abs
+        from, to = text.index("#{y}.#{x} wordstart"), text.index("#{y}.#{x} wordend")
+
+        words = word_completions(text, from, to)
+
+        complete(text){ [from, to, words] }
+      end
+
+      def contextual_completions(text, from, to)
+        tags  = Set.new(text.tag_names(to))
         completions = []
 
-        @preferences.each do |key, value|
+        text.preferences.each do |key, value|
           name, scope, settings, uuid =
             value.values_at('name', 'scope', 'settings', 'uuid')
           scopes = Set.new(scope.split(/\s*,\s*|\s+/))
@@ -46,7 +106,7 @@ module VER
           next unless completion_command = settings['completionCommand']
           next unless scope_compare(tags, scopes)
 
-          current_word = get(from, to).strip
+          current_word = text.get(from, to).strip
           ENV['TM_CURRENT_WORD'] = current_word
 
           tmp = Tempfile.new('ver/complete_tm')
@@ -70,34 +130,18 @@ module VER
         scopes.all?{|scope| tags.any?{|tag| scope.start_with?(tag) }}
       end
 
-      def complete_line
-        @complete_last_used = :complete_line
-
-        from, to = 'insert linestart', 'insert lineend'
-        lines = line_completions(from, to)
-
-        complete{ [from, to, lines] }
-      end
-
-      def line_completions(from, to)
-        line = get(from, to).to_s.strip
+      def line_completions(text, from, to)
+        line = text.get(from, to).to_s.strip
 
         return [] if line.empty?
         needle = Regexp.escape(line)
-        search_all(/^.*#{needle}.*$/).map{|match, *_| match }.uniq
-      end
-
-      def complete_file
-        @complete_last_used = :complete_file
-
-        complete continue: true do
-          file_completions('insert linestart', 'insert')
-        end
+        text.search_all(/^.*#{needle}.*$/).map{|match, *_| match }.uniq
       end
 
-      def file_completions(from, to)
-        y = index(from).y
-        line = get(from, to)
+      # TODO: use filename_under_cursor, that should be much more accurate.
+      def file_completions(text, from, to)
+        y = text.index(from).y
+        line = text.get(from, to)
 
         return [] unless match = line.match(/(?<pre>.*?)(?<path>\/[^\s"'{}()\[\]]*)(?<post>.*?)/)
         from, to = match.offset(:path)
@@ -115,43 +159,20 @@ module VER
         return "#{y}.#{to - 1}", "#{y}.#{to}", list
       end
 
-      def complete_word
-        @complete_last_used = :complete_word
-
-        y, x = index('insert').split
-        x = (x - 1).abs
-        from, to = index("#{y}.#{x} wordstart"), index("#{y}.#{x} wordend")
-
-        words = word_completions(from, to)
-
-        complete{ [from, to, words] }
-      end
-
-      def word_completions(from, to)
-        prefix = get(from, to).strip
+      def word_completions(text, from, to)
+        prefix = text.get(from, to).strip
         return [] if prefix.empty?
         prefix = Regexp.escape(prefix)
 
-        found = search_all(/(^|\W)(#{prefix}[\w-]*)/).
-          sort_by{|match, mf, mt| [Text::Index.new(self, mf).delta(from), match] }.
-          map{|match, *_| match.strip[/[\w-]+/] }.uniq
+        found = text.search_all(/(^|\W)(#{prefix}[\w-]*)/).
+          sort_by{|match, mf, mt|
+            [VER::Text::Index.new(text, mf).delta(from), match]
+          }.map{|match, *_| match.strip[/[\w-]+/] }.uniq
         found.delete prefix
         found
       end
 
-      def complete_aspell
-        @complete_last_used = :complete_aspell
-
-        complete do
-          pos = index('insert - 1 chars')
-          from, to = pos.wordstart, pos.wordend
-          [from, to, aspell_completions(from, to)]
-        end
-      end
-
-      def aspell_completions(from, to)
-        word = get(from, to)
-
+      def aspell_completions(text, word)
         if result = aspell_execute(word)[word]
           result[:suggestions]
         else
@@ -181,11 +202,6 @@ module VER
 
         return results
       end
-
-      def complete(options = {}, &block)
-        undo_separator
-        HoverCompletion.new(self, options, &block)
-      end
     end
   end
 end

data/lib/ver/methods/control.rb

@@ -1,11 +1,140 @@
 module VER
   module Methods
     module Control
-      def repeat_command(count = 1)
-        return unless command = keymap.last_send
-        return if command.first == __method__
-        count.times{ send(*command) }
-        keymap.last_send = command
+      module_function
+
+      def enter(text, old_mode, new_mode)
+        clean_line(text, :insert)
+      end
+
+      def leave(text, old_mode, new_mode)
+        # clean_line(text, :insert)
+      end
+
+      def insert_at(text, motion, *count)
+        Move.send(motion, text, *count)
+        text.minor_mode(:control, :insert)
+      end
+
+      def insert_indented_newline_above(text)
+        Insert.insert_indented_newline_above(text)
+      end
+
+      def insert_indented_newline_below(text)
+        Insert.insert_indented_newline_below(text)
+      end
+
+      def open_file_under_cursor(text)
+        Open.open_file_under_cursor(text)
+      end
+
+      def source_buffer(text)
+        VER.message("Source #{text.filename}")
+        load(text.filename.to_s)
+      end
+
+      def cursor_vertical_top(text)
+        insert = text.count('1.0', 'insert', :displaylines)
+        last   = text.count('1.0', 'end', :displaylines)
+
+        fraction = ((100.0 / last) * insert) / 100
+
+        text.yview_moveto(fraction)
+      end
+
+      def cursor_vertical_top_sol(text)
+        cursor_vertical_top(text)
+        Move.start_of_line(text)
+      end
+
+      def cursor_vertical_center(text)
+        insert = text.count('1.0', 'insert', :displaylines)
+        last   = text.count('1.0', 'end', :displaylines)
+        shown  = text.count('@0,0', "@0,#{text.winfo_height}", :displaylines)
+
+        fraction = ((100.0 / last) * (insert - (shown / 2))) / 100
+
+        text.yview_moveto(fraction)
+      end
+
+      def cursor_vertical_center_sol(text)
+        cursor_vertical_center(text)
+        Move.start_of_line(text)
+      end
+
+      def cursor_vertical_bottom(text)
+        insert = text.count('1.0', 'insert', :displaylines) + 1
+        last   = text.count('1.0', 'end', :displaylines)
+        shown  = text.count('@0,0', "@0,#{text.winfo_height}", :displaylines)
+
+        fraction = ((100.0 / last) * (insert - shown)) / 100
+
+        text.yview_moveto(fraction)
+      end
+
+      def cursor_vertical_bottom_sol(text)
+        cursor_vertical_bottom(text)
+        start_of_line(text)
+      end
+
+      def chdir(text)
+        text.ask 'Change to: ' do |path, action|
+          case action
+          when :attempt
+            path = File.expand_path(path.to_s)
+
+            begin
+              Dir.chdir(path)
+              VER.message 'Changed working directory to %s' % [path]
+              :abort
+            rescue Errno::ENOENT => ex
+              VER.warn ex
+            end
+          end
+        end
+      end
+
+      # Toggle case of the character under the cursor up to +count+ characters
+      # forward (+count+ is inclusive the first character).
+      # This only works for alphabetic ASCII characters, no other encodings.
+      def toggle_case(text, count = text.prefix_count)
+        from, to = 'insert', "insert + #{count} chars"
+        chunk = text.get(from, to)
+        chunk.tr!('a-zA-Z', 'A-Za-z')
+        text.replace(from, to, chunk)
+      end
+
+      REPEAT_BREAK_CMD = [
+        :repeat_command,
+        :undo,
+        :redo,
+      ]
+
+      REPEAT_BREAK_MODE = [
+        :move,
+        :search,
+      ]
+
+      def repeat_command(text, count = text.prefix_count)
+        actions = []
+        text.major_mode.action_history.reverse_each do |event, mode, action|
+          if actions.empty?
+            next if REPEAT_BREAK_CMD.include?(action.method)
+            next if REPEAT_BREAK_MODE.include?(mode.name)
+          else
+            break if REPEAT_BREAK_CMD.include?(action.method)
+            break if REPEAT_BREAK_MODE.include?(mode.name)
+          end
+
+          actions << [action, event]
+        end
+
+        actions.reverse!
+
+        actions.each do |action, event|
+          event.prefix_arg = count
+          action.call(event)
+        end
       end
 
       # Assigns env variables used in the given command.
@@ -18,36 +147,36 @@ module VER
       #
       # @param [String] command
       #   The string containing the command executed
-      def prepare_exec(command)
-        prepare_exec_f if command =~ /\$f/
-        prepare_exec_d if command =~ /\$d/
-        prepare_exec_F if command =~ /\$F/
-        prepare_exec_i if command =~ /\$i/
-        prepare_exec_c if command =~ /\$c/
-        prepare_exec_s if command =~ /\$s/
+      def prepare_exec(text, command)
+        prepare_exec_f(text) if command =~ /\$f/
+        prepare_exec_d(text) if command =~ /\$d/
+        prepare_exec_F(text) if command =~ /\$F/
+        prepare_exec_i(text) if command =~ /\$i/
+        prepare_exec_c(text) if command =~ /\$c/
+        prepare_exec_s(text) if command =~ /\$s/
       end
 
-      def prepare_exec_f
+      def prepare_exec_f(text)
         p f: (ENV['f'] = filename.to_s)
       end
 
-      def prepare_exec_d
+      def prepare_exec_d(text)
         p d: (ENV['d'] = filename.directory.to_s)
       end
 
-      def prepare_exec_F
-        p F: (ENV['F'] = layout.views.map{|v| v.text.filename }.join(' '))
+      def prepare_exec_F(text)
+        p F: (ENV['F'] = VER.buffers.map{|key, buffer| buffer.filename }.join(' '))
       end
 
-      def prepare_exec_i
+      def prepare_exec_i(text)
         raise NotImplementedError
       end
 
-      def prepare_exec_c
+      def prepare_exec_c(text)
         p c: (ENV['c'] = clipboard_get)
       end
 
-      def prepare_exec_s
+      def prepare_exec_s(text)
         content = []
 
         each_selected_line do |y, fx, tx|
@@ -57,191 +186,190 @@ module VER
         ENV['s'] = content.join("\n")
       end
 
-      def exec_into_new(command = nil)
-        if command
-          target = options.home_conf_dir/'shell-result.txt'
-          prepare_exec(command)
-          p command
-          system(command)
-          target.open('w+'){|io| io.write(`#{command}`) }
-          view.find_or_create(target)
-        else
-          status_ask 'Command: ' do |command|
-            exec_into_new(command)
-          end
-        end
-      end
+      ENV_EXPORTERS = %w[
+        current_line current_word directory filepath line_index line_number
+        scope selected_text
+      ]
 
-      def exec_into_void
-        status_ask 'Command: ' do |command|
-          system(command)
-          message("Exit code: #{$?}")
+      # Set up the env for a script, then execute it.
+      # For now, I only setup the env, until we figure out a good way to find
+      # bundle commands.
+      def exec_bundle
+        ENV_EXPORTERS.each do |exporter|
+          ENV["VER_#{exporter.upcase}"] = ENV["TM_#{exporter.upcase}"] =
+            send("exec_env_#{exporter}").to_s
         end
-      end
 
-      def tags_at(index = :insert)
-        index = index(index)
-        tags = tag_names(index)
-        message tags.inspect
-
-        require 'ver/tooltip'
-
-        tooltip = Tk::Tooltip.new(tags.inspect)
-        tooltip.show_on(self)
-
-        Tk::After.ms(5000){ tooltip.destroy }
+        yield if block_given?
       end
 
-      # Substitute over all lines of the buffer
-      def gsub(regexp, with)
-        total = 0
-        index('1.0').upto(index('end')) do |index|
-          lineend = index.lineend
-          line = get(index, lineend)
+      # textual content of the current line
+      def exec_env_current_line
+        get('insert linestart', 'insert lineend')
+      end
 
-          if line.gsub!(regexp, with)
-            replace(index, lineend, line)
-            total += 1
-          end
-        end
+      # the word in which the caret is located.
+      def exec_env_current_word
+        get('insert wordstart', 'insert wordend')
+      end
 
-        message "Performed gsub on #{total} lines"
+      # the folder of the current document (may not be set).
+      def exec_env_directory
+        filename.dirname.to_s
       end
 
-      # Substitute on current line
-      def sub(regexp, with)
-        linestart = index('insert linestart')
-        lineend = linestart.lineend
-        line = get(linestart, lineend)
+      # path (including file name) for the current document (may not be set).
+      def exec_env_filepath
+        filename.to_s
+      end
 
-        if line.sub!(regexp, with)
-          replace(linestart, lineend, line)
-        end
+      # the index in the current line which marks the caret's location.
+      # This index is zero-based and takes the utf-8 encoding of the line (e.g.
+      # read as TM_CURRENT_LINE) into account.
+      def exec_env_line_index
+        index('insert').x
       end
 
-      def open_grep_list
-        View::List::Grep.new self do |file, line|
-          view.find_or_create(file, line)
-        end
+      # the carets line position (counting from 1).
+      def exec_env_line_number
+        index('insert').y
       end
 
-      def grep_buffer
-        View::List::Grep.new self, filename do |file, line|
-          view.find_or_create(file, line)
-        end
+      def exec_env_scope
+        tag_names('insert').join(', ')
       end
 
-      def grep_buffers
-        glob = '{' << layout.views.map{|v| v.text.filename }.join(',') << '}'
+      # full content of the selection (may not be set).
+      # Note that environment variables have a size limitation of roughly 64 KB,
+      # so if the user selects more than that, this variable will not reflect
+      # the actual selection (commands that need to work with the selection
+      # should generally set this to be the standard input).
+      def exec_env_selected_text
+        content = []
 
-        View::List::Grep.new self, glob do |file, line|
-          view.find_or_create(file, line)
+        each_selected_line do |y, fx, tx|
+          content << get("#{y}.#{fx}", "#{y}.#{tx}")
         end
+
+        content.join("\n")
       end
 
-      def open_method_list
-        View::List::Methods.new self do |file, line|
-          view.find_or_create(file, line)
+      def exec_into_new(text, command = nil)
+        if command
+          target = text.options.home_conf_dir/'shell-result.txt'
+          prepare_exec(command)
+          system(command)
+          target.open('w+'){|io| io.write(`#{command}`) }
+          VER.find_or_create_buffer(target)
+        else
+          text.ask 'Command: ' do |answer, action|
+            case action
+            when :attempt
+              begin
+                exec_into_new(answer)
+                :abort
+              rescue => ex
+                VER.warn(ex)
+              end
+            end
+          end
         end
       end
 
-      # TODO: make this better?
-      def status_ex
-        completion = method(:status_ex_filter)
-
-        View::List::Ex.new self, completion do |command, propose|
-          begin
-            result = propose ? send(command, propose) : eval(command)
-            status.message "%s # => %p" % [command, result]
-          rescue Exception => ex
-            status.error "%s # => %p" % [command, ex]
+      def exec_into_void(text)
+        text.ask 'Command: ' do |command, action|
+          case action
+          when :attempt
+            begin
+              system(command)
+              VER.message("Exit code: #{$?}")
+              :abort
+            rescue => ex
+              VER.warn(ex)
+            end
           end
         end
       end
 
-      def status_ex_filter(input)
-        input = input.to_s.split.last
-        return [] if !input || input.empty?
-
-        begin
-          regexp = Regexp.new(input)
-        rescue ArgumentError, RegexpError, SyntaxError
-          regexp = Regexp.new(Regexp.escape(input))
-        end
+      def tags_at(index = :insert)
+        index = index(index)
+        tags = tag_names(index)
+        VER.message tags.inspect
 
-        self.methods.grep(regexp).sort_by{|sym| sym =~ regexp }
-      end
+        require 'ver/tooltip'
 
-      def open_console
-        View::Console.new(self)
-      end
+        tooltip = Tk::Tooltip.new(tags.inspect)
+        tooltip.show_on(self)
 
-      def open_terminal
-        require 'ver/view/term'
-        View::Terminal.new(self)
+        Tk::After.ms(5000){ tooltip.destroy }
       end
 
-      def wrap_line
-        text = get('insert linestart', 'insert lineend')
-        textwidth = options[:textwidth]
-        lines = wrap_lines_of(text, textwidth).join("\n")
-        lines.rstrip!
+      # Substitute over all lines of the buffer
+      def gsub(text, regexp, with)
+        total = 0
+        Undo.record text do |record|
+          text.index('1.0').upto(text.index('end')) do |index|
+            lineend = index.lineend
+            line = text.get(index, lineend)
+
+            if line.gsub!(regexp, with)
+              record.replace(index, lineend, line)
+              total += 1
+            end
+          end
+        end
 
-        replace('insert linestart', 'insert lineend', lines)
+        VER.message "Performed gsub on #{total} lines"
       end
 
-      def status_theme_select
-        return unless @syntax
+      # Substitute on current line
+      def sub(text, regexp, with)
+        linestart = text.index('insert linestart')
+        lineend = linestart.lineend
+        line = text.get(linestart, lineend)
 
-        status_ask 'Theme name: ' do |name|
-          load_theme(name) || "No theme called #{name} found"
+        if line.sub!(regexp, with)
+          text.replace(linestart, lineend, line)
         end
       end
 
-      def theme_switch
-        return unless @syntax
-
-        View::List::Theme.new(self){|name| load_theme(name) }
+      def executor(text, action = nil)
+        VER::Executor.new(text, action: action)
       end
+      alias ex executor
+      module_function :ex
 
-      def syntax_switch
-        return unless @syntax
-
-        View::List::Syntax.new(self){|name| load_syntax(name) }
-      end
+      def wrap_line(text)
+        content = text.get('insert linestart', 'insert lineend')
+        textwidth = text.options.textwidth
+        lines = wrap_lines_of(content, textwidth).join("\n")
+        lines.rstrip!
 
-      def status_evaluate
-        status_ask 'Eval expression: ' do |term|
-          begin
-            eval(term)
-          rescue Exception => ex
-            ex
-          end
-        end
+        text.replace('insert linestart', 'insert lineend', lines)
       end
 
-      def smart_evaluate
-        if sel = tag_ranges(:sel)
+      def smart_evaluate(text)
+        if sel = text.tag_ranges(:sel)
           from, to = sel.first
-          return selection_evaluate if from && to
+          return Selection.evaluate(text) if from && to
         end
 
-        line_evaluate
+        line_evaluate(text)
       end
 
-      def line_evaluate
-        text = get('insert linestart', 'insert lineend')
-        stdout_capture_evaluate(text) do |res,out|
-          insert("insert lineend", "\n%s%p" % [out, res] )
+      def line_evaluate(text)
+        content = text.get('insert linestart', 'insert lineend')
+        stdout_capture_evaluate(content, text.filename, binding) do |res,out|
+          text.insert("insert lineend", "\n%s%p" % [out, res] )
         end
       end
 
-      def stdout_capture_evaluate(code)
+      def stdout_capture_evaluate(code, file, binding = binding)
         begin
           old_stdout = $stdout.dup
           rd, wr = IO.pipe
           $stdout.reopen(wr)
-          result = eval(code)
+          result = eval(code, binding, file.to_s)
           $stdout.reopen old_stdout; wr.close
           stdout = rd.read
 
@@ -260,75 +388,31 @@ module VER
         VER.error(exception)
       end
 
-      def buffer_switch
-        View::List::Buffer.new self do |file|
-          view.find_or_create(file) if File.exists?(file)
-        end
+      def join_line_forward(text)
+        from, to = 'insert linestart', 'insert + 1 lines lineend'
+        lines = text.get(from, to)
+        text.replace(from, to, lines.gsub(/\s*\n\s*/, ' '))
       end
 
-      def window_switch(count = nil)
-        if count
-          # p count: count
-        else
-          View::List::Window.new self do |view|
-            view.push_top
-            view.focus
-          end
-        end
-      end
-
-      def file_open_popup
-        filetypes = [
-          ['ALL Files',  '*'    ],
-          ['Text Files', '*.txt'],
-        ]
-
-        fpath = Tk.get_open_file(filetypes: filetypes)
-
-        return unless fpath
-
-        view.find_or_create(fpath)
-      end
-
-      def file_open_fuzzy
-        View::List::FuzzyFileFinder.new self do |path|
-          view.find_or_create(path)
-        end
+      def join_line_backward(text)
+        from, to = 'insert - 1 lines linestart', 'insert lineend'
+        lines = text.get(from, to)
+        text.replace(from, to, lines.gsub(/\s*\n\s*/, ' '))
       end
 
-      def join_lines
-        start_of_next_line = search(/\S/, 'insert lineend').first
-        replace('insert lineend', start_of_next_line, ' ')
-      rescue RuntimeError => exception
-        return if exception.message =~ /Index "\d+\.\d+" before "insert lineend" in the text/
-        Kernel.raise exception
+      def indent_line(text, count = text.prefix_count)
+        indent = (' ' * text.options[:shiftwidth] * count)
+        text.insert('insert linestart', indent)
       end
 
-      def replace_char
-        status_ask 'Replace with: ', take: 1 do |char|
-          if char.size == 1
-            replace('insert', 'insert + 1 chars', char)
-            backward_char
-            "replaced #{char.size} chars"
-          else
-            status.message 'replace aborted'
-          end
-        end
-      end
-
-      def indent_line(count = 1)
-        indent = (' ' * options[:shiftwidth] * count)
-        insert('insert linestart', indent)
-      end
-
-      def unindent_line(count = 1)
-        indent = ' ' * options[:shiftwidth]
+      def unindent_line(text, count = text.prefix_count)
+        indent = ' ' * text.options[:shiftwidth]
         replace_from = 'insert linestart'
         replace_to = "insert linestart + #{indent.size} chars"
 
-        undo_record do |record|
+        Undo.record text do |record|
           count.times do
-            line = get('insert linestart', 'insert lineend')
+            line = text.get('insert linestart', 'insert lineend')
 
             return unless line.start_with?(indent)
 
@@ -337,34 +421,23 @@ module VER
         end
       end
 
-      def clean_line(index, record = self)
-        index = index(index)
+      def clean_line(text, index, record = text)
+        index = text.index(index)
         from, to = index.linestart, index.lineend
-        line = get(from, to)
+        line = text.get(from, to)
         bare = line.rstrip
         record.replace(from, to, bare) if bare.empty?
       end
 
-      def start_insert_mode
-        self.mode = :insert
-      end
-
-      def start_control_mode
-        clean_line(:insert)
-        self.mode = :control
-      end
-
-      private
-
-      def wrap_lines_of(text, wrap = 80)
+      def wrap_lines_of(content, wrap = 80)
         Kernel.raise ArgumentError, "+wrap+ must be > 1" unless wrap > 1
         wrap -= 1
 
-        indent = text[/^\s+/] || ''
+        indent = content[/^\s+/] || ''
         indent_size = indent.size
         lines = [indent.dup]
 
-        text.scan(/\S+/) do |chunk|
+        content.scan(/\S+/) do |chunk|
           last = lines.last
           last_size = last.size
           chunk_size = chunk.size
@@ -383,22 +456,6 @@ module VER
 
         lines
       end
-
-      def status_ask(prompt, options = {}, &callback)
-        @status.ask(prompt, options){|*args|
-          begin
-            callback.call(*args)
-          rescue => ex
-            VER.error(ex)
-          ensure
-            begin
-              focus
-            rescue RuntimeError
-              # might have been destroyed, stay silent
-            end
-          end
-        }
-      end
     end
   end
 end