ver 2010.02 → 2010.08

data/lib/ver/methods/nano.rb

@@ -5,59 +5,87 @@ module VER
       module_function
 
       # Insert the next keystroke verbatim
-      def verbatim(text, action)
-        p text.major_mode.event_history.last
-        char = text.major_mode.event_history.last[:unicode]
-        text.insert(:insert, char)
+      def verbatim(buffer, action)
+        char = buffer.events.last.unicode
+        buffer.insert(:insert, char)
       end
 
       # Insert the keystroke verbatim
-      def verbatim_insert(text)
+      def verbatim_insert(buffer)
+      end
+
+      def ascii_enter(buffer, old, new)
+        buffer.store(self, :ascii_digit, [])
+      end
+
+      def ascii_leave(buffer, old, new)
+        buffer.store(self, :ascii_digit, nil)
+      end
+
+      def ascii(buffer)
+        unicode = buffer.events.last.unicode
+        if unicode =~ /^\d+$/
+          digits = buffer.store(self, :ascii_digit)
+          digits << unicode.to_i
+        else
+          # do nothing?
+          return
+        end
+
+        return if digits.size < 3
+
+        ord = digits.join.to_i
+        buffer.at_insert.insert(ord.chr)
+      rescue => ex
+        VER.error(ex)
+        buffer.minor_mode(:ascii_digit, :control)
+      else
+        buffer.minor_mode(:ascii_digit, :control)
       end
 
       # Noop
-      def redraw(text)
-        mumble "Redraw"
+      def redraw(buffer)
+        mumble buffer, "Redraw"
       end
 
       # Noop
-      def suspend(text)
-        mumble "Suspend"
+      def suspend(buffer)
+        mumble buffer, "Suspend"
       end
 
-      def home(text)
-        if text.store(self, :smart_home)
-          smart_home(text)
+      def home(buffer)
+        if buffer.store(self, :smart_home)
+          smart_home(buffer)
         else
-          dumb_home(text)
+          dumb_home(buffer)
         end
       end
 
-      def smart_home(text)
-        insert = text.index(:insert)
-        x = text.get(insert.linestart, insert.lineend).index(/\S/) || 0
+      def smart_home(buffer)
+        insert = buffer.index(:insert)
+        x = buffer.get(insert.linestart, insert.lineend).index(/\S/) || 0
         y = insert.y
 
         if insert.split == [y, x]
-          text.mark_set(:insert, 'insert linestart')
+          buffer.mark_set(:insert, 'insert linestart')
         else
-          text.mark_set(:insert, "#{y}.#{x}")
+          buffer.mark_set(:insert, "#{y}.#{x}")
         end
       end
 
-      def dumb_home(text)
-        text.mark_set(:insert, 'insert linestart')
+      def dumb_home(buffer)
+        buffer.mark_set(:insert, 'insert linestart')
       end
 
       # Constant cursor position display enable/disable
-      def toggle_cursor_pos(text)
-        widgets = text.status.widgets
+      def toggle_cursor_pos(buffer)
+        widgets = buffer.status.widgets
         np = widgets.find{|widget| widget.kind_of?(Status::NanoPosition) }
 
         if np.toggle
-          message "Constant cursor position display enabled"
+          message buffer, "Constant cursor position display enabled"
         else
-          message "Constant cursor position display disabled"
+          message buffer, "Constant cursor position display disabled"
         end
       end
 
@@ -68,118 +96,118 @@ module VER
       # forwards or backwards).
       # If the cursor is already at that position, it will jump to the true
       # beginning of the line.
-      def toggle_smart_home_key(text)
-        if old = text.store(self, :smart_home)
-          text.store(self, :smart_home, true)
-          message "Smart home key enabled"
+      def toggle_smart_home_key(buffer)
+        if old = buffer.store(self, :smart_home)
+          buffer.store(self, :smart_home, true)
+          message buffer, "Smart home key enabled"
         else
-          text.store(self, :smart_home, false)
-          message "Smart home key disabled"
+          buffer.store(self, :smart_home, false)
+          message buffer, "Smart home key disabled"
         end
       end
 
       # Auto indent enable/disable
       # If enabled, indent new lines to the previous line's indentation.
       # Useful when editing source code.
-      def toggle_auto_indent(text)
-        if text.options.autoindent = !text.options.autoindent
-          message "Auto indent enabled"
+      def toggle_auto_indent(buffer)
+        if buffer.options.autoindent = !buffer.options.autoindent
+          message buffer, "Auto indent enabled"
         else
-          message "Auto indent disabled"
+          message buffer, "Auto indent disabled"
         end
       end
 
       # Conversion of typed tabs to spaces enable/disable
