ver 2009.10.14 → 2009.11.28

data/lib/ver/methods/open.rb

@@ -0,0 +1,208 @@
+module VER
+  module Methods
+    module Open
+      # TODO:
+      # Binary files are still major fail.
+      # We could try to copy behaviour of Vim or Emacs.
+      # Some nice files for testing binary display are in /usr/share/terminfo
+      #
+      # About the nature of fail:
+      # First of all, just about no font is made to have binary glyphs, even if it
+      # would be nice to create a composite font, and would make editing a lot
+      # nicer, it's really no option.
+      #
+      # Next issue is that some bytes that occur in binary files "\0" for example,
+      # cause big problems for Tcl_EvalEx.
+      #
+      # I've tried sending the byte as:
+      #   "\0", "\\0",
+      #   "\x0", "\\x0",
+      #   "\x00", "\\x00",
+      #   "\u0000", "\\u0000"
+      #
+      # Tcl doesn't like that at all.
+      # The first obviously sends the original \0 byte directly on, the second
+      # displays in the widget as "\0", "\x0", and so on, which will lead to total
+      # corruption.
+      #
+      # I have no idea how to work around this issue, must be some convention?
+      # More important though, is to avoid sending those bytes at all, and it
+      # seems to be a huge amount of work to get support for binary editing going.
+      # There are much better tools for this around already, and maybe diluting
+      # the normal Text buffer for this purpose will just make problems.
+      #
+      # For now, VER will simply fail to open files that contain \0 bytes, and
+      # display binary files in a weird way.
+      def open_path(path, line = 1)
+        self.filename = path
+
+        begin
+          self.value = read_file(filename)
+          message "Opened #{short_filename}"
+        rescue Errno::ENOENT
+          delete '1.0', :end
+          message "Create #{short_filename}"
+        end
+
+        after_open(line)
+      end
+
+      # Read given file into memory and convert to @encoding
+      def read_file(path)
+        path = Pathname(path.to_s).expand_path
+        encoding_name = encoding.name
+        content = path.open("r:#{encoding_name}"){|io| io.read }
+
+        unless content.valid_encoding? # take a guess
+          @encoding = GUESS_ENCODING_ORDER.find{|enc|
+            content.force_encoding(enc)
+            content.valid_encoding?
+          }
+
+          # Now we have the source encoding, let's make it UTF-8 so Tcl can
+          # handle it.
+          content.force_encoding(@encoding)
+          content.encode!(Encoding::UTF_8)
+        end
+
+        content.chomp
+      end
+
+      def open_empty
+        delete '1.0', :end
+        message "[No File]"
+        after_open
+      end
+
+      def after_open(line = 1)
+        VER.opened_file(self)
+
+        edit_reset
+        mark_set :insert, "#{line.to_i}.0"
+        @pristine = false
+
+        bind('<Map>') do
+          defer do
+            setup_highlight
+            apply_modeline
+          end
+          bind('<Map>'){ see(:insert) }
+        end
+      end
+
+      MODELINES = {
+        /\s+(?:ver|vim?|ex):\s*.*$/ => /\s+(?:ver|vim?|ex):\s*(.*)$/,
+        /\s+(?:ver|vim?|ex):[^:]+:/ => /\s+(?:ver|vim?|ex):([^:]+):/,
+        /^(?:ver|vim?):[^:]+:/      => /^(?:ver|vim?):([^:]+):/,
+      }
+
+      def apply_modeline
+        MODELINES.each do |search_pattern, extract_pattern|
+          found = search(search_pattern, 1.0, :end, :count)
+
+          next if found.empty?
+
+          pos, count = found
+          p found: found, pos: pos, count: count
+
+          line = get(pos, "#{pos} + #{count} chars")
+          p line: line
+
+          line =~ extract_pattern
+          $1.scan(/[^:\s]+/) do |option|
+            apply_modeline_option(option)
+          end
+        end
+      end
+
+      def apply_modeline_option(option)
+        negative = option.gsub!(/^no/, '')
+        boolean = !negative
+
+        case option
+        when 'ai', 'autoindent'
+          set :autoindent, boolean
+        when 'et', 'expandtab'
+          set :expandtab, boolean
+        when /(?:tw|textwidth)=(\d+)/
+          set :textwidth, $1.to_i
+        when /(?:ts|tabstop)=(\d+)/
+          set :tabstop, $1.to_i
+        when /(?:sw|shiftwidth)=(\d+)/
+          set :shiftwidth, $1.to_i
+        when /(?:ft|filetype)=(\w+)/
+          set :filetype, $1
+        else
+          p unknown_modeline_option: option
+        end
+      end
+
+      attr_reader :options
+
+      def set(option, value)
+        method = "set_#{option}"
+
+        if respond_to?(method)
+          if block_given?
+            __send__(method, value, &Proc.new)
+          else
+            __send__(method, value)
+          end
+        else
+          options[option] = value
+          yield(value) if block_given?
+        end
+
+        require 'pp'
+        pp options
+      end
+
+      def set_filetype(type)
+        syntax = Syntax.from_filename(Pathname("foo.#{type}"))
+
+        if load_syntax(syntax)
+          options.filetype = type
+        end
+      end
+    end
+  end
+end
+
+=begin
+There are two forms of modelines.  The first form:
+	[text]{white}{vi:|vim:|ex:}[white]{options}
+
+[text]		any text or empty
+{white}		at least one blank character (<Space> or <Tab>)
+{vi:|vim:|ex:}	the string "vi:", "vim:" or "ex:"
+[white]		optional white space
+{options}	a list of option settings, separated with white space or ':',
+		where each part between ':' is the argument for a ":set"
+		command (can be empty)
+
+Example:
+   vi:noai:sw=3 ts=6 ~
+
+The second form (this is compatible with some versions of Vi):
+
+	[text]{white}{vi:|vim:|ex:}[white]se[t] {options}:[text]
+
+[text]		any text or empty
+{white}		at least one blank character (<Space> or <Tab>)
+{vi:|vim:|ex:}	the string "vi:", "vim:" or "ex:"
+[white]		optional white space
+se[t]		the string "set " or "se " (note the space)
+{options}	a list of options, separated with white space, which is the
+		argument for a ":set" command
+:		a colon
+[text]		any text or empty
+
+Example:
+   /* vim: set ai tw=75: */ ~
+
+The white space before {vi:|vim:|ex:} is required.  This minimizes the chance
+that a normal word like "lex:" is caught.  There is one exception: "vi:" and
+"vim:" can also be at the start of the line (for compatibility with version
+3.0).  Using "ex:" at the start of the line will be ignored (this could be
+short for "example:").
+=end

