ver 2010.02 → 2010.08

data/lib/ver/methods/clipboard.rb

@@ -13,74 +13,221 @@ module VER
         copy(text, text.get(*movement))
       end
 
-      # 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
-        }
+      def responding_to?(method)
+        lambda{|object| object.respond_to?(method) }
+      end
 
-        paste_continous(text, content.to_s) if content
+      def paste_after(buffer, count = buffer.prefix_count)
+        buffer.with_register do |register|
+          case content = register.value
+          when responding_to?(:to_str)
+            paste_string_after(buffer, count, content.to_str)
+          when responding_to?(:to_ary)
+            paste_array_after(buffer, count, content.to_ary)
+          else
+            buffer.warn "Don't know how to paste: %p" % [content]
+          end
+        end
       end
 
-      def paste_above(text)
-        text.mark_set(:insert, 'insert - 1 line lineend')
-        paste(text)
+      def paste_after_go_after(buffer, count = buffer.prefix_count)
+        buffer.with_register do |register|
+          case content = register.value
+          when responding_to?(:to_str)
+            paste_string_after_go_after(buffer, count, content.to_str)
+          when responding_to?(:to_ary)
+            paste_array_after(buffer, count, content.to_ary)
+          else
+            buffer.warn "Don't know how to paste: %p" % [content]
+          end
+        end
       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(content)
+      def paste_after_adjust(buffer, count = buffer.prefix_count)
+        buffer.with_register do |register|
+          case content = register.value
+          when responding_to?(:to_str)
+            indent = buffer.at_insert.get('linestart', 'lineend')[/^[ \t]*/]
+            string = content.to_str.gsub(/^\s*/, indent)
+            paste_string_after(buffer, count, string)
+          when responding_to?(:to_ary)
+            paste_array_after(buffer, count, content.to_ary)
+          else
+            buffer.warn "Don't know how to paste: %p" % [content]
+          end
+        end
+      end
+
+      # on "foo", it's simple char selection, insert at insert mark.
+      # on "foo\nb", it was a char selection, insert at insert mark.
+      # on "foo\nbar\n":
+      #   we assume it's linewise, insert newline at eol, then insert the string
+      #   starting at the new line.
+      def paste_string_after(buffer, count, string)
+        buffer.undo_record do |record|
+          if string =~ /\n\Z/ # ends with newline
+            string = "\n#{string}".chomp * count # # put newline in front
+            buffer.insert = buffer.at_insert.lineend
+            record.insert(:insert, string)
+            buffer.insert = buffer.at_insert.linestart
+          else
+            buffer.insert = buffer.at_insert + '1 displaychars'
+            record.insert(:insert, string * count)
+          end
+        end
+      end
+
+      def paste_string_after_go_after(buffer, count, string)
+        buffer.undo_record do |record|
+          if string =~ /\n\Z/ # ends with newline
+            string = "\n#{string}".chomp * count # # put newline in front
+            buffer.insert = buffer.at_insert.lineend
+            record.insert(:insert, string)
+          else
+            buffer.insert = buffer.at_insert + '1 displaychars'
+            record.insert(:insert, string * count)
+          end
+        end
+      end
+
+      # the vim and the ver, the vim and the ver,
+      # one's a genius, the other's insane.
+      #
+      # I have a faint idea how vim knows the difference, it involves the y_type
+      # of a register struct, but we won't go into that.
+      # It's enough to know that vim can only handle block pasting when it was
+      # yanked from vim, we shall behave the same.
+      def paste_array_after(buffer, count, array)
+        insert_line, insert_char = *buffer.index(:insert)
+
+        buffer.undo_record do |record|
+          array.each_with_index do |line, index|
+            record.insert("#{insert_line + index}.#{insert_char}", line)
+          end
+        end
+      end
+
+      def paste_before_go_after(buffer, count = buffer.prefix_count)
+        buffer.with_register do |register|
+          case content = register.value
+          when responding_to?(:to_str)
+            paste_string_before_go_after(buffer, count, content.to_str)
+          when responding_to?(:to_ary)
+            paste_array_before(buffer, count, content.to_ary)
+          else
+            buffer.warn "Don't know how to paste: %p" % [content]
+          end
         end
       end
 
-      def copy_string(content)
-        Tk::Clipboard.set(content, type: 'STRING')
+      def paste_before_adjust(buffer, count = buffer.prefix_count)
+        buffer.with_register do |register|
+          case content = register.value
+          when responding_to?(:to_str)
+            indent = buffer.at_insert.get('linestart', 'lineend')[/^[ \t]*/]
+            string = content.to_str.gsub(/^\s*/, indent)
+            paste_string_before(buffer, count, string)
+          when responding_to?(:to_ary)
+            paste_array_before(buffer, count, content.to_ary)
+          else
+            buffer.warn "Don't know how to paste: %p" % [content]
+          end
+        end
+      end
 
-        copy_message(content.count("\n") + 1, content.size)
+      def paste_before(buffer, count = buffer.prefix_count)
+        buffer.with_register do |register|
+          case content = register.value
+          when responding_to?(:to_str)
+            paste_string_before(buffer, count, content.to_str)
+          when responding_to?(:to_ary)
+            paste_array_before(buffer, count, content.to_ary)
+          else
+            buffer.warn "Don't know how to paste: %p" % [content]
+          end
+        end
       end
 
