ver 2010.02 → 2010.08

data/lib/ver/text/selection/block.rb

@@ -0,0 +1,69 @@
+module VER
+  class Text
+    class Selection
+      class Block < Selection
+        def each
+          return Enumerator.new(self, :each) unless block_given?
+
+          each_range do |range|
+            fy, fx, ty, tx = *range.first, *range.last
+            yield fy, fx, ty, tx
+          end
+        end
+
+        def mode_name
+          :select_block
+        end
+
+        def refresh
+          return unless @refresh
+          start  = anchor.index
+          insert = buffer.at_insert
+          clear
+
+          ly, lx, ry, rx =
+            if insert > start
+              [*insert, *start]
+            else
+              [*start, *insert]
+            end
+
+          from_y, to_y = [ly, ry].sort
+          from_x, to_x = [lx, rx].sort
+
+          ranges = []
+          from_y.upto to_y do |y|
+            ranges << "#{y}.#{from_x}" << "#{y}.#{to_x + 1}"
+          end
+
+          add(*ranges)
+        end
+
+        # Ask for string, then replace each line the selection spans with it.
+        def replace_string_eol
+          buffer.ask 'Replace selection with: ', do |answer, action|
+            case action
+            when :attempt
+              if answer.size > 0
+                replace_string_eol!(answer)
+                :abort
+              else
+                buffer.warn "replacement required"
+              end
+            end
+          end
+        end
+
+        def replace_string_eol!(string)
+          buffer.undo_record do |record|
+            each do |from_line, from_char, to_line, to_char|
+              from_line.upto to_line do |line|
+                buffer.replace("#{line}.#{from_char}", "#{line}.0 lineend", string)
+              end
+            end
+          end
+        end
+      end # Block
+    end # Selection
+  end # Text
+end # VER

data/lib/ver/text/selection/char.rb

@@ -0,0 +1,93 @@
+module VER
+  class Text
+    class Selection
+      class Char < Selection
+        def mode_name
+          :select_char
+        end
+
+        # yields the range
+        def each
+          return Enumerator.new(self, :each) unless block_given?
+
+          each_range do |range|
+            fy, fx, ty, tx = *range.first, *range.last
+
+            if fy == ty
+              yield fy, fx, ty, tx
+            elsif (ty - fy) == 1
+              efy, efx = *buffer.index("#{fy}.#{fx} lineend")
+              sty, stx = *buffer.index("#{ty}.#{tx} linestart")
+              yield fy, fx, efy, efx
+              yield sty, stx, ty, tx
+            else
+              efy, efx = *buffer.index("#{fy}.#{fx} lineend")
+              yield fy, fx, efy, efx
+
+              ((fy + 1)...ty).each do |y|
+                sy, sx = *buffer.index("#{y}.0 linestart")
+                ey, ex = *buffer.index("#{y}.0 lineend")
+                yield sy, sx, ey, ex
+              end
+
+              sty, stx = *buffer.index("#{ty}.#{tx} linestart")
+              yield sty, stx, ty, tx
+            end
+          end
+        end
+
+        def refresh
+          return unless @refresh
+          start  = anchor.index
+          insert = buffer.at_insert
+          clear
+
+          if insert > start
+            add(start, insert + '1 chars')
+          else
+            add(insert, start + '1 chars')
+          end
+        end
+
+        # we assume char selection is always continuous, so no need to check the
+        # ranges.
+        def replace_with_clipboard
+          return unless content = Clipboard.dwim
+
+          start = buffer.index('sel.first')
+
+          case content
+          when Array
+            replace(content.join("\n"))
+          when String
+            replace(content)
+          else
+            raise "Unknown kind of clipboard content: %p" % [content]
+          end
+
+          finish
+          buffer.insert = start
+        end
+
+        def replace_with_string(string, expand)
+          insert = buffer.index(:insert)
+          anchor = self.anchor.index
+
+          from, to = buffer.index('sel.first'), buffer.index('sel.last')
+
+          buffer.undo_record do |record|
+            if expand
+              length = buffer.count(from, to, :displaychars)
+              record.replace(from, to, string * length)
+            else
+              record.replace(from, to, string)
+            end
+          end
+
+          self.anchor.index = anchor
+          refresh
+        end
+      end # Char
+    end # Selection
+  end # Text
+end # VER

data/lib/ver/text/selection/line.rb