data/lib/ver/methods/preview.rb

@@ -0,0 +1,14 @@
+module VER
+  module Methods
+    module Preview
+      def preview
+        return unless syntax
+
+        case syntax.name
+        when 'Ruby'
+          View::Console.new(self, 'ruby', filename)
+        end
+      end
+    end
+  end
+end

data/lib/ver/methods/save.rb

@@ -0,0 +1,111 @@
+module VER
+  module Methods
+    module Save
+      def may_close
+        return yield unless edit_modified?
+        return yield if persisted?
+
+        question = 'Save this buffer before closing? [y]es [n]o [c]ancel: '
+
+        status_ask question, take: 1 do |answer|
+          case answer[0]
+          when 'Y', 'y'
+            yield if file_save
+            :saved
+          when 'N', 'n'
+            yield
+            :close_without_saving
+          else
+            "Cancel closing"
+          end
+        end
+      end
+
+      def persisted?
+        return false unless filename && filename.file?
+        require 'digest/md5'
+
+        on_disk = Digest::MD5.hexdigest(filename.read)
+        in_memory = Digest::MD5.hexdigest(value)
+        on_disk == in_memory
+      end
+
+      def quit
+        VER.exit
+      end
+
+      def file_save(filename = self.filename)
+        save_to(filename)
+      end
+
+      def file_save_popup(options = {})
+        options = options.dup
+        options[:filetypes] ||= [
+          ['ALL Files',  '*'    ],
+          ['Text Files', '*.txt'],
+        ]
+
+        options[:filename]  ||= ::File.basename(@filename)
+        options[:extension] ||= ::File.extname(@filename)
+        options[:directory] ||= ::File.dirname(@filename)
+
+        fpath = Tk.get_save_file(options)
+
+        return unless fpath
+
+        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_atomic(filename, to)
+      rescue => exception
+        VER.error(exception)
+        save_dumb(to)
+      end
+
+      def save_atomic(from, to)
+        require 'tmpdir'
+        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}"
+        return true
+      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}"
+        return true
+      rescue Exception => ex
+        VER.error(ex)
+        return false
+      end
+    end
+  end
+end

