ver 2009.12.14 → 2010.02

data/lib/ver/methods/nano.rb

@@ -0,0 +1,186 @@
+module VER
+  module Methods
+    # A bunch of methods specific to the Nano keymap.
+    module Nano
+      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)
+      end
+
+      # Insert the keystroke verbatim
+      def verbatim_insert(text)
+      end
+
+      # Noop
+      def redraw(text)
+        mumble "Redraw"
+      end
+
+      # Noop
+      def suspend(text)
+        mumble "Suspend"
+      end
+
+      def home(text)
+        if text.store(self, :smart_home)
+          smart_home(text)
+        else
+          dumb_home(text)
+        end
+      end
+
+      def smart_home(text)
+        insert = text.index(:insert)
+        x = text.get(insert.linestart, insert.lineend).index(/\S/) || 0
+        y = insert.y
+
+        if insert.split == [y, x]
+          text.mark_set(:insert, 'insert linestart')
+        else
+          text.mark_set(:insert, "#{y}.#{x}")
+        end
+      end
+
+      def dumb_home(text)
+        text.mark_set(:insert, 'insert linestart')
+      end
+
+      # Constant cursor position display enable/disable
+      def toggle_cursor_pos(text)
+        widgets = text.status.widgets
+        np = widgets.find{|widget| widget.kind_of?(Status::NanoPosition) }
+
+        if np.toggle
+          message "Constant cursor position display enabled"
+        else
+          message "Constant cursor position display disabled"
+        end
+      end
+
+      # Smart home key enable/disable
+      # If enabled, this makes the Home key smarter.
+      # When Home is pressed anywhere but at the very beginning of non-whitespace
+      # characters on a line, the cursor will jump to that beginning (either
+      # 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"
+        else
+          text.store(self, :smart_home, false)
+          message "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"
+        else
+          message "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"
+        else
+          message "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"
+        else
+          text.configure wrap: :word
+          message "Soft line wrapping enabled"
+        end
+      end
+
+      # Help mode enable/disable
+      def toggle_help_mode(text)
+        widgets = text.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"
+      end
+
+      # Smooth scrolling enable/disable
+      def toggle_smooth_scrolling(text)
+        mumble "Toggle smooth scrolling"
+      end
+
+      # Whitespace display enable/disable
+      def toggle_whitespace_display(text)
+        mumble "Toggle whitespace display"
+      end
+
+      # Color syntax highlighting enable/disable
+      def toggle_color_syntax_highlighting(text)
+        mumble "Toggle color syntax highlighting"
+      end
+
+      # Cut to end enable/disable
+      def toggle_cut_to_end(text)
+        mumble "Toggle cut to end"
+      end
+
+      # Long line wrapping enable/disable
+      def toggle_long_line_wrapping(text)
+        mumble "Toggle long line wrapping"
+      end
+
+      # Backup files enable/disable
+      def toggle_backup_files(text)
+        mumble "Toggle backup files"
+      end
+
+      # Multiple file buffers enable/disable
+      def toggle_multiple_file_buffers(text)
+        mumble "Toggle multiple file buffers"
+      end
+
+      # Mouse support enable/disable
+      def toggle_mouse(text)
+        mumble "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"
+      end
+
+      # Suspension enable/disable
+      def toggle_suspension(text)
+        mumble "Toggle suspension"
+      end
+
+      def message(string)
+        VER.message "[ #{string} ]"
+      end
+
+      def mumble(string)
+        VER.message "[ #{string} ignored, mumble mumble ]"
+      end
+    end
+  end
+end

data/lib/ver/methods/open.rb

@@ -1,6 +1,79 @@
 module VER
   module Methods
     module Open
