ver 2010.02 → 2010.08

data/lib/ver/methods/delete.rb

@@ -1,126 +1,9 @@
 module VER
-  module Methods
-    module Delete
-      module_function
-
-      def change_motion(text, motion, count = text.prefix_count)
-        delete_motion(text, motion, count)
-        text.minor_mode(:control, :insert)
-      end
-
-      # Given a +motion+, this method will execute a virtual movement with the
-      # +count+ argument and [delete] the corresponding indices.
-      #
-      # @param [Symbol String] motion name of a method acceptable for [virtual_movement]
-      # @param [#to_i] count
-      #
-      # @see delete
-      # @see VER::Move::virtual_movement
-      def delete_motion(text, motion, count = text.prefix_count)
-        movement = Move.virtual(text, motion, count)
-        delete(text, *movement)
-      end
-
-      # Given a +motion+, this method will execute a virtual movement with the
-      # +count+ argument and [kill] the corresponding indices.
-      #
-      # @param [Symbol String] motion name of a method acceptable for [virtual_movement]
-      # @param [#to_i] count
-      #
-      # @see kill
-      # @see VER::Move#virtual_movement
-      def kill_motion(text, motion, count = text.prefix_count)
-        movement = Move.virtual(text, motion, count)
-        kill(text, *movement)
-      end
-
-      # [word_right_end] goes to the last character, that is, the insert mark is
-      # between the second to last and last character.
-      # This means that the range to delete is off by one, account for it here.
-      def change_word_right_end(text, count = text.prefix_count)
-        index = Move.index_at_word_right_end(text, count)
-        delete(text, :insert, index + 1)
-        text.minor_mode(:control, :insert)
-      end
-
-      # Delete current line and upto +count+ subsequent lines.
-      #
-      # @param [#to_i] count Number of lines to delete
-      #
-      # @see delete
-      # @see kill_line
-      def delete_line(text, count = text.prefix_count)
-        count = count.abs - 1
-        from = text.index('insert linestart')
-        to = "#{from.y + count}.#{from.x} lineend + 1 char"
-        delete(text, from, text.index(to))
-      end
-
-      # Copy current line and upto +count+ subsequent lines and delete them.
-      #
-      # @param [#to_i] count Number of lines to kill
-      #
-      # @see kill
-      # @see delete_line
-      def kill_line(text, count = text.prefix_count)
-        count = count.abs - 1
-        from = text.index('insert linestart')
-        to = "#{from.y + count.to_i}.#{from.x} lineend + 1 char"
-        kill(text, from, text.index(to))
-      end
-
-      # Wrapper for [kill_line] that starts insert mode after killing +count+
-      # lines. It also doesn't delete the newline.
-      #
-      # @param [#to_i] count Number of lines to kill
-      #
-      # @see kill_line
-      def change_line(text, count = text.prefix_count)
-        count = count.abs - 1
-        from = text.index('insert linestart')
-        to = "#{from.y + count}.#{from.x} lineend"
-        kill(text, from, text.index(to))
-        text.minor_mode(:control, :insert)
-      end
-
-      # Tag and delete all trailing whitespace in the current buffer.
-      def delete_trailing_whitespace(text)
-        ranges = text.tag_ranges('invalid.trailing-whitespace').flatten
-        text.execute(:delete, *ranges) unless ranges.empty?
-      end
-
-      # Delete text between +indices+
-      def delete(text, *indices)
-        indices_size = indices.size
-        return if indices_size == 0
-
-        Undo.record text do |record|
-          if indices_size == 1
-            record.delete(indices.first)
-          else
-            indices.each_slice(2) do |from, to|
-              next if from == to
-              record.delete(from, to)
-            end
-          end
-        end
-      end
-
-      # Copy text between +indices+ and delete it.
-      #
-      # @param [Array<Text::Index, String, Symbol>] indices
-      #   one or more indices within the buffer, must be an even number of
-      #   indices if more than one.
-      def kill(text, *indices)
-        if indices.size > 2
-          deleted = indices.each_slice(2).map{|left, right|
-            text.get(left, right) }
-        else
-          deleted = text.get(*indices)
-        end
-
-        Clipboard.copy(text, deleted)
-        delete(text, *indices)
+  class Buffer
+    # Tag and delete all trailing whitespace in the {Buffer}.
+    def delete_trailing_whitespace
+      @invalid_trailing_whitespace.each_range do |range|
+        range.delete
       end
     end
   end