-      def toggle_convert_typed_tabs_to_spaces(text)
-        if text.options.expandtab = !text.options.expandtab
-          message "Conversion of typed tabs to spaces enabled"
+      def toggle_convert_typed_tabs_to_spaces(buffer)
+        if buffer.options.expandtab = !buffer.options.expandtab
+          message buffer, "Conversion of typed tabs to spaces enabled"
         else
-          message "Conversion of typed tabs to spaces disabled"
+          message buffer, "Conversion of typed tabs to spaces disabled"
         end
       end
 
       # Soft line wrapping enable/disable
       # VER will attempt to display the entire contents of a line, even if it is
       # longer than the screen width.
-      def toggle_soft_line_wrapping(text)
-        if text.cget(:wrap) == :word
-          text.configure wrap: :none
-          message "Soft line wrapping disabled"
+      def toggle_soft_line_wrapping(buffer)
+        if buffer.cget(:wrap) == :word
+          buffer.configure wrap: :none
+          message buffer, "Soft line wrapping disabled"
         else
-          text.configure wrap: :word
-          message "Soft line wrapping enabled"
+          buffer.configure wrap: :word
+          message buffer, "Soft line wrapping enabled"
         end
       end
 
       # Help mode enable/disable
-      def toggle_help_mode(text)
-        widgets = text.status.widgets
+      def toggle_help_mode(buffer)
+        widgets = buffer.status.widgets
         np = widgets.find{|widget| widget.kind_of?(Status::NanoHelp) }
 
         message(np.toggle ? "Help mode enabled" : "Help mode disabled")
       end
 
       # Use of one more line for editing enable/disable
-      def toggle_one_more_line(text)
-        mumble "Toggle one more line ignored"
+      def toggle_one_more_line(buffer)
+        mumble buffer, "Toggle one more line ignored"
       end
 
       # Smooth scrolling enable/disable
-      def toggle_smooth_scrolling(text)
-        mumble "Toggle smooth scrolling"
+      def toggle_smooth_scrolling(buffer)
+        mumble buffer, "Toggle smooth scrolling"
       end
 
       # Whitespace display enable/disable
-      def toggle_whitespace_display(text)
-        mumble "Toggle whitespace display"
+      def toggle_whitespace_display(buffer)
+        mumble buffer, "Toggle whitespace display"
       end
 
       # Color syntax highlighting enable/disable
-      def toggle_color_syntax_highlighting(text)
-        mumble "Toggle color syntax highlighting"
+      def toggle_color_syntax_highlighting(buffer)
+        mumble buffer, "Toggle color syntax highlighting"
       end
 
       # Cut to end enable/disable
-      def toggle_cut_to_end(text)
-        mumble "Toggle cut to end"
+      def toggle_cut_to_end(buffer)
+        mumble buffer, "Toggle cut to end"
       end
 
       # Long line wrapping enable/disable
-      def toggle_long_line_wrapping(text)
-        mumble "Toggle long line wrapping"
+      def toggle_long_line_wrapping(buffer)
+        mumble buffer, "Toggle long line wrapping"
       end
 
       # Backup files enable/disable
-      def toggle_backup_files(text)
-        mumble "Toggle backup files"
+      def toggle_backup_files(buffer)
+        mumble buffer, "Toggle backup files"
       end
 
       # Multiple file buffers enable/disable
-      def toggle_multiple_file_buffers(text)
-        mumble "Toggle multiple file buffers"
+      def toggle_multiple_file_buffers(buffer)
+        mumble buffer, "Toggle multiple file buffers"
       end
 
       # Mouse support enable/disable
-      def toggle_mouse(text)
-        mumble "Toggle mouse support"
+      def toggle_mouse(buffer)
+        mumble buffer, "Toggle mouse support"
       end
 
       # No conversion from DOS/Mac format enable/disable
-      def toggle_dos_mac_format_conversion(text)
-        mumble "Toggle no conversion from DOS/Mac format"
+      def toggle_dos_mac_format_conversion(buffer)
+        mumble buffer, "Toggle no conversion from DOS/Mac format"
       end
 
       # Suspension enable/disable
-      def toggle_suspension(text)
-        mumble "Toggle suspension"
+      def toggle_suspension(buffer)
+        mumble buffer, "Toggle suspension"
       end
 
-      def message(string)
-        VER.message "[ #{string} ]"
+      def message(buffer, string)
+        buffer.message "[ #{string} ]"
       end
 
       def mumble(string)
-        VER.message "[ #{string} ignored, mumble mumble ]"
+        buffer.message "[ #{string} ignored, mumble mumble ]"
       end
     end
   end