+      GUESS_ENCODING_ORDER = [
+        Encoding::US_ASCII,
+        Encoding::UTF_8,
+        Encoding::Shift_JIS,
+        Encoding::EUC_JP,
+        Encoding::EucJP_ms,
+        Encoding::Big5,
+        Encoding::UTF_16BE,
+        Encoding::UTF_16LE,
+        Encoding::UTF_32BE,
+        Encoding::UTF_32LE,
+        Encoding::CP949,
+        Encoding::Emacs_Mule,
+        Encoding::EUC_KR,
+        Encoding::EUC_TW,
+        Encoding::GB18030,
+        Encoding::GBK,
+        Encoding::Stateless_ISO_2022_JP,
+        Encoding::CP51932,
+        Encoding::EUC_CN,
+        Encoding::GB12345,
+        Encoding::Windows_31J,
+        Encoding::MacJapanese,
+        Encoding::UTF8_MAC,
+        Encoding::BINARY,
+      ]
+
+      module_function
+
+      # Try to determine the file under the cursor.
+      # This handles names without spaces if no quotes are found
+      # quotes may be like '', "", [], {}, () <>
+      # we also search for the file in a couple of common locations.
+      # Since some programming languages allow omission of the
+      # filename-extension, we assume that it's one of the extensions registered
+      # for the current file type if nothing could be found otherwise.
+      # if that fails, we try to use `locate`, which can yield good results.
+      # if no file could be found it simply does nothing?
+      def file_under_cursor(text)
+        paths = %w[ . lib ext / ]
+        head = text.get('insert linestart', 'insert')
+        tail = text.get('insert', 'insert lineend')
+        tail_index = tail.index(/['"\]})>]/) || tail.index(/\s/)
+        return unless delim = $&
+
+        head_index = head.rindex(delim)
+        return unless tail_index && head_index
+
+        base = [head[(head_index + 1)..-1], tail[0...tail_index]].join
+
+        syntax_name = text.syntax.name if @syntax
+        exts = VER::Syntax::Detector::EXTS_LIST.fetch(syntax_name, [])
+
+        found = catch(:found){
+          paths.map{|path|
+            path_base = File.join(path, base)
+            throw(:found, path_base) if File.file?(path_base)
+            path_base
+          }.each do |path_base|
+            exts.each do |ext|
+              path_base_ext = "#{path_base}.#{ext}"
+              throw(:found, path_base_ext) if File.file?(path_base_ext)
+            end
+          end
+          nil
+        }
+      end
+
+      def open_file_under_cursor(text)
+        return unless found = file_under_cursor(text)
+        VER.find_or_create_buffer(found)
+      end
+
       # TODO:
       # Binary files are still major fail.
       # We could try to copy behaviour of Vim or Emacs.
@@ -33,64 +106,187 @@ module VER
       #
       # 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
+      def open_path(text, path, line = 1, column = 0)
+        text.filename = path
 
         begin
-          clear
-          insert 1.0, read_file(filename)
-          message "Opened #{short_filename}"
+          text.clear
+          content = read_file(text, text.filename)
+          text.encoding = content.encoding
+          text.readonly = !text.filename.writable?
+          text.insert(1.0, content)
+          VER.message "Opened #{text.short_filename}"
         rescue Errno::ENOENT
-          delete '1.0', :end
-          message "Create #{short_filename}"
+          text.clear
+          VER.message("Created #{text.short_filename}")
         end
 
-        after_open(line)
+        after_open(text, line, column)
+      end
+
+      def open_symbolic(text, name, line = 1, column = 0)
+        text.name = name
+        text.clear
+
+        case name
+        when :Scratch
+          text.insert(:insert, <<-TEXT)
+# This buffer is for notes you don't want to save, and for Ruby evaluation.
+# If you want to create a file, visit that file with :o.
+# then enter the text in that file's own buffer.
+          TEXT
+          after_open(text, 1, 0, Syntax.new('Ruby'))
+        when :Messages
+          text.tag_configure(:info, foreground: '#aaf')
+          text.tag_configure(:warn, foreground: '#faa')
+          after_open(text, 1, 0, Syntax.new('Plain Text'))
+        when :Completions
+          text.major_mode = :Completions
+          text.tag_configure('ver.minibuf.completion', foreground: '#00f')
+          after_open(text, 1, 0, Syntax.new('Plain Text'))
+        else
+          after_open(text, 1, 0, Syntax.new('Plain Text'))
+        end
+
+        VER.message "Created #{name}"
+      end
+
+      def open_empty(text)
+        text.clear
+        text.message "[No File]"
+        after_open(text, 1, 0, Syntax.new('Plain Text'))
+      end
+
+      def file_open_popup(text)
+        filetypes = [
+          ['ALL Files',  '*'    ],
+          ['Text Files', '*.txt'],
+        ]
+
+        fpath = Tk.get_open_file(filetypes: filetypes)
+
+        return unless fpath
+
+        VER.find_or_create_buffer(fpath)
+      end
+
+      def file_open_ask(text)
+        text.ask 'Filename: ', value: Dir.pwd do |answer, action|
+          case action
+          when :complete
+            file_complete(answer)
+          when :attempt
+            p answer
+            :abort
+          end
+        end
+      end
+
+      def file_complete(answer)
+        rel = answer.sub(/^.*\/\//, '/')
+        rel = rel.sub(/^.*\/~\//, '~/')
+        rel = File.expand_path(rel) unless File.directory?(rel)
+        rel_size = rel.size
+
+        choices = Dir.glob("#{rel}*").map{|path|
+          if File.directory?(path)
+            path[rel_size..-1] << '/'
+          else
+            path[rel_size..-1]
+          end
+        }
+
+        common = nil
+        choices.each do |path|
+          path.size.times do |index|
+            next if index == 0
+            slice = path[0, index]
+
+            if choices.all?{|choice| choice.start_with?(slice) }
+              common = slice
+            end
+          end
+        end
+
+        if common
+          only = answer + common
+
+          if choices.size == 1
+            choices.map{|choice| (answer + choice).sub(/\/+$/, '/') }
+          elsif choices.size > 1
+            [only]
+          else
+            if File.directory?(File.expand_path(only))
+              [only]
+            else
+              [only]
+            end
+          end
+        else
+          choices.map{|choice| (answer + choice).sub(/\/+$/, '/') }
+        end
       end
 
       # Read given file into memory and convert to @encoding
-      def read_file(path)
+      def read_file(text, path)
         path = Pathname(path.to_s).expand_path
-        encoding_name = encoding.name
-        content = path.open("r:#{encoding_name}"){|io| io.read }
+        encoding = text.encoding
+        content = path.open("r:#{encoding.name}"){|io| io.read }
 
         unless content.valid_encoding? # take a guess
-          @encoding = GUESS_ENCODING_ORDER.find{|enc|
+          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
+        return content.chomp
       end
 
-      def open_empty
-        delete '1.0', :end
-        message "[No File]"
-        after_open
+      def after_open(text, line = 1, column = 0, syntax = nil)
+        detect_project_paths(text)
+        VER.opened_file(text)
+
+        text.mark_set(:insert, "#{line.to_i}.#{column.to_i}")
+        text.pristine = true
+
+        text.undoer = VER::Undo::Tree.new(text)
+        update_mtime(text)
+
+        text.bind('<Map>') do
+          VER.defer do
+            syntax ? text.setup_highlight_for(syntax) : text.setup_highlight
+            apply_modeline(text)
+          end
+          text.bind('<Map>'){ text.see(:insert) }
+        end
       end
 
-      def after_open(line = 1)
-        VER.opened_file(self)
+      def update_mtime(text)
+        return unless filename = text.filename
+        text.store(:stat, :mtime, filename.mtime)
+      rescue Errno::ENOENT
+      end
 
-        edit_reset
-        mark_set :insert, "#{line.to_i}.0"
-        @pristine = false
+      PROJECT_DIRECTORY_GLOB = '{.git/,.hg/,_darcs/,_FOSSIL_}'
 
-        @undoer = VER::Undo::Tree.new(self)
+      def detect_project_paths(text)
+        return unless filename = text.filename
+        parent = filename.expand_path.dirname
 
-        bind('<Map>') do
-          defer do
-            setup_highlight
-            apply_modeline
+        begin
+          (parent/PROJECT_DIRECTORY_GLOB).glob do |repo|
+            text.project_repo = repo
+            text.project_root = repo.dirname
+            return
           end
-          bind('<Map>'){ see(:insert) }
-        end
+
+          parent = parent.dirname
+        end until parent.root?
       end
 
       MODELINES = {
@@ -99,69 +295,67 @@ module VER
         /^(?:ver|vim?):[^:]+:/      => /^(?:ver|vim?):([^:]+):/,
       }
 
-      def apply_modeline
+      def apply_modeline(text)
         MODELINES.each do |search_pattern, extract_pattern|
-          found = search(search_pattern, 1.0, :end, :count)
+          found = text.search(search_pattern, 1.0, :end, :count)
 
           next if found.empty?
 
           pos, count = found
-          p found: found, pos: pos, count: count
+          # p found: found, pos: pos, count: count
 
-          line = get(pos, "#{pos} + #{count} chars")
-          p line: line
+          line = text.get(pos, "#{pos} + #{count} chars")
+          # p line: line
 
           line =~ extract_pattern
           $1.scan(/[^:\s]+/) do |option|
-            apply_modeline_option(option)
+            apply_modeline_option(text, option)
           end
         end
       end
 
-      def apply_modeline_option(option)
+      def apply_modeline_option(text, option)
         negative = option.gsub!(/^no/, '')
         boolean = !negative
 
         case option
         when 'ai', 'autoindent'
-          set :autoindent, boolean
+          set text, :autoindent, boolean
         when 'et', 'expandtab'
-          set :expandtab, boolean
+          set text, :expandtab, boolean
         when /(?:tw|textwidth)=(\d+)/
-          set :textwidth, $1.to_i
+          set text, :textwidth, $1.to_i
         when /(?:ts|tabstop)=(\d+)/
-          set :tabstop, $1.to_i
+          set text, :tabstop, $1.to_i
         when /(?:sw|shiftwidth)=(\d+)/
-          set :shiftwidth, $1.to_i
+          set text, :shiftwidth, $1.to_i
         when /(?:ft|filetype)=(\w+)/
-          set :filetype, $1
+          set text, :filetype, $1
         else
           p unknown_modeline_option: option
         end
       end
 
-      attr_reader :options
-
-      def set(option, value)
+      def set(text, option, value)
         method = "set_#{option}"
 
         if respond_to?(method)
           if block_given?
-            __send__(method, value, &Proc.new)
+            __send__(method, text, value, &Proc.new)
           else
-            __send__(method, value)
+            __send__(method, text, value)
           end
         else
-          options[option] = value
-          yield(value) if block_given?
+          text.options[option] = value
+          yield(text, value) if block_given?
         end
       end
 
       def set_filetype(type)
-        syntax = Syntax.from_filename(Pathname("foo.#{type}"))
+        syntax = VER::Syntax.from_filename(Pathname("foo.#{type}"))
 
-        if load_syntax(syntax)
-          options.filetype = type
+        if text.load_syntax(syntax)
+          text.options.filetype = type
         end
       end
     end