@@ -0,0 +1,64 @@
+module VER
+  class Text
+    class Selection
+      class Line < Selection
+        def kill
+          indices = []
+          chunks = each_range.map do |range|
+            indices << range.first << (range.last + '1 chars')
+            buffer.get(*indices.last(2))
+          end
+
+          buffer.with_register do |register|
+            register.value = chunks.at(1) ? chunks : chunks.first
+          end
+
+          buffer.delete(*indices)
+          clear
+          finish
+        end
+
+        def copy
+          buffer.with_register do |register|
+            register.value = buffer.get("#{self}.first", "#{self}.last + 1 chars")
+          end
+
+          buffer.insert = "#{self}.first"
+          clear
+          finish
+        end
+
+        def each
+          return Enumerator.new(self, :each) unless block_given?
+
+          each_range do |range|
+            fy, fx, ty, tx = *range.first, *range.last
+
+            fy.upto(ty) do |y|
+              sy, sx = *buffer.index("#{y}.0 linestart")
+              ey, ex = *buffer.index("#{y}.0 lineend")
+              yield sy, sx, ey, ex
+            end
+          end
+        end
+
+        def mode_name
+          :select_line
+        end
+
+        def refresh
+          return unless @refresh
+          start = anchor.index
+          insert = buffer.at_insert
+          clear
+
+          if insert > start
+            add(start.linestart, insert.lineend)
+          else
+            add(insert.linestart, start.lineend)
+          end
+        end
+      end # Line
+    end # Selection
+  end # Text
+end # VER

data/lib/ver/text/tag.rb