data/lib/ver/methods/help.rb

@@ -7,8 +7,8 @@ module VER
         VER::Help::HelpForHelp.new(self)
       end
 
-      def describe_key
-        VER::Help::DescribeKey.new(self)
+      def describe_key(buffer)
+        VER::Help::DescribeKey.new(buffer)
       end
     end
   end

data/lib/ver/methods/insert.rb

@@ -1,8 +1,16 @@
 module VER
+  Buffer.def_delegator(:@at_insert, :tab, :insert_tab)
+  Buffer.def_delegator(:@at_insert, :newline, :insert_newline)
+  Buffer.def_delegator(:@at_insert, :selection, :insert_selection)
+
   module Methods
     module Insert
       module_function
 
+      def tab(buffer)     buffer.insert_tab end
+      def newline(buffer) buffer.insert_newline end
+      def selection(buffer) buffer.insert_selection end
+
       def file_contents(filename)
         content = read_file(filename)
         insert :insert, content
@@ -10,34 +18,16 @@ module VER
         VER.error(ex)
       end
 
-      def selection(text)
-        text.insert(:insert, Tk::Selection.get)
-      end
-
-      def tab(text)
-        text.insert(:insert, "\t")
-      end
-
-      def newline(text)
-        if text.options.autoindent
-          indented_newline(text)
-        else
-          text.insert(:insert, "\n")
-        end
-      end
-
       def newline_below(text)
         Undo.record text do |record|
           if text.options.autoindent
-            # text.mark_set('insert', 'insert lineend')
-            # Indent.insert_newline(text, record)
             line = text.get('insert linestart', 'insert lineend')
 
             indent = line[/^\s*/]
-            text.mark_set(:insert, 'insert lineend')
+            text.insert = 'insert lineend'
             record.insert(:insert, "\n#{indent}")
           else
-            text.mark_set(:insert, 'insert lineend')
+            text.insert = 'insert lineend'
             record.insert(:insert, "\n")
           end
 
@@ -88,20 +78,42 @@ module VER
         common_string(text, text.event.unicode)
       end
 
-      def replace_string(text, replacement = text.event.unicode)
-        Undo.record text do |record|
-          record.delete(:insert, 'insert + 1 chars')
-          common_string(text, replacement, record)
+      def enter_replace(buffer, old_mode, new_mode)
+        # store count argument for later repetition
+        buffer.store(self, :replace_count, buffer.prefix_count(0))
+        buffer.store(self, :replace_chars, '')
+      end
+
+      def leave_replace(buffer, old_mode, new_mode)
+        # repeat replacment
+        count = buffer.store(self, :replace_count)
+        chars = buffer.store(self, :replace_chars).dup
+
+        buffer.undo_record do |record|
+          count.times do
+            common_string(buffer, chars, record)
+          end
         end
       end
 
-      def replace_char(text, replacement = text.event.unicode)
-        Undo.record text do |record|
+      def replace_string(buffer, replacement = buffer.event.unicode)
+        buffer.undo_record do |record|
           record.delete(:insert, 'insert + 1 chars')
-          common_string(text, replacement, record)
+          buffer.store(self, :replace_chars) << replacement
+          common_string(buffer, replacement, record)
         end