-      def copy_array(content)
-        marshal = [Marshal.dump(content)].pack('m')
-        Tk::Clipboard.set(marshal, type: 'ARRAY')
+      def paste_string_before(buffer, count, string)
+        buffer.undo_record do |record|
+          if string =~ /\n\Z/ # ends with newline
+            string = string.chomp # get rid of that
+            count.times do
+              # insert newline at sol, insert string just before that
+              buffer.insert = buffer.at_insert.linestart
+              record.insert(:insert, "\n")
+              record.insert(buffer.at_insert - '1 lines', string)
+              buffer.insert = (buffer.at_insert - '1 lines').linestart
+            end
+          else
+            buffer.insert = buffer.at_insert - '1 displaychars'
+            record.insert(:insert, string * count)
+          end
+        end
+      end
 
-        copy_message content.size, content.reduce(0){|s,v| s + v.size }
+      def paste_string_before_go_after(buffer, count, string)
+        buffer.undo_record do |record|
+          if string =~ /\n\Z/ # ends with newline
+            string = string.chomp # get rid of that
+            count.times do
+              # insert newline at sol, insert string just before that
+              buffer.insert = buffer.at_insert.linestart
+              record.insert(:insert, "\n")
+              record.insert(buffer.at_insert - '1 lines', string)
+              buffer.insert = (buffer.at_insert - '1 lines').linestart
+            end
+          else
+            buffer.insert = buffer.at_insert - '1 displaychars'
+            record.insert(:insert, string * count)
+          end
+        end
       end
 
-      def copy_fallback(content)
-        Tk::Clipboard.set(content)
+      def paste_array_before(buffer, count, array)
+      end
 
-        VER.message "Copied unkown entity of class %p" % [content.class]
+      def copy(text, content)
+        if content.respond_to?(:to_str)
+          VER::Clipboard.string = string = content.to_str
+          copy_message(text, string.count("\n") + 1, string.size)
+        elsif content.respond_to?(:to_ary)
+          VER::Clipboard.marshal = array = content.to_ary
+          copy_message(text, array.size, array.reduce(0){|s,v| s + v.size })
+        else
+          VER::Clipboard.dwim = content
+          text.message "Copied unkown entity of class %p" % [content.class]
+        end
       end
 
-      def copy_message(lines, chars)
+      def copy_message(text, lines, chars)
         lines_desc = lines == 1 ? 'line' : 'lines'
         chars_desc = chars == 1 ? 'character' : 'characters'
 
+        # FIXME: messages should be:
+        # block of N lines yanked
+        # N lines yanked
+        # no message for a couple of chars
+
         msg = "copied %d %s of %d %s" % [lines, lines_desc, chars, chars_desc]
-        VER.message(msg)
+        text.message(msg)
       end
 
-      def paste_continous(text, content)
+      def paste_continous(buffer, content)
         if content =~ /\A([^\n]*)\n\Z/
-          text.mark_set :insert, 'insert lineend'
-          text.insert :insert, "\n#{$1}"
+          buffer.mark_set :insert, 'insert lineend'
+          buffer.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) }
+          buffer.mark_set :insert, 'insert lineend'
+          buffer.insert :insert, "\n"
+          content.each_line{|line| buffer.insert(:insert, line) }
         else
-          text.insert :insert, content
+          buffer.insert :insert, content
         end
       end
 
-      def paste_array(text, marshal_array)
-        array = Marshal.load(marshal_array.unpack('m').first)
-        insert_y, insert_x = text.index(:insert).split
+      def paste_array(text, array)
+        insert_y, insert_x = *text.index(:insert)
 
         Undo.record text do |record|
           array.each_with_index do |line, index|
@@ -88,16 +235,6 @@ module VER
           end
         end
       end
-
-      def clipboard_get(text, type = 'STRING')
-        Tk::Clipboard.get(text, type)
-      rescue RuntimeError => ex
-        if ex.message =~ /form "#{type}" not defined/
-          yield if block_given?
-        else
-          VER.error(ex)
-        end
-      end
     end
   end
 end

data/lib/ver/methods/completion.rb

@@ -38,8 +38,8 @@ module VER
       def aspell(text)
         text.store(self, :last_used, :aspell)
 
-        pos = text.index('insert - 1 chars')
-        from, to = pos.wordstart, pos.wordend
+        from = text.index('insert - 1 chars wordstart')
+        to   = text.index('insert - 1 chars wordend')
         word = text.get(from, to)
 
         complete text do
@@ -85,7 +85,7 @@ module VER
       def word(text)
         text.store(self, :last_used, :word)
 
-        y, x = text.index('insert').split
+        y, x = *text.index('insert')
         x = (x - 1).abs
         from, to = text.index("#{y}.#{x} wordstart"), text.index("#{y}.#{x} wordend")
 
@@ -140,7 +140,7 @@ module VER
 
       # TODO: use filename_under_cursor, that should be much more accurate.
       def file_completions(text, from, to)