data/lib/ver/methods/open.rb

@@ -51,7 +51,7 @@ module VER
 
         base = [head[(head_index + 1)..-1], tail[0...tail_index]].join
 
-        syntax_name = text.syntax.name if @syntax
+        syntax_name = text.syntax.name if text.syntax
         exts = VER::Syntax::Detector::EXTS_LIST.fetch(syntax_name, [])
 
         found = catch(:found){
@@ -115,10 +115,10 @@ module VER
           text.encoding = content.encoding
           text.readonly = !text.filename.writable?
           text.insert(1.0, content)
-          VER.message "Opened #{text.short_filename}"
+          text.message "Opened #{text.short_filename}"
         rescue Errno::ENOENT
           text.clear
-          VER.message("Created #{text.short_filename}")
+          text.message("Created #{text.short_filename}")
         end
 
         after_open(text, line, column)
@@ -148,7 +148,7 @@ module VER
           after_open(text, 1, 0, Syntax.new('Plain Text'))
         end
 
-        VER.message "Created #{name}"
+        text.message "Created #{name}"
       end
 
       def open_empty(text)
@@ -171,12 +171,13 @@ module VER
       end
 
       def file_open_ask(text)
-        text.ask 'Filename: ', value: Dir.pwd do |answer, action|
+        path = Dir.pwd + '/'
+        text.ask 'Filename: ', value: path do |answer, action|
           case action
           when :complete
             file_complete(answer)
           when :attempt
-            p answer
+            VER.find_or_create_buffer(answer)
             :abort
           end
         end
@@ -332,7 +333,7 @@ module VER
         when /(?:ft|filetype)=(\w+)/
           set text, :filetype, $1
         else
-          p unknown_modeline_option: option
+          l unknown_modeline_option: option
         end
       end
 

data/lib/ver/methods/preview.rb

@@ -13,32 +13,52 @@ module VER
 
       module_function
 
-      def preview(text)
-        return unless syntax = text.syntax
+      def preview(buffer)
+        return unless syntax = buffer.syntax
 
-        case syntax.name
-        when 'Ruby'; preview_ruby(text)
+        method = "preview_#{syntax.name}".downcase
+
+        if respond_to?(method)
+          send(method, buffer)
+        end
+      end
+
+      def compile(buffer)
+        return unless syntax = buffer.syntax
+
+        method = "compile_#{syntax.name}".downcase
+
+        if respond_to?(method)
+          send(method, buffer)
         end
       end
 
-      def preview_ruby(text)
-        save(text)
-        open_rxvt(text, <<-SHELL)
-ruby #{text.filename.shellescape}
+      def compile_haml(buffer)
+      end
+
+      def compile_sass(buffer)
+      end
+
+      def preview_ruby(buffer)
+        buffer.save
+        spawn_rxvt(<<-SHELL)
+ruby #{buffer.filename.shellescape}
 echo "\nPreview finished, press <Return> to return to VER"
 read
 exit
         SHELL
       end
 
-      def save(text)
-        Save.file_save(text)
+      # Open a new urxvt term in the background, this is not kept inside VER
+      # layout.
+      def spawn_rxvt(command)
+        system("urxvt -e $SHELL -c '%s' &" % [command])
       end
 
       # Open a new urxvt term and manage it inside the layout of VER.
       # Please let me know if you notice weird behaviour around the focus
-      def open_rxvt(text, command)
-        layout = text.layout
+      def open_rxvt(buffer, command)
+        layout = buffer.layout
 
         # No Tk::Tile::Frame as it doesn't support container
         frame = Frame.new(layout, container: true)
@@ -52,7 +72,7 @@ exit
           # Usually humans don't notice the delay, so we could increase it a bit
           # if need arises.
           Tk::After.ms 100 do
-            text.focus
+            buffer.focus
             frame.focus
           end
         end
@@ -66,7 +86,7 @@ exit
         frame.bind '<Destroy>' do |event|
           Tk::After.idle do
             layout.close_buffer(frame)
-            text.focus(:force) # need to use force, the term was outside tk
+            buffer.focus(:force) # need to use force, the term was outside tk
           end
         end
       end

data/lib/ver/methods/save.rb

@@ -1,193 +1,224 @@
 module VER
-  module Methods
-    # TODO: we _must_ write backup files, VER can corrupt files on a system
-    #       crash for some reason.
-    module Save
-      module_function
-
-      def may_close(text)
-        return yield if text.pristine?
-        return yield if text.persisted?
-
-        question = "Save buffer #{text.buffer.name} " \
-                   "before closing? [y]es [n]o [c]ancel: "
-
-        text.ask question, value: 'y' do |answer, action|
-          case action
-          when :attempt
-            case answer[0]
-            when /y/i
-              yield if save(text)
-              VER.message 'Saved'
-              :abort
-            when /n/i
-              yield
-              VER.message 'Closing without saving'
-              :abort
-            else
-              VER.warn "Cancel closing"
-              :abort
-            end
-          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 ;)
+  #
+  # TODO: we _must_ write backup files, VER can corrupt files on a system
+  #       crash for some reason.
+  class Buffer
+    # Close one buffer after another, wait when one needs user input.
+    def quit
+      buffers = VER.buffers.each
+      closer = lambda{
+        begin
+          buffers.next.close(&closer)
+        rescue StopIteration
         end
-      end
-
-      def may_save(text, as = nil)
-        last = text.store(:stat, :mtime)
-        current = text.filename.mtime rescue nil
-
-        if last && current
-          if last == current
-            yield
-          else
-            question = "The buffer #{text.buffer.name} " \
-                       "has changed since last save, overwrite? [y]es [n]o: "
-            text.ask question, value: 'n' do |answer, action|
-              case action
-              when :attempt
-                case answer[0]
-                when /y/i
-                  yield
-                  :abort
-                else
-                  VER.warn "Save aborted"
-                  :abort
-                end
-              end
-            end
-          end
-        else
-          yield
-        end
-      end
+      }
+      closer.call
+    end
 