-        text.mark_set(:insert, 'insert - 1 chars')
-        text.minor_mode(:replace_char, :control)
+      end
+
+      def replace_char(buffer, replacement = buffer.event.unicode, count = buffer.prefix_count)
+        buffer.undo_record do |record|
+          count.times do
+            record.delete(:insert, 'insert + 1 chars')
+            common_string(buffer, replacement, record)
+          end
+        end
+        buffer.skip_prefix_count_once = replacement =~ /^\d+$/
+        buffer.mark_set(:insert, 'insert - 1 chars')
+        buffer.minor_mode(:replace_char, :control)
       end
 
       def common_string(text, string, record = text)
@@ -118,6 +130,66 @@ module VER
         # puts "Insert %p in mode %p" % [string, keymap.mode]
         record.insert(:insert, string)
       end
+
+      # Insert characters literally, or enter decimal byte value (3 digits).
+      # This means we try to get up to 3 digits, but possibly don't get any.
+      #
+      # This code is less than elegant, but so is the behaviour we try to
+      # achieve.
+      #
+      # (none)		decimal		   3		255
+      # o or O		octal		   3		377	 (255)
+      # x or X		hexadecimal	   2		ff	 (255)
+      # u		hexadecimal	   4		ffff	 (65535)
+      # U		hexadecimal	   8		7fffffff (2147483647)
+      def literal(buffer)
+        reader = ->(string = ''){
+          buffer.major_mode.read(1) do |event|
+            if unicode = event.unicode
+              string += unicode # copy
+              buffer.message string.inspect
+
+              case result = literal_handle(buffer, string)
+              when nil
+                reader.call(string)
+              when String
+                literal_insert(buffer, result)
+              end
+            else
+              return # Unverrichteter Dinge
+            end
+          end
+        }
+
+        reader.call
+      end
+
+      # returning nil means read next char
+      # returning a String means you're done and want the result inserted.
+      # returning anything else means you're giving up.
+      def literal_handle(buffer, string)
+        case string
+        when /^\d{,3}$/
+          return if string.size < 3
+          [string.to_i].pack('U')
+        when /^o([0-7]{,3})$/i
+          return if $1.size < 3
+          [Integer("0#$1")].pack('U')
+        when /^x(\h{,2})$/i
+          return if $1.size < 2
+          [Integer("0x#$1")].pack('U')
+        when /^u(\h{,4})$/
+          return if $1.size < 4
+          [Integer("0x#$1")].pack('U')
+        when /^U(\h{,8})$/
+          return if $1.size < 8
+          [Integer("0x#$1")].pack('U')
+        end
+      end
+
+      def literal_insert(buffer, char)
+        buffer.at_insert.insert(char)
+      end
     end
   end
 end

data/lib/ver/methods/layout.rb

@@ -3,119 +3,117 @@ module VER
     module Layout
       module_function
 
-      def change(text, action, *count)
-        action.call(text, *count)
+      def change(buffer, action, *count)
+        action.call(buffer, *count)
       end
 
-      def peer(text)
-        text.layout.create_buffer(peer: text) do |buffer|
+      def peer(buffer)
+        buffer.layout.create_buffer(peer: buffer) do |buffer|
           yield(buffer) if block_given?
         end
       end
 
-      def focus(text, index = 0)
-        return unless found = VER.buffers.values[index - 1]
-        text.layout.push_top(found)
+      def focus(buffer, index = 0)
+        return unless found = VER.buffers.to_a[index - 1]
+        buffer.layout.push_top(found)
         found.focus
       end
 
-      def find_or_create(text, file, &block)
-        VER::Buffer.find_or_create(file, &block)
+      # Close the given +buffer+
+      def close(buffer)
+        buffer.close
       end
 
-      def create(text)
-        VER::Buffer.create
+      # Hide the given +buffer+
+      def hide(buffer)
+        buffer.layout.hide_buffer(buffer)
       end
 
-      def close(text)
-        text.buffer.close
+      def focus_next(buffer)
+        buffer.layout.focus_next(buffer)
       end
 
-      def focus_next(text)
-        text.layout.focus_next(text.buffer)
+      def focus_prev(buffer)
+        buffer.layout.focus_prev(buffer)
       end
 