data/lib/ver/methods/search.rb

@@ -1,9 +1,33 @@
 module VER
   module Methods
     module Search
-      def status_search
-        status_ask 'Search term: ' do |term|
-          tag_all_matching(:search, Regexp.new(term))
+      SEARCH_HIGHLIGHT = {
+        foreground: '#000',
+        background: '#ff0',
+      }
+
+      def status_search_next
+        status_search_common('/') do
+          search_next
+        end
+      end
+
+      def status_search_prev
+        status_search_common('?') do
+          search_prev
+        end
+      end
+
+      def status_search_common(question)
+        status_ask question do |term|
+          begin
+            needle = Regexp.new(term)
+          rescue RegexpError
+            needle = Regexp.escape(term)
+          end
+
+          tag_all_matching(:search, needle, SEARCH_HIGHLIGHT)
+          yield
         end
       end
 
@@ -13,21 +37,47 @@ module VER
       end
 
       def search_prev
-        from, to = tag_prevrange('search', 'insert - 1 chars', '0.0')
+        from, to = tag_prevrange('search', 'insert - 1 chars', '1.0')
         mark_set(:insert, from) if from
       end
 
       def search_next_word_under_cursor
         word = get('insert wordstart', 'insert wordend')
-        tag_all_matching(:search, word)
+        return if word.squeeze == ' ' # we don't want to match space
+        tag_all_matching(:search, word, SEARCH_HIGHLIGHT)
         search_next
       end
 
       def search_prev_word_under_cursor
         word = get('insert wordstart', 'insert wordend')
-        tag_all_matching(:search, word)
+        return if word.squeeze == ' ' # we don't want to match space
+        tag_all_matching(:search, word, SEARCH_HIGHLIGHT)
         search_prev
       end
+
+      def search_char_right
+        status_ask 'Search char right: ', take: 1 do |char|
+          from, to = 'insert', 'insert lineend'
+          regexp = Regexp.new(Regexp.escape(char))
+
+          search_all regexp, from, to do |match, pos, mark|
+            mark_set :insert, pos
+            break
+          end
+        end
+      end
+
+      def search_char_left
+        status_ask 'Search char left: ', take: 1 do |char|
+          from, to = 'insert', 'insert linestart'
+          regexp = Regexp.new(Regexp.escape(char))
+
+          rsearch_all regexp, from, to do |match, pos, mark|
+            mark_set :insert, pos
+            break
+          end
+        end
+      end
     end
   end
-end
+end

data/lib/ver/methods/select.rb

@@ -1,14 +1,39 @@
 module VER
   module Methods
     module Select
+      def wrap_selection
+        queue = []
+        text = []
+
+        each_selected_line do |y, fx, tx|
+          queue << y
+          text << get("#{y}.0", "#{y}.0 lineend")
+        end
+
+        lines = wrap_lines_of(text.join(' '))
+        from, to = queue.first, queue.last
+        replace("#{from}.0", "#{to}.0 lineend", lines.join("\n"))
+
+        finish_selection
+      end
+
       def start_selection_mode(name)
         self.mode = name
-        @selection_start = index(:insert).split('.').map(&:to_i)
-        refresh_selection
+        start_selection(name)
       end
 
       def switch_selection_mode(name)
         self.mode = name