-        y = text.index(from).y
+        lineno = text.index(from).line
         line = text.get(from, to)
 
         return [] unless match = line.match(/(?<pre>.*?)(?<path>\/[^\s"'{}()\[\]]*)(?<post>.*?)/)
@@ -156,7 +156,7 @@ module VER
           item.sub(path, '/')
         end
 
-        return "#{y}.#{to - 1}", "#{y}.#{to}", list
+        return "#{lineno}.#{to - 1}", "#{lineno}.#{to}", list
       end
 
       def word_completions(text, from, to)

data/lib/ver/methods/control.rb

@@ -11,6 +11,10 @@ module VER
         # clean_line(text, :insert)
       end
 
+      def temporary(buffer, action)
+        action.to_method(buffer).call
+      end
+
       def insert_at(text, motion, *count)
         Move.send(motion, text, *count)
         text.minor_mode(:control, :insert)
@@ -28,9 +32,13 @@ module VER
         Open.open_file_under_cursor(text)
       end
 
-      def source_buffer(text)
-        VER.message("Source #{text.filename}")
-        load(text.filename.to_s)
+      def source_buffer(buffer)
+        if filename = buffer.filename
+          buffer.message("Source #{filename}")
+          load(filename.to_s)
+        else
+          buffer.warn("#{buffer.uri} is no file")
+        end
       end
 
       def cursor_vertical_top(text)
@@ -47,8 +55,8 @@ module VER
         Move.start_of_line(text)
       end
 
-      def cursor_vertical_center(text)
-        insert = text.count('1.0', 'insert', :displaylines)
+      def cursor_vertical_center(text, index = :insert)
+        insert = text.count('1.0', index, :displaylines)
         last   = text.count('1.0', 'end', :displaylines)
         shown  = text.count('@0,0', "@0,#{text.winfo_height}", :displaylines)
 
@@ -77,6 +85,13 @@ module VER
         start_of_line(text)
       end
 
+      def cursor_horizontal_center(buffer)
+        x, y, width, height = *buffer.bbox('insert')
+        line_middle = y + (height / 2) # gives less room for error?
+        buffer_middle = buffer.winfo_width / 2
+        set("@#{buffer_middle},#{y}")
+      end
+
       def chdir(text)
         text.ask 'Change to: ' do |path, action|
           case action
@@ -85,7 +100,7 @@ module VER
 
             begin
               Dir.chdir(path)
-              VER.message 'Changed working directory to %s' % [path]
+              text.message 'Changed working directory to %s' % [path]
               :abort
             rescue Errno::ENOENT => ex
               VER.warn ex
@@ -104,39 +119,6 @@ module VER
         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.
       # - $f: The current buffer's filename
       # - $d: The current buffer's directory
@@ -282,7 +264,7 @@ module VER
           when :attempt
             begin
               system(command)
-              VER.message("Exit code: #{$?}")
+              text.message("Exit code: #{$?}")
               :abort
             rescue => ex
               VER.warn(ex)
@@ -291,19 +273,6 @@ module VER
         end
       end
 
-      def tags_at(index = :insert)
-        index = index(index)
-        tags = tag_names(index)
-        VER.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(text, regexp, with)
         total = 0
@@ -319,7 +288,7 @@ module VER
           end
         end
 
-        VER.message "Performed gsub on #{total} lines"
+        text.message "Performed gsub on #{total} lines"
       end
 
       # Substitute on current line
@@ -358,9 +327,10 @@ module VER
       end
 
       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] )
+        code = text.get('insert linestart', 'insert lineend')
+        file = (text.filename || text.uri).to_s
+        stdout_capture_evaluate(code, file, binding) do |res, out|
+          text.at_insert.lineend.insert("\n%s%p" % [out, res])
         end
       end
 
@@ -382,19 +352,29 @@ module VER
         end
       end
 
-      def eval_buffer
-        result = eval(value, TOPLEVEL_BINDING)
-      rescue Exception => exception
-        VER.error(exception)
+      # for some odd reason, vim likes to have arbitrary commands that reduce
+      # the argument by one if it's greater 1...
+      def join_forward(buffer, count = buffer.prefix_count)
+        count = count > 1 ? (count - 1) : count
+        buffer.undo_record do |record|
+          count.times do
+            buffer.insert = buffer.at_insert.lineend
+            record.replace('insert', 'insert + 1 chars', ' ')
+          end
+        end
       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*/, ' '))
+      def join_forward_nospace(buffer, count = buffer.prefix_count)
+        count = count > 1 ? (count - 1) : count
+        buffer.undo_record do |record|
+          count.times do
+            buffer.insert = buffer.at_insert.lineend
+            record.replace('insert', 'insert + 1 chars', '')
+          end
+        end
       end
 
-      def join_line_backward(text)
+      def join_backward(text)
         from, to = 'insert - 1 lines linestart', 'insert lineend'
         lines = text.get(from, to)
         text.replace(from, to, lines.gsub(/\s*\n\s*/, ' '))
@@ -454,6 +434,7 @@ module VER
           end
         end
 
+        lines.pop if lines.last == indent
         lines
       end
     end