ver 2010.02 → 2010.08

data/lib/ver/text/position.rb

@@ -0,0 +1,240 @@
+module VER
+  class Text
+    # A Position is any kind of index in a Tk::Text widget, it may be a {Mark},
+    # {Insert}, {End}, etc.
+    # The Position relies on a buffer property being present, which should be
+    # responding to the methods of {Tk::Text} that take at least one index.
+    module Position
+      include Comparable
+
+      def bbox
+        buffer.bbox(self)
+      end
+
+      # Compare relationship with +other+ index using +op+.
+      #
+      # @param [#to_tcl] op
+      #   one of <, <=, ==, >=, >, or !=
+      # @param [#to_tcl] other
+      #   another index to compare against
+      # @return [Boolean] whether relationship is satisfied.
+      def compare(op, other)
+        buffer.compare(self, op, other)
+      end
+
+      # Used for {Comparable}.
+      # Returns 1 if +other+ is after this position.
+      # Returns -1 if +other is before this position.
+      # Returns 0 if they are equal.
+      #
+      # @param [#to_tcl] other
+      #   another index to compare against
+      # @return [Fixnum]
+      def <=>(other)
+        return  1 if compare('>',  other)
+        return -1 if compare('<',  other)
+        return  0 if compare('==', other)
+      end
+
+      # Kill contents of the line at position, switch from control to
+      # insert mode.
+      # Always leaves an empty line
+      def change_line(count = buffer.prefix_count)
+        kill_line
+        buffer.minor_mode(:control, :insert)
+      end
+
+      def copy_line(count = buffer.prefix_count)
+        from = "#{self} linestart"
+
+        to =
+          case count
+          when 0, 1; "#{self} lineend + 1 chars"
+          else     ; "#{self} + #{count - 1} lines lineend + 1 chars"
+          end
+
+        buffer.range(buffer.index(from), buffer.index(to)).copy
+      end
+
+      # Delete this and any other given +indices+ from the buffer.
+      def delete(*indices)
+        buffer.delete(self, *indices)
+      end
+
+      def delete_line(count = buffer.prefix_count)
+        buffer.delete("#{self} linestart", "#{self} + #{count - 1} lines lineend + 1 chars")
+      end
+
+      def dlineinfo
+        buffer.dlineinfo(self)
+      end
+
+      def delta(other)
+        line_diff = other.line - line
+
+        if line_diff == 0
+          (other.char - char).abs
+        else
+          line_diff.abs
+        end
+      end
+
+      def dump(*options)
+        buffer.dump(*options, self)
+      end
+
+      def get(from = nil, to = nil)
+        if from && to
+          buffer.get("#{self} #{from}", "#{self} #{to}")
+        elsif from
+          buffer.get("#{self} #{from}")
+        else
+          buffer.get(self)
+        end
+      end
+
+      def increase_number(count = buffer.prefix_count)
+        return unless result = formatted_number(count)
+        head, tail, number = *result
+        buffer.replace(
+          "#{self} - #{head.size} chars",
+          "#{self} + #{tail.size} chars",
+          number
+        )
+      end
+
+      def decrease_number(count = buffer.prefix_count)
+        return unless result = formatted_number(-count)
+        head, tail, number = *result
+        buffer.replace(
+          "#{self} - #{head.size} chars",
+          "#{self} + #{tail.size} chars",
+          number
+        )
+      end
+
+      def formatted_hex(number)
+        if number > 0
+          '%#x' % number
+        elsif number == 0
+          '0x0'
+        else
+          '-0x%x' % number.abs
+        end
+      end
+
+      def formatted_binary(number)
+        if number > 0
+          '%#b' % number
+        elsif number == 0
+          '0b0'
+        else
+          '-0b%b' % number.abs
+        end
+      end
+
+      def formatted_exponential(number, precicion)
+        "%-.#{precicion}e" % number
+      end
+
+      def formatted_float(number, precicion)
+        "%-.#{precicion}f" % number
+      end
+
+      def formatted_octal(number)
+        if number > 0
+          '%#o' % number
+        elsif number == 0
+          '00'
+        else
+          '-0%o' % number.abs
+        end
+      end
+
+      def formatted_number(count)
+        head = buffer.get("#{self} linestart", self)[/\S*$/]
+        tail = buffer.get(self, "#{self} lineend")[/^\S*/]
+
+        number =
+          case chunk = head + tail
+          when /^[+-]?0x\h+$/
+            formatted_hex(Integer(chunk) + count)
+          when /^[+-]?0b[01]+$/
+            formatted_binary(Integer(chunk) + count)
+          when /^[+-]?(\d+\.\d+|\d+)e[+-]?\d+$/
+            precicion = $1[/\.(\d+)/, 1].to_s.size
+            formatted_exponential(Float(chunk) + count, precicion)
+          when /^[+-]?\d+\.(\d+)/
+            formatted_float(Float(chunk) + count, $1.size)
+          when /^[+-]?([1-9]\d*|0)$/
+            "%-d" % [Integer(chunk) + count]
+          when /^[+-]?0\d+$/
+            formatted_octal(Integer(chunk) + count)
+          else
+            return
+          end
+
+        return head, tail, number
+      end
+
+      def inspect
+        index.inspect
+      end
+
+      def insert(*args)
+        buffer.insert(self, *args)
+      end
+
+      def kill_line(count = buffer.prefix_count)
+        copy_line(count)
+        delete_line(count)
+      end
+
+      def see
+        buffer.see(self)
+      end
+
+      def linestart
+        buffer.index("#{self} linestart")
+      end
+
+      def lineend
+        buffer.index("#{self} lineend")
+      end
+
+      def tags
+        buffer.tags(self)
+      end
+
+      def tag_names
+        buffer.tag_names(self)
+      end
+
+      def to_a
+        index.to_a
+      end
+
+      def toggle_case!(count = buffer.prefix_count)
+        buffer.range(self, self + "#{count} displaychars").toggle_case!
+      end
+
+      def +(arg)
+        case arg
+        when Integer
+          buffer.index("#{self} + #{arg} chars")
+        else
+          buffer.index("#{self} + #{arg}")
+        end
+      end
+
+      def -(arg)
+        case arg
+        when Integer
+          buffer.index("#{self} - #{arg} chars")
+        else
+          buffer.index("#{self} - #{arg}")
+        end
+      end
+    end
+  end
+end

