ver 2009.10.14 → 2009.11.28

data/lib/ver/methods/control.rb

@@ -1,6 +1,103 @@
 module VER
   module Methods
     module Control
+      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 }
+      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)
+
+          if line.gsub!(regexp, with)
+            replace(index, lineend, line)
+            total += 1
+          end
+        end
+
+        message "Performed gsub on #{total} lines"
+      end
+
+      # Substitute on current line
+      def sub(regexp, with)
+        linestart = index('insert linestart')
+        lineend = linestart.lineend
+        line = get(linestart, lineend)
+
+        if line.sub!(regexp, with)
+          replace(linestart, lineend, line)
+        end
+      end
+
+      def open_grep_list
+        View::List::Grep.new self do |file, line|
+          view.find_or_create(file, line)
+        end
+      end
+
+      def open_method_list
+        View::List::Methods.new self do |file, line|
+          view.find_or_create(file, line)
+        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]
+          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
+
+        self.methods.grep(regexp).sort_by{|sym| sym =~ regexp }
+      end
+
+      def open_console
+        View::Console.new(self)
+      end
+
+      def open_terminal
+        require 'ver/view/term'
+        View::Terminal.new(self)
+      end
+
+      def wrap_line
+        text = get('insert linestart', 'insert lineend')
+        textwidth = options[:textwidth]
+        lines = wrap_lines_of(text, textwidth).join("\n")
+        lines.rstrip!
+
+        replace('insert linestart', 'insert lineend', lines)
+      end
+
       def status_theme_select
         return unless @syntax
 
@@ -23,197 +120,107 @@ module VER
 
       def status_evaluate
         status_ask 'Eval expression: ' do |term|
-          eval(term)
-        end
-      end
-
-      def status_ask(prompt, &callback)
-        @status.ask(prompt){|*args|
           begin
-            callback.call(*args)
-          rescue => ex
-            p ex
-            status.message ex.message
-          ensure
-            focus
+            eval(term)
+          rescue Exception => ex
+            ex
           end
-        }
+        end
       end
 
       def smart_evaluate
-        from, to = tag_ranges(:sel).first
-
-        if from && to
-          selection_evaluate
-        else
-          line_evaluate
+        if sel = tag_ranges(:sel)
+          from, to = sel.first
+          return selection_evaluate if from && to
         end
+
+        line_evaluate
       end
 
       def line_evaluate
         text = get('insert linestart', 'insert lineend')
-        result = eval(text)
-        insert("insert lineend", "\n#{result.inspect}\n")
+        stdout_capture_evaluate(text) do |res,out|
+          insert("insert lineend", "\n%s%p" % [out, res] )
+        end
+      end
+
+      def stdout_capture_evaluate(code)
+        begin
+          old_stdout = $stdout.dup
+          rd, wr = IO.pipe
+          $stdout.reopen(wr)
+          result = eval(code)
+          $stdout.reopen old_stdout; wr.close
+          stdout = rd.read
+
+          yield(result, stdout)
+        rescue Exception => exception
+          yield(exception, '')
+        ensure
+          wr.closed? || $stdout.reopen(old_stdout) && wr.close
+          rd.closed? || rd.close
+        end
+      end
+
+      def eval_buffer
+        result = eval(value, TOPLEVEL_BINDING)
+      rescue Exception => exception
+        VER.error(exception)
       end
 
       def buffer_switch
         View::List::Buffer.new self do |file|
-
-          # VER.resume_buffer file_path
-          open_path file if File.exists? file
+          view.find_or_create(file) if File.exists?(file)
         end
       end
 
       def window_switch(count = nil)
         if count
-          p count: count
+          # p count: count
         else
           View::List::Window.new self do |view|
+            view.push_top
             view.focus
-            # open_path(path)
           end
         end
       end
 
-      def file_save
-        save_to(filename)
-      end
-
-      def file_save_popup
-        filetypes = [
-          ['ALL Files',  '*'    ],
-          ['Text Files', '*.txt'],
-        ]
-
-        filename  = ::File.basename @filename
-        extension = ::File.extname  @filename
-        directory = ::File.dirname  @filename
-
-        fpath = Tk.getSaveFile(
-          initialfile: filename,
-          initialdir: directory,
-          defaultextension: extension,
-          filetypes: filetypes
-        )
-
-        return if fpath.empty?
-
-        save_to(fpath)
-      end
-
-      # Some strategies are discussed at:
-      #
-      # http://bitworking.org/news/390/text-editor-saving-routines
-      #
-      # I try another, "wasteful" approach, copying the original file to a
-      # temporary location, overwriting the contents in the copy, then moving the
-      # file to the location of the original file.
-      #
-      # This way all permissions should be kept identical without any effort, but
-      # it will take up additional disk space.
-      #
-      # If there is some failure during the normal saving procedure, we will
-      # simply overwrite the original file in place, make sure you have good insurance ;)
-      def save_to(to)
-        save_smart(filename, to)
-      rescue => ex
-        puts "#{ex.class}: #{ex}", *ex.backtrace
-        save_dumb(filename, to)
-      end
-
-      def save_smart(from, to)
-        sha1 = Digest::SHA1.hexdigest([from, to].join)
-        temp_path = File.join(Dir.tmpdir, 'ver', sha1)
-        temp_dir = File.dirname(temp_path)
-
-        FileUtils.mkdir_p(temp_dir)
-        FileUtils.copy_file(from, temp_path, preserve = true)
-        File.open(temp_path, 'w+') do |io|
-          io.write(self.value)
-        end
-        FileUtils.mv(temp_path, to)
-
-        status.message "Saved to #{to}"
-      rescue Errno::ENOENT
-        save_dumb(to)
-      end
-
-      def save_dumb(to)
-        File.open(to, 'w+') do |io|
-          io.write(self.value)
-        end
-
-        status.message "Saved to #{to}"
-      end
-
       def file_open_popup
         filetypes = [
           ['ALL Files',  '*'    ],
           ['Text Files', '*.txt'],
         ]
 