@@ -0,0 +1,322 @@
+module VER
+  class Text
+    # The first form of annotation in text widgets is a tag.
+    # A tag is a textual string that is associated with some of the characters
+    # in a text.
+    # Tags may contain arbitrary characters, but it is probably best to avoid
+    # using the characters " " (space), "+" (plus), or "-" (minus): these
+    # characters have special meaning in indices, so tags containing them cannot
+    # be used as indices.
+    # There may be any number of tags associated with characters in a text.
+    # Each tag may refer to a single character, a range of characters, or
+    # several ranges of characters.
+    # An individual character may have any number of tags associated with it.
+    #
+    # A priority order is defined among tags, and this order is used in
+    # implementing some of the tag-related functions described below.
+    # When a tag is defined (by associating it with characters or setting its
+    # display options or binding commands to it), it is given a priority higher
+    # than any existing tag.
+    # The priority order of tags may be redefined using the "pathName tag
+    # raise" and "pathName tag lower" widget commands.
+    #
+    # Tags serve three purposes in text widgets.
+    # First, they control the way information is displayed on the screen.
+    # By default, characters are displayed as determined by the -background,
+    # -font, and -foreground options for the text widget.
+    # However, display options may be associated with individual tags using the
+    # "pathName tag configur" widget command.
+    # If a character has been tagged, then the display options associated with
+    # the tag override the default display style.
+    class Tag < Struct.new(:buffer, :name)
+      # FIXME: yes, i know i'm calling `tag add` for every line, which makes
+      #        things slower, but it seems like there is a bug in the text widget.
+      #        So we aggregate the information into a single eval.
+      def add(*indices)
+        code = [%(set win "#{buffer.tk_pathname}")]
+
+        indices.each_slice(2) do |first, last|
+          if last
+            code << %($win tag add #{name} "#{first}" "#{last}")
+          else
+            code << %($win tag add #{name} "#{first}")
+          end
+        end
+
+        Tk.execute_only(Tk::TclString.new(code.join("\n")))
+      end
+
+      def bind(*args, &block)
+        buffer.tag_bind(to_tcl, *args, &block)
+      end
+
+      def cget(option)
+        buffer.tag_cget(self, option)
+      end
+
+      # Comment all lines that the selection touches.
+      # Tries to maintain indent.
+      def comment
+        comment = buffer.options.comment_line.to_s
+        indent = nil
+        lines = []
+
+        each_line do |line, fc, tc|
+          line_fc, line_tc = "#{line}.#{fc}", "#{line}.#{tc}"
+
+          next if buffer.at_end == line_tc
+
+          lines << line
+
+          next if indent == 0 # can't get lower
+
+          line = buffer.get("#{line}.#{fc}", "#{line}.#{tc}")
+
+          next unless start = line =~ /\S/
+
+          indent ||= start
+          indent = start if start < indent
+        end
+
+        indent ||= 0
+
+        buffer.undo_record do |record|
+          lines.each do |line|
+            record.insert("#{line}.#{indent}", comment)
+          end
+        end
+      end
+
+      def configure(*options)
+        buffer.tag_configure(self, *options)
+      end
+
+      def copy
+        chunks = ranges.map{|range| range.get }
+        buffer.with_register{|reg| reg.value = chunks.at(1) ? chunks : chunks.first }
+      end
+
+      def delete
+        buffer.tag_delete(self)
+      end
+      alias tag_delete delete
+
+      def each_range(&block)
+        ranges.each(&block)
+      end
+
+      def each_line
+        return Enumerator.new(self, :each_line) unless block_given?
+
+        each_range do |range|
+          fy, fx, ty, tx = *range.first, *range.last
+          fy.upto(ty) do |y|
+            yield y, fx, tx
+          end
+        end
+      end
+
+      def encode_rot13!
+        buffer.undo_record do |record|
+          each_range do |range|
+            range.encode_rot13!(record)
+          end
+        end
+      end
+
+      # Eval contents of tag and insert them into the buffer.
+      def evaluate!
+        file = buffer.filename
+
+        each_range do |range|
+          code = range.get
+
+          Methods::Control.stdout_capture_evaluate(code, file, binding) do |res, out|
+            range.last.lineend.insert("\n%s%p" % [out, res])
+          end
+        end
+      end
+
+      def first
+        buffer.index("#{self}.first")
+      end
+
+      def get
+        values = ranges.map{|range| range.get }
+        values.size == 1 ? values.first : values unless values.empty?
+      end
+
+      def indent
+        indent_size = buffer.options.shiftwidth
+        indent = ' ' * indent_size
+
+        buffer.undo_record do |record|
+          each_line do |y, fx, tx|
+            tx = fx + indent_size
+            next if buffer.get("#{y}.#{fx}", "#{y}.#{tx}").empty?
+            record.insert("#{y}.#{fx}", indent)
+          end
+        end
+      end
+
+      def inspect
+        "#<VER::Text::Tag %p on %p>" % [name, buffer]
+      end
+
+      def kill
+        indices = []
+
+        chunks = ranges.map{|range|
+          indices << range.first << range.last
+          range.get
+        }
+
+        # A bit of duplication, but if we use copy here we have to iterate the
+        # ranges again.
+        buffer.with_register do |register|
+          register.value = chunks.at(1) ? chunks : chunks.first
+        end
+
+        buffer.delete(*indices)
+      end
+
+      def last
+        buffer.index("#{self}.last")
+      end
+
+      def lower(below_this = Tk::None)
+        buffer.tag_lower(self, below_this)
+      end
+      alias tag_lower lower
+
+      # Convert all characters within the tag to lower-case using
+      # String#downcase.
+      # Usually only works for alphabetic ASCII characters.
+      def lower_case!
+        buffer.undo_record do |record|
+          each_range do |range|
+            range.lower_case!(record)
+          end
+        end
+      end
+      alias downcase! lower_case!
+
+      def next_range(from_index, to_index = Tk::None)
+        buffer.tag_nextrange(self, from_index, to_index)
+      end
+      alias nextrange next_range
+
+      # Replace contents of tag with stdout output of a command
+      def pipe!(*cmd)
+        require 'open3'
+
+        Open3.popen3(*cmd) do |si, so, thread|
+          queue = []
+          each_range do |range|
+            si.write(range.get)
+            queue.concat(range.to_a)
+          end
+
+          si.close
+          output = so.read
+
+          return if queue.empty?
+
+          buffer.undo_record do |record|
+            record.delete(*queue)
+            record.insert(queue.first, output.chomp)
+          end
+        end
+      end
+
+      def prev_range(from_index, to_index = Tk::None)
+        buffer.tag_prevrange(self, from_index, to_index)
+      end
+      alias prevrange prev_range
+
+      def raise(above_this = Tk::None)
+        buffer.tag_raise(above_this)
+      end
+      alias tag_raise raise
+
+      def ranges
+        buffer.tag_ranges(self)
+      end
+
+      def remove(index, *indices)
+        buffer.tag_remove(self, index, *indices)
+      end
+      alias tag_remove remove
+
+      def replace(*args)
+        buffer.range("#{self}.first", "#{self}.last").replace(*args)
+      end
+
+      def to_s
+        name.to_s
+      end
+
+      def to_tcl
+        name.to_tcl
+      end
+
+      # Toggle case within the selection.
+      # This only works for alphabetic ASCII characters, no other encodings.
+      def toggle_case!
+        buffer.undo_record do |record|
+          each_range do |range|
+            range.toggle_case!(record)
+          end
+        end
+      end
+
+      def uncomment
+        comment = buffer.options.comment_line.to_s
+        regex = /#{Regexp.escape(comment)}/
+
+        buffer.undo_record do |record|
+          each_line do |y, fx, tx|
+            from, to = "#{y}.0 linestart", "#{y}.0 lineend"
+            line = buffer.get(from, to)
+
+            if line.sub!(regex, '')
+              record.replace(from, to, line)
+            end
+          end
+        end
+      end
+
+      def unindent
+        indent_size = buffer.options.shiftwidth
+        indent = ' ' * indent_size
+        queue = []
+
+        each_line do |y, fx, tx|
+          tx = fx + indent_size
+          left, right = "#{y}.#{fx}", "#{y}.#{tx}"
+          next unless buffer.get(left, right) == indent
+          queue << left << right
+        end
+
+        buffer.delete(*queue)
+      end
+
+      # Convert all characters within the tag to upper-case using
+      # String#upcase.
+      # Usually only works for alphabetic ASCII characters.
+      def upper_case!
+        buffer.undo_record do |record|
+          each_range do |range|
+            range.upper_case!(record)
+          end
+        end
+      end
+      alias upcase! upper_case!
+
+      def wrap(width = buffer.prefix_count(80))
+        wrapped = Methods::Control.wrap_lines_of(get, width)
+        replace(wrapped.join("\n"))
+      end
+    end
+  end
+end