data/lib/ver/text/range.rb

@@ -0,0 +1,74 @@
+module VER
+  class Text
+    class Range < Struct.new(:buffer, :first, :last)
+      def change
+        kill
+        buffer.minor_mode(:control, :insert)
+      end
+
+      def copy
+        buffer.with_register{|reg| reg.value = get }
+      end
+
+      def count(*options)
+        buffer.count(*self, *options)
+      end
+
+      def delete(*indices)
+        buffer.delete(*self, *indices)
+      end
+
+      def dump(*options)
+        buffer.dump(*options, *self)
+      end
+
+      def encode_rot13!(record = buffer)
+        record.replace(*self, get.tr('A-Ma-mN-Zn-z', 'N-Zn-zA-Ma-m'))
+      end
+
+      def first=(index)
+        self[:first] = index.is_a?(Index) ? index : buffer.index(index)
+      end
+
+      def get
+        buffer.get(*self)
+      end
+
+      def inspect
+        "#<VER::Text::Range %s on %p>" % ["(#{first}..#{last})", buffer]
+      end
+
+      def kill
+        copy
+        delete
+      end
+
+      def last=(index)
+        self[:last] = index.is_a?(Index) ? index : buffer.index(index)
+      end
+
+      def lower_case!(record = buffer)
+        record.replace(*self, get.downcase)
+      end
+      alias downcase! lower_case!
+
+      def replace(*args)
+        buffer.replace(first, last, *args)
+      end
+
+      def to_a
+        [first, last]
+      end
+
+      def toggle_case!(record = buffer)
+        record.replace(*self, get.tr('a-zA-Z', 'A-Za-z'))
+      end
+      # alias needed?
+
+      def upper_case!(record = buffer)
+        record.replace(*self, get.upcase)
+      end
+      alias upcase! upper_case!
+    end
+  end
+end

data/lib/ver/text/selection.rb