-        fpath = Tk.getOpenFile(filetypes: filetypes)
+        fpath = Tk.get_open_file(filetypes: filetypes)
 
-        return if fpath.empty?
+        return unless fpath
 
-        open_path(fpath)
+        view.find_or_create(fpath)
       end
 
       def file_open_fuzzy
         View::List::FuzzyFileFinder.new self do |path|
-          open_path(path)
+          view.find_or_create(path)
         end
       end
 
-      def delete_char_left
-        delete 'insert - 1 char'
-      end
-
-      def delete_char_right
-        delete 'insert'
-      end
-
-      def delete_word_right
-        delete 'insert', 'insert wordend'
-      end
-
-      def delete_word_left
-        delete 'insert wordstart', 'insert'
-      end
-
-      def delete_line
-        delete 'insert linestart', 'insert lineend + 1 char'
-      end
-
-      def delete_to_eol
-        delete 'insert', 'insert lineend'
-      end
-
-      def delete_to_eol_then_insert
-        delete_to_eol
-        start_insert_mode
-      end
-
       def join_lines
-        start_of_next_line = search(/\S/, 'insert lineend')
+        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/
-        raise exception
-      end
-
-      def insert_string(string)
-        # puts "Insert %p in mode %p" % [string, keymap.mode]
-        insert :insert, string unless string.empty?
-      end
-
-      def ignore_string(string)
-        status.message "Ignore %p in mode %p" % [string, keymap.mode]
+        Kernel.raise exception
       end
 
       def replace_char
-        status_ask 'Replace with: ' do |string|
-          replace('insert', 'insert + 1 chars', string)
+        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
 
@@ -233,59 +240,12 @@ module VER
        )
       end
 
-      def insert_indented_newline_below
-        line = get('insert linestart', 'insert lineend')
-
-        indent = line.empty? ? "" : (line[/^\s+/] || '')
-        mark_set :insert, 'insert lineend'
-        insert :insert, "\n#{indent}"
-
-        start_insert_mode
-      end
-
-      def insert_indented_newline_above
-        y, x = index(:insert).split('.').map(&:to_i)
-
-        if y > 1
-          go_line_up
-          insert_indented_newline_below
-        else
-          insert('insert linestart', "\n")
-          mark_set(:insert, 'insert - 1 line')
-        end
-      end
-
-      def insert_newline
-        insert :insert, "\n"
-      end
-
-      def insert_indented_newline
-        line1 = get('insert linestart', 'insert lineend')
-        indentation1 = line1[/^\s+/] || ''
-        insert :insert, "\n"
-
-        line2 = get('insert linestart', 'insert lineend')
-        indentation2 = line2[/^\s+/] || ''
-
-        replace(
-          'insert linestart',
-          "insert linestart + #{indentation2.size} chars",
-          indentation1
-        )
-      end
-
-      def insert_tab
-        insert :insert, "\t"
-      end
-
-      def eol_then_insert_mode
-        go_end_of_line
-        start_insert_mode
-      end
-
-      def sol_then_insert_mode
-        go_beginning_of_line
-        start_insert_mode
+      def clean_line(index)
+        index = index(index)
+        from, to = index.linestart, index.lineend
+        line = get(from, to)
+        bare = line.rstrip
+        replace(from, to, bare) if bare.empty?
       end
 
       def start_insert_mode
@@ -293,35 +253,10 @@ module VER
       end
 
       def start_control_mode
+        clean_line(:insert)
         self.mode = :control
       end
 
-      def copy_line
-        copy get('insert linestart', 'insert lineend + 1 chars')
-      end
-
-      def copy_right_word
-        copy get('insert', 'insert wordend')
-      end
-
-      def copy_left_word
-        copy get('insert', 'insert wordstart')
-      end
-
-      # FIXME: nasty hack or neccesary?
-      def paste
-        text = TkClipboard.get
-        paste_continous text
-
-      rescue RuntimeError => ex
-        if ex.message =~ /form "STRING" not defined/
-          array = TkClipboard.get type: Array
-          paste_tk_array array
-        else
-          Kernel.raise ex
-        end
-      end
-
       def undo
         edit_undo
         touch!
@@ -335,6 +270,52 @@ module VER
       rescue RuntimeError => ex
         status.value = ex.message
       end
+
+      private
+
+      def wrap_lines_of(text, wrap = 80)
+        Kernel.raise ArgumentError, "+wrap+ must be > 1" unless wrap > 1
+        wrap -= 1
+
+        indent = text[/^\s+/] || ''
+        indent_size = indent.size
+        lines = [indent.dup]
+
+        text.scan(/\S+/) do |chunk|
+          last = lines.last
+          last_size = last.size
+          chunk_size = chunk.size
+
+          if last_size + chunk_size > wrap
+            lines << indent + chunk
+          elsif last_size == indent_size
+            last << chunk
+          elsif chunk =~ /\.$/
+            last << ' ' << chunk
+            lines << indent.dup
+          else
+            last << ' ' << chunk
+          end
+        end
+
+        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