-      def focus_prev(text)
-        text.layout.focus_prev(text.buffer)
+      def push_up(buffer)
+        buffer.layout.push_up(buffer)
       end
 
-      def push_up(text)
-        text.layout.push_up(text.buffer)
+      def push_down(buffer)
+        buffer.layout.push_down(buffer)
       end
 
-      def push_down(text)
-        text.layout.push_down(text.buffer)
+      def push_top(buffer)
+        buffer.layout.push_top(buffer)
       end
 
-      def push_top(text)
-        text.layout.push_top(text.buffer)
+      def push_bottom(buffer)
+        buffer.layout.push_bottom(buffer)
       end
 
-      def push_bottom(text)
-        text.layout.push_bottom(text.buffer)
+      def one(buffer)
+        buffer.layout.options.merge! master: 1, slaves: 0
+        push_top(buffer)
       end
 
-      def one(text)
-        text.layout.options.merge! master: 1, slaves: 0
-        push_top(text)
+      def two(buffer)
+        buffer.layout.options.merge! master: 1, slaves: 1
+        push_top(buffer)
       end
 
-      def two(text)
-        text.layout.options.merge! master: 1, slaves: 1
-        push_top(text)
-      end
-
-      def slave_inc(text)
-        slaves = text.layout.options[:slaves]
-        unless slaves >= text.layout.stack.size
-          text.layout.options[:slaves] += 1
-          text.layout.apply
+      def slave_inc(buffer)
+        slaves = buffer.layout.options[:slaves]
+        unless slaves >= buffer.layout.frames.size
+          buffer.layout.options[:slaves] += 1
+          buffer.layout.apply
         end
       end
 
-      def slave_dec(text)
-        slaves = text.layout.options[:slaves]
-        text.layout.options[:slaves] -= 1 if slaves > 0
-        text.layout.apply
+      def slave_dec(buffer)
+        slaves = buffer.layout.options[:slaves]
+        buffer.layout.options[:slaves] -= 1 if slaves > 0
+        buffer.layout.apply
       end
 
-      def master_inc(text)
-        text.layout.options[:master] += 1
-        text.layout.apply
+      def master_inc(buffer)
+        buffer.layout.options[:master] += 1
+        buffer.layout.apply
       end
 
-      def master_dec(text)
-        master = text.layout.options[:master]
-        text.layout.options[:master] -= 1 if master > 0
-        text.layout.apply
+      def master_dec(buffer)
+        master = buffer.layout.options[:master]
+        buffer.layout.options[:master] -= 1 if master > 0
+        buffer.layout.apply
       end
 
       # Shrink the master pane by 10%
-      def master_shrink(text)
-        center = text.layout.options[:center]
-        text.layout.options[:center] -= 0.1 if center > 0.1
-        text.layout.apply
+      def master_shrink(buffer)
+        center = buffer.layout.options[:center]
+        buffer.layout.options[:center] -= 0.1 if center > 0.1
+        buffer.layout.apply
       end
 
       # Grow the master pane by 10%
-      def master_grow(text)
-        center = text.layout.options[:center]
-        text.layout.options[:center] += 0.1 if center < 0.9
-        text.layout.apply
+      def master_grow(buffer)
+        center = buffer.layout.options[:center]
+        buffer.layout.options[:center] += 0.1 if center < 0.9
+        buffer.layout.apply
       end
 
       # Center the split between masters and slaves
-      def master_equal(text)
-        text.layout.options[:center] = 0.5
-        text.layout.apply
+      def master_equal(buffer)
+        buffer.layout.options[:center] = 0.5
+        buffer.layout.apply
       end
 
-      def cycle_next(text)
-        text.layout.cycle_next(text.buffer)
+      def cycle_next(buffer)
+        buffer.layout.cycle_next(buffer)
       end
 
-      def cycle_prev(text)
-        text.layout.cycle_prev(text.buffer)
+      def cycle_prev(buffer)
+        buffer.layout.cycle_prev(buffer)
       end
     end
   end