+        switch_selection(name)
+      end
+
+      def start_selection(name)
+        self.selection_start = index(:insert)
+        switch_selection(name)
+      end
+
+      def switch_selection(name)
+        self.selection_mode = name.to_sym
         refresh_selection
       end
 
@@ -28,15 +53,17 @@ module VER
         delete(*queue)
         mark_set(:insert, queue.first)
 
-        clear_selection
-        start_control_mode
+        finish_selection
       end
 
       def indent_selection
+        indent_size = VER.options.shiftwidth
+        indent = ' ' * indent_size
+
         each_selected_line do |y, fx, tx|
-          tx = fx + 2
+          tx = fx + indent_size
           next if get("#{y}.#{fx}", "#{y}.#{tx}").empty?
-          insert("#{y}.#{fx}", '  ')
+          insert("#{y}.#{fx}", indent)
         end
 
         edit_separator
@@ -44,12 +71,14 @@ module VER
       end
 
       def unindent_selection
+        indent_size = VER.options.shiftwidth
+        indent = ' ' * indent_size
         queue = []
 
         each_selected_line do |y, fx, tx|
-          tx = fx + 2
+          tx = fx + indent_size
           left, right = "#{y}.#{fx}", "#{y}.#{tx}"
-          next unless get(left, right) == '  '
+          next unless get(left, right) == indent
           queue << left << right
         end
 
@@ -62,27 +91,24 @@ module VER
         tag_ranges(:sel).each do |from, to|
           code = get(from, to)
 
-          begin
-            result = eval(code)
-            insert("#{to} lineend", "\n%p" % [result])
-          rescue => exception
-            insert("#{to} lineend", "\n%p" % [exception])
+          stdout_capture_evaluate(code) do |res,out|
+            insert("#{to} lineend", "\n%s%p" % [out, res] )
           end
         end
+
+        finish_selection
       end
 
       def copy_selection
         chunks = tag_ranges(:sel).map{|sel| get(*sel) }
         copy(chunks.size == 1 ? chunks.first : chunks)
-        clear_selection
-        start_control_mode
+        finish_selection
       end
 
       def pipe_selection
         status_ask 'Pipe command: ' do |cmd|
           pipe_selection_execute(cmd)
-          clear_selection
-          start_control_mode
+          finish_selection
         end
       end
 
@@ -104,8 +130,62 @@ module VER
         refresh_selection
       end
 
+      def selection_replace_char
+        status_ask 'Replace selection with: ', take: 1 do |char|
+          if char.size == 1
+            replace_selection_with(char, full = true)
+            "replaced 1 char"
+          else
+            'replace aborted'
+          end
+        end
+      end
+
+      def selection_replace_string
+        status_ask 'Replace selection with: ', do |string|
+          if string.size > 0
+            replace_selection_with(string, full = false)
+            "replaced #{string.size} chars"
+          else
+            'replace aborted'
+          end
+        end
+      end
+
       private
 
+      # TODO: find better name for +full+
+      def replace_selection_with(string, full)
+        origin = index(:insert)
+
+        if full
+          each_selected_line do |y, fx, tx|
+            diff = tx - fx
+            replace("#{y}.#{fx}", "#{y}.#{tx}", string * diff)
+          end
+        else
+          string_size = string.size
+          each_selected_line do |y, fx, tx|
+            replace("#{y}.#{fx}", "#{y}.#{tx}", string)
+          end
+        end
+
+        edit_separator
+        mark_set :insert, origin
+      end
+
+      def finish_selection(mode = nil)
+        edit_separator
+        clear_selection
+        mode ? self.mode = mode : keymap.use_previous_mode
+        apply_mode_style(keymap.mode)
+      end
+
+      def clear_selection
+        self.selection_start = nil
+        tag_remove :sel, '1.0', 'end'
+      end
+
       def each_selection
         tag_ranges(:sel).each do |sel|
           (fy, fx), (ty, tx) = sel.map{|pos| pos.split('.').map(&:to_i) }