@@ -0,0 +1,402 @@
+module VER
+  class Text
+    class Selection < Tag
+      autoload :Char, 'ver/text/selection/char'
+      autoload :Line, 'ver/text/selection/line'
+      autoload :Block, 'ver/text/selection/block'
+
+      def self.enter(buffer, old_mode, new_mode)
+        buffer.at_sel.enter(old_mode, new_mode)
+      end
+
+      def self.leave(buffer, old_mode, new_mode)
+        buffer.at_sel.leave(old_mode, new_mode)
+      end
+
+      attr_accessor :mode
+      attr_reader :anchor
+
+      def initialize(buffer, refresh = true, mode = :select_char)
+        super(buffer, :sel)
+        @mode = mode
+        @anchor = buffer.mark(:sel_anchor)
+        refresh() if @refresh = refresh
+      end
+
+      # This is called when the minor mode changes.
+      def enter(old_mode, new_mode)
+        reset unless old_mode.name =~ /^select_/
+        enter_mode(new_mode.name)
+      end
+
+      def enter_mode(mode_name)
+        buffer.at_sel = sel =
+          case mode_name
+          when /^select_char/;  Char.new(buffer)
+          when /^select_line/;  Line.new(buffer)
+          when /^select_block/; Block.new(buffer)
+          else; raise ArgumentError, "Unknown mode: %p"
+          end
+
+        sel.mode = mode_name.to_sym
+      end
+
+      # This is called when the minor mode changes.
+      def leave(old_mode, new_mode)
+        return if new_mode.name =~ /^select/
+        @refresh = false
+        clear
+        anchor.unset
+      end
+
+      def reset
+        clear
+        anchor.index = :insert
+      end
+
+      def clear
+        tag_remove('1.0', 'end')
+      end
+
+      # Enter control mode, indirectly invokes {leave}.
+      def finish
+        buffer.minor_mode(mode, :control)
+      end
+
+      # Using delete, since the sel tag cannot be deleted anyway.
+      def delete
+        buffer.undo_record do |record|
+          ranges = []
+          each_range{|range| ranges.push(*range) }
+          record.delete(*ranges)
+        end
+
+        finish
+      end
+
+      def copy
+        super
+        buffer.insert = "#{self}.first"
+        clear
+        finish
+      end
+
+      def kill
+        super
+        clear
+        finish
+      end
+
+      def change
+        kill
+        buffer.minor_mode(:control, :insert)
+      end
+
+      def wrap
+        super
+        finish
+      end
+
+      def comment
+        refresh
+        super
+        refresh
+      end
+
+      def uncomment
+        refresh
+        super
+        refresh
+      end
+
+      def evaluate!
+        super
+        clear
+        finish
+      end
+
+      def toggle_case!
+        super
+        clear
+        finish
+      end
+
+      def lower_case!
+        super
+        clear
+        finish
+      end
+      alias downcase! lower_case!
+
+      def upper_case!
+        super
+        clear
+        finish
+      end
+      alias upcase! upper_case!
+
+      def encode_rot13!
+        super
+        clear
+        finish
+      end
+
+      def indent
+        anchor = self.anchor.index
+        insert = buffer.at_insert.index
+        super
+        # self.anchor.index = anchor
+        # buffer.insert = insert + '1 chars'
+        refresh
+      end
+
+      def unindent
+        anchor = self.anchor.index
+        insert = buffer.at_insert.index
+        super
+        # self.anchor.index = anchor
+        # buffer.insert = insert + '1 chars'
+        refresh
+      end
+
+      def pipe!(*cmd)
+        super
+        clear
+        finish
+      end
+
+      # Replace every character in the selection with the character entered.
+      def replace_char(char = buffer.events.last.unicode)
+        replace_with_string(char, expand = true)
+        buffer.minor_mode(:select_replace_char, mode_name)
+      end
+
+      # Ask for a string that every chunk of the selection should be replaced with
+      def replace_string
+        buffer.ask 'Replace selection with: ', do |answer, action|
+          case action
+          when :attempt
+            if answer.size > 0
+              replace_with_string(answer, expand = false)
+              buffer.message "replaced #{answer.size} chars"
+              :abort
+            else
+              buffer.warn "replacement required"
+            end
+          end
+        end
+      end
+
+      def replace_with_clipboard
+        return unless string = VER::Clipboard.string
+        ranges = buffer.tag_ranges(:sel)
+        from, to = ranges.first.first, ranges.last.last
+        replace(from, to, string)
+        finish
+        buffer.mark_set :insert, from
+      end
+
+      def replace_with_string(string, expand)
+        insert = buffer.index(:insert)
+        anchor = self.anchor.index
+
+        buffer.undo_record do |record|
+          if expand
+            each_range do |range|
+              current = range.count(:displaychars)
+              record.replace(*range, string * current)
+            end
+          else
+            each_line do |y, fx, tx|
+              record.replace("#{y}.#{fx}", "#{y}.#{tx}", string)
+            end
+
+            offset = (anchor.char + string.size) - 1
+            buffer.insert = insert.linestart + "#{offset} chars"
+          end
+        end
+
+        self.anchor.index = anchor
+        refresh
+      end
+
+      # Press <Shift-F7> to work with the text as if it were one big string (multiple
+      # for Ruby code that uses the variable "str".  For example, entering
+      #
+      # str.upcase
+      #
+      # will convert the selected text to uppercase.
+      def string_operation
+        buffer.ask 'Ruby code: ', value: 'str.' do |code, action|
+          case action
+          when :attempt
+            begin
+              string_operation!(code)
+            rescue Exception => ex
+              VER.warn(ex)
+              buffer.warn(ex)
+            else
+              clear
+              finish
+              :abort
+            end
+          end
+        end
+      end
+
+      # Provide a restricted scope so people cannot interfere with undo or
+      # MiniBuffer.
+      def string_operation!(code)
+        replace(string_operation_eval(code, get))
+      end
+
+      def string_operation_eval(code, str)
+        eval(code).to_str
+      end
+
+      def array_operation
+        buffer.ask 'Ruby code: ', value: 'lines.' do |code, action|
+          case action
+          when :attempt
+            begin
+              array_operation!(code)
+            rescue Exception => ex
+              VER.error(ex)
+              buffer.warn(ex)
+            else
+              clear
+              finish
+              :abort
+            end
+          end
+        end
+      end
+
+      def array_operation!(code)
+        lines = []
+        first = last = nil
+
+        each do |from_line, from_char, to_line, to_char|
+          from_line.upto to_line do |lineno|
+            from, to = "#{lineno}.0", "#{lineno}.0 lineend"
+            first ||= from
+            last = to
+
+            line = buffer.get(from, to)
+            lines << line
+          end
+        end
+
+        buffer.undo_record do |record|
+          modified = array_operation_eval(code, lines)
+          record.replace(first, last, modified.join("\n"))
+        end
+      end
+
+      # Provide a restricted scope so people cannot interfere with undo or
+      # MiniBuffer.
+      def array_operation_eval(code, lines)
+        eval(code).to_a
+      end
+
+      # Press <F7> to iterate over each line of selected text.  You will be prompted
+      # for Ruby code which will act as the body of a Ruby block which uses the
+      # variable "line" and evaluates to a String.  For example:
+      #
+      #   line.strip.squeeze( ' ' )
+      #
+      # will strip off whitespace from the beginning and end of each line and then
+      # collapse all consecutive sequences of spaces into single spaces.
+      def line_operation
+        buffer.ask 'Ruby code: ', value: 'line.' do |code, action|
+          case action
+          when :attempt
+            begin
+              line_operation!(code)
+            rescue Exception => ex
+              VER.error(ex)
+              buffer.warn(ex)
+            else
+              clear
+              finish
+              :abort
+            end
+          end
+        end
+      end
+
+      def line_operation!(code)
+        buffer.undo_record do |record|
+          each do |from_line, from_char, to_line, to_char|
+            from_line.upto to_line do |lineno|
+              from, to = "#{lineno}.0", "#{lineno}.0 lineend"
+              line = buffer.get(from, to)
+              modified = line_operation_eval(code, line)
+              record.replace(from, to, modified)
+            end
+          end
+        end
+      end
+
+      # Provide a restricted scope so people cannot interfere with undo or
+      # MiniBuffer.
+      def line_operation_eval(code, line)
+        eval(code).to_str
+      end
+
+      def change_linestart
+        first_line, last_line = first.line, last.line
+        buffer.ask 'Insert text at linestart: ' do |text, action|
+          case action
+          when :attempt
+            buffer.undo_record do |record|
+              first_line.upto last_line do |line|
+                record.insert("#{line}.0", text)
+              end
+            end
+            :abort
+          end
+        end
+      end
+
+      def change_lineend
+        first_line, last_line = first.line, last.line
+        buffer.ask 'Insert text at linestart: ' do |text, action|
+          case action
+          when :attempt
+            buffer.undo_record do |record|
+              first_line.upto last_line do |line|
+                record.insert("#{line}.0 lineend", text)
+              end
+            end
+            :abort
+          end
+        end
+      end
+
+      def join(separator = ' ')
+        buffer.undo_record do |record|
+          first_line, last_line = first.line, last.line
+
+          first_line.upto(last_line - 1) do |line|
+            line = first_line
+
+            left  = buffer.get("#{line}.0", "#{line}.0 lineend").rstrip
+            right = buffer.get("#{line + 1}.0", "#{line + 1}.0 lineend").lstrip
+            left << separator
+
+            # first replace the right hand, which is the second line.
+            record.replace("#{line + 1}.0", "#{line + 1}.0 lineend", right, 'sel')
+            # put insert cursor at start of second line.
+            buffer.insert = "#{line + 1}.0"
+            # and finally join the two lines.
+            record.replace("#{line}.0", "#{line}.0 lineend + 1 chars", left, 'sel')
+          end
+        end
+
+        clear
+        finish
+      end
+    end # Selection
+  end # Text
+end # VER