-      def quit(text = nil)
-        buffers = VER.buffers.values
-        pending = Array.new(buffers.size)
-
-        buffers.each_with_index do |buffer, index|
-          VER.defer do
-            may_close(buffer.text) do
-              pending[index] = true
-              # p pending
-              VER.exit if pending.all?
-            end
-          end
+    # Save all buffers in ordered fashion, take into account that some buffers
+    # might require user interaction.
+    def save_all
+      buffers = VER.buffers.each
+      closer = lambda{
+        begin
+          buffers.next.save(&closer)
+        rescue StopIteration
         end
-      end
+      }
+      closer.call
+    end
 
-      def save_all(text)
-        VER.buffers.each do |name, buffer|
-          save(buffer.text)
-        end
+    # Try to copy the file we want to save to a temp dir, trying to preserve
+    # permissions.
+    # Once it's there, we overwrite the contents with the buffer contents.
+    # If that worked, we move it to the original location.
+    #
+    # On sshfs mounts we might face chown issues, so we ignore them.
+    # If this all fails for some reason, we resort to {save_dumb}
+    #
+    # When save was successful overall, we call the given +block+.
+    def save_atomic(from, to, &block)
+      require 'tmpdir'
+      sha1 = Digest::SHA1.hexdigest([from, to].join)
+      temp_path = File.join(Dir.tmpdir, 'ver/save', sha1)
+      temp_dir = File.dirname(temp_path)
+
+      FileUtils.mkdir_p(temp_dir)
+      FileUtils.copy_file(from, temp_path, preserve = true)
+      if save_dumb(temp_path)
+        FileUtils.mv(temp_path, to)
+        success("Saved to #{to}", &block)
+      else
+        false
       end
-
-      def save(text)
-        save_to(text, text.filename)
+    rescue Errno::EACCES => ex
+      # sshfs-mounts raise error but save correctly.
+      if ex.backtrace[0].match(/chown\'$/)
+        success("Saved to #{to} (chown issue)", &block)
+      else
+        warn(ex)
+        false
       end
+    rescue Errno::ENOENT
+      save_dumb(to, &block)
+    end
 
-      def save_as(text)
-        dir = text.filename.dirname.to_s + '/'
-
-        text.ask 'Filename: ', value: dir do |answer, action|
-          case action
-          when :complete
-            Pathname(answer + '*').expand_path.glob.map{|f|
-              File.directory?(f) ? "#{f}/" : f
-            }
-          when :attempt
-            begin
-              save_to(text, Pathname(answer).expand_path)
-              :abort
-            rescue => exception
-              VER.warn exception
-            end
-          end
+    def save_dumb(to, &block)
+      File.open(to, 'w+') do |io|
+        io.set_encoding(self.encoding)
+
+        begin
+          io.write(self.value)
+        rescue Encoding::UndefinedConversionError => ex
+          # this might happen when trying to save UTF-8 as US-ASCII
+          # so just warn, try to save as UTF-8 instead.
+          warn("Saving as UTF-8 because of: #{ex.class}: #{ex}")
+          io.rewind
+          io.set_encoding(Encoding::UTF_8)
+          io.write(self.value)
+          self.encoding = Encoding::UTF_8
         end
       end
 
-      def file_save(text, filename = text.filename)
-        save_to(text, filename)
-      end
+      success("Saved to #{to}", &block)
+    rescue Exception => ex
+      warn(ex)
+      VER.error(ex)
+      return false
+    end
 
-      def file_save_popup(text, options = {})
-        options = options.dup
-        options[:filetypes] ||= [
-          ['ALL Files',  '*'    ],
-          ['Text Files', '*.txt'],
-        ]
+    def success(message)
+      self.message(message)
+      self.pristine = true
+      update_mtime
+      yield if block_given?
+      true
+    end
 
-        filename = text.filename
-        options[:initialfile]      ||= ::File.basename(filename)
-        options[:defaultextension] ||= ::File.extname(filename)
-        options[:initialdir]       ||= ::File.dirname(filename)
+    def save_popup(options = {}, &block)
+      options = options.dup
+      options[:filetypes] ||= [
+        ['ALL Files',  '*'    ],
+        ['Text Files', '*.txt'],
+      ]
 
-        fpath = Tk.get_save_file(options)
+      options[:initialfile]      ||= filename.basename
+      options[:defaultextension] ||= filename.extname
+      options[:initialdir]       ||= filename.dirname
 
-        return unless fpath
+      fpath = Tk.get_save_file(options)
+      return unless fpath
+      save_to(fpath, &block)
+    end
 
-        save_to(text, fpath)
+    def save(filename = self.filename, &block)
+      if filename
+        save_to(filename, &block)
+      else
+        save_as(&block)
       end
+    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(text, to)
-        may_save(text){ save_atomic(text, text.filename, to) }
-      rescue => exception
-        VER.error(exception)
-        may_save(text){ save_dumb(text, to) }
+    def save_to(to, &block)
+      may_save{ save_atomic(filename, to, &block) }
+    rescue => exception
+      VER.error(exception)
+      may_save{ save_dumb(to, &block) }
+    end
+
+    def save_as
+      if filename = self.filename
+        dir = filename.dirname.to_s + '/'
+      else
+        dir = Dir.pwd + '/'
       end
 
-      def save_atomic(text, 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)
-        save_dumb(text, temp_path) && FileUtils.mv(temp_path, to)
-
-        success(text, "Saved to #{to}")
-      rescue Errno::EACCES => ex
-        # sshfs-mounts raise error but save correctly.
-        if ex.backtrace[0].match(/chown\'$/)
-          success(text, "Saved to #{to} (chown issue)")
-        else
-          VER.warn ex
-          false
+      message = "Save #{uri} as: "
+
+      ask message, value: dir do |answer, action|
+        case action
+        when :complete
+          Pathname(answer + '*').expand_path.glob.map{|f|
+            File.directory?(f) ? "#{f}/" : f
+          }
+        when :attempt
+          begin
+            save_to(Pathname(answer).expand_path)
+            yield if block_given?
+            :abort
+          rescue => exception
+            warn exception
+          end
         end
-      rescue Errno::ENOENT
-        save_dumb(text, to)
       end
+    end
 
-      def save_dumb(text, to)
-        File.open(to, 'w+') do |io|
-          io.write(text.value)
+    def may_close
+      return yield if pristine? || persisted?
+
+      question = "Save buffer #{uri} before closing? " \
+                 "[y]es [n]o [c]ancel: "
+
+      ask question, value: 'y' do |answer, action|
+        case action
+        when :attempt
+          case answer[0]
+          when /y/i
+            may_save{ yield if save }
+            VER.message 'Saved'
+            :abort
+          when /n/i
+            yield
+            VER.message 'Closing without saving'
+            :abort
+          else
+            VER.warn "Cancel closing"
+            :abort
+          end
         end
+      end
+    end
 
-        success(text, "Saved to #{to}")
-      rescue Exception => ex
-        VER.error(ex)
-        return false
+    def may_save(as = nil)
+      last    = store(:stat, :mtime)
+      current = filename.mtime rescue nil
+
+      # if we have two mtimes
+      if last && current
+        # save if they're the same
+        return yield if last == current
+      else
+         # save since there is no previous one
+        return yield
       end
 
-      def success(text, message)
-        VER.message message
-        text.pristine = true
-        Open.update_mtime(text)
-        true
+      question = "The buffer #{uri} has changed since last save, " \
+                 "overwrite? [y]es [n]o: "
+      ask question, value: 'n' do |answer, action|
+        case action
+        when :attempt
+          case answer[0]
+          when /y/i
+            yield
+            :abort
+          else
+            warn "Save aborted"
+            :abort
+          end
+        end
       end
     end
   end