Changeset 6579 for lang/vim

Timestamp:

02/12/08 01:44:48 (10 months ago)

Author:

kana

Message:

lang/vim/ku:
* Sync with my local repository (from 2008-02-11T14:51:28+0900 to

2008-02-12T01:43:48+09:00).

Location:

lang/vim/ku/trunk

Files:

• autoload/ku.vim (modified) (21 diffs)
• doc/ku.txt (modified) (5 diffs)

lang/vim/ku/trunk/autoload/ku.vim

@@ -4 +4 @@
 " License: MIT license (see <http://www.opensource.org/licenses/mit-license>)
 " $Id$  "{{{1
-" FIXME: auto-complete 1 component for each typing '/' (like bluewind).
 " FIXME: s:do(): Force action on unmatched pattern.
 " FIXME: more smart sorting:
@@ -24 +23 @@
 let s:TYPE_DICTONARY = type({})
 
+" Key sequence to start (omni) completion
+" without auto-selecting the first match.
+let s:KEYS_TO_START_COMPLETION = "\<C-x>\<C-o>\<C-p>"
+
+" The prompt for user input.
+" This is necessary to publish CursorMovedI event for each typing.
+" Note that the length should be 1 to avoid some problems.
+let s:PROMPT = '>'
+
+
+" Flag to avoid infinite loop by auto-directory-insertion.
+let s:auto_directory_insertion_done_p = s:FALSE
 
 " Flag which indicates whether the ku window is opened with bang (:Ku!).
@@ -32 +43 @@
 let s:INVALID_BUFNR = -3339
   " to be reloadable (for debugging)
-if exists('s:bufnr') && s:bufnr != s:INVALID_BUFNR
+if exists('s:bufnr') && s:bufnr != s:INVALID_BUFNR && bufexists(s:bufnr)
   execute s:bufnr 'bwipeout'
 endif
 let s:bufnr = s:INVALID_BUFNR
 
+" Fallback actions for all types.
+if !exists('s:fallback_actions')
+  let s:fallback_actions = {}
+endif
+
+" The last column of the cursor.
+let s:INVALID_COL = -3338
+let s:last_col = s:INVALID_COL
+
+" Items gathered by the last completion.
+let s:last_items = []
+
 " Preferred type of items.
 let s:INVALID_TYPE = '*all*'
 let s:preferred_type = s:INVALID_TYPE
-
-" Key sequence to start (omni) completion
-" without auto-selecting the first match.
-let s:KEYS_TO_START_COMPLETION = "\<C-x>\<C-o>\<C-p>"
-
-" The last column of the cursor.
-let s:INVALID_COL = -3338
-let s:last_col = s:INVALID_COL
-
-" Items gathered by the last completion.
-let s:last_items = []
 
 " All available types.
@@ -57 +69 @@
 endif
 
-" The prompt for user input.
-" This is necessary to publish CursorMovedI event for each typing.
-" Note that the length should be 1 to avoid some problems.
-let s:PROMPT = '>'
-
 " Misc. values to restore the original state.
 let s:completeopt = ''
 let s:ignorecase = ''
 let s:winrestcmd = ''
-
-" Flag to avoid infinite loop by auto-directory-insertion.
-let s:auto_directory_insertion_done_p = s:FALSE
 
 
@@ -108 +112 @@
   set ignorecase
   let s:winrestcmd = winrestcmd()
+
+  " Do some initialization for each type -- before opening the ku buffer.
+  for type_name in keys(s:types)
+    call s:types[type_name].initialize('before-open')
+  endfor
 
   " Open a new window and switch to the ku buffer.
@@ -119 +128 @@
   2 wincmd _
 
-  " Do some initialization for each type.
+  " Do some initialization for each type -- after opening the ku buffer.
   for type_name in keys(s:types)
-    call s:types[type_name].initialize()
+    call s:types[type_name].initialize('after-open')
   endfor
 
@@ -174 +183 @@
 function! ku#custom_key(type_name, key, new_action_name)  "{{{2
   if !s:valid_type_name_p(a:type_name)
-   \ || !has_key(s:types[a:type_name].actions, a:new_action_name)
+   \ || !s:type_has_action_p(s:types[a:type_name], a:new_action_name)
     return ''
   endif
@@ -187 +196 @@
 
 function! ku#custom_action(type_name, action_name, new_action_function)  "{{{2
-  if !s:valid_type_name_p(a:type_name) || !s:callable_p(a:new_action_function)
+  if !s:callable_p(a:new_action_function)
     return s:FALSE
   endif
 
-  let s:types[a:type_name].actions[a:action_name] = a:new_action_function
+  if a:type_name ==# '*fallback*'
+    let s:fallback_actions[a:action_name] = a:new_action_function
+  elseif s:valid_type_name_p(a:type_name)
+    let s:types[a:type_name].actions[a:action_name] = a:new_action_function
+  else
+    return s:TRUE
+  endif
   return s:TRUE
 endfunction
@@ -301 +316 @@
       \ = (a:choose_p
       \    ? s:choose_action_for_item(item)
-      \    : item._ku_type.actions[item._ku_type.keys['*default*']])
+      \    : s:type_action(item._ku_type, item._ku_type.keys['*default*']))
     call s:apply(ActionFunction, [item])
   endif
@@ -624 +639 @@
 
   if has_key(a:item._ku_type.keys, c)
-    let name = a:item._ku_type.keys[c]
-    if has_key(a:item._ku_type.actions, name)
-      return a:item._ku_type.actions[name]
+    let Action = s:type_action(a:item._ku_type, a:item._ku_type.keys[c])
+    if s:callable_p(Action)
+      return Action
     endif
   endif
@@ -728 +743 @@
   endfor
   for n in values(a:args.keys)
-    if !has_key(a:args.actions, n)
+    if !s:type_has_action_p(a:args, n)
       return s:FALSE
     endif
@@ -737 +752 @@
 
   return s:TRUE
+endfunction
+
+
+
+
+function! s:type_has_action_p(type, action_name)  "{{{2
+  return s:callable_p(s:type_action(a:type, a:action_name))
+endfunction
+
+
+
+
+function! s:type_action(type, action_name)  "{{{2
+  let Action = get(a:type.actions, a:action_name, 0)
+  if s:callable_p(Action)
+    return Action
+  endif
+  return get(s:fallback_actions, a:action_name, 0)
 endfunction
 
@@ -799 +832 @@
   call feedkeys("\<C-b>", 'n')
 endfunction
+call ku#custom_action('*fallback*', 'ex', function('s:_type_any_action_ex'))
 
 
@@ -812 +846 @@
   endif
 endfunction
+call ku#custom_action('*fallback*', 'cd', s:pa('s:_type_any_action_xcd', 'cd'))
+call ku#custom_action('*fallback*', 'cd-local',
+   \                  s:pa('s:_type_any_action_xcd', 'lcd'))
 
 
@@ -910 +947 @@
    \     'split-far-right':
    \       s:pa('s:_type_buffer_action_xsplit', 'vertical botright'),
-   \     'ex':
-   \       function('s:_type_any_action_ex'),
-   \     'cd':
-   \       s:pa('s:_type_any_action_xcd', 'cd'),
-   \     'cd-local':
-   \       s:pa('s:_type_any_action_xcd', 'lcd'),
    \     'unload':
    \       s:pa('s:_type_buffer_action_xdelete', 'bunload'),
@@ -929 +960 @@
 
 " file  "{{{2
-" FIXME: smart caching.
-function! s:_type_file_initialize()
-  let s:_type_file_cache = {}
-  let s:_type_file_frags_count = -1
-endfunction
+" Note: Timestamps of directories will be updated when files/directories are
+" created or removed.
+  " key = full path of the directory
+  " value = [time stamp of the directory, list of items in the directory]
+  " FIXME: how about when the cache becames too large?
+let s:_type_file_cache = {}
 
 function! s:_type_file_gather(pattern)
@@ -942 +974 @@
     let base_directory = a:pattern[:last_slash]
     let last_component = a:pattern[last_slash+1:]
-    let cache_key = base_directory
+    let cache_key = fnamemodify(base_directory, ':p')
   else
     let base_directory = ''
     let last_component = a:pattern
-    let cache_key = ' '  " can't use empty string as a key of dictionaries.
+    let cache_key = fnamemodify('.', ':p')
   endif
 
   if !has_key(s:_type_file_cache, cache_key)
+   \ || getftime(cache_key) != s:_type_file_cache[cache_key][0]
     let items = []
     for f in ['*', '.[^.]*']
@@ -956 +989 @@
       endfor
     endfor
-    let s:_type_file_cache[cache_key] = items
-  endif
-  return s:_type_file_cache[cache_key]
+    let s:_type_file_cache[cache_key] = [getftime(cache_key), items]
+  endif
+  return s:_type_file_cache[cache_key][1]
 endfunction
 
@@ -973 +1006 @@
 call ku#register_type({
    \   'name': 'file',
-   \   'initialize': function('s:_type_file_initialize'),
    \   'gather': function('s:_type_file_gather'),
    \   'keys': {
@@ -1025 +1057 @@
    \     'split-far-right':
    \       s:pa('s:_type_file_action_xsplit', 'vertical botright'),
-   \     'ex':
-   \       function('s:_type_any_action_ex'),
-   \     'cd':
-   \       s:pa('s:_type_any_action_xcd', 'cd'),
-   \     'cd-local':
-   \       s:pa('s:_type_any_action_xcd', 'lcd'),
    \   },
    \ })
@@ -1041 +1067 @@
 
 
-" __END__  "{{{1
+" Fin.  "{{{1
+
+silent doautocmd User KuLoaded
+
+
+
+
+
+
+
+
+" __END__
 " vim: foldmethod=marker

lang/vim/ku/trunk/doc/ku.txt

@@ -64 +64 @@
 
 ku#default_key_mappings()                          *ku#default_key_mappings()*
-                        Define the following key mappings for the ku window
-                        to the current buffer.
+                        Define the following key mappings which are local to
+                        the current buffer.  If one of the following {lhs}s is
+                        already mapped to something, it will be overridden.
+                        Be careful about when to call this function.
 
                         Modes   {lhs}           {rhs} ~
@@ -96 +98 @@
                         for items of the type {type-name}.
 
+                        {type-name} may be '*fallback*', if so, the given
+                        action is defined as a fallback action for all types.
+                        This means that the fallback action {action-name} will
+                        be used if the action {action-name} is not defined for
+                        a type,
+
 ku#custom_key({type-name}, {key}, {new-action-name})    *ku#custom_key()*
                         Define {key} to do the action {new-action-name} for
@@ -160 +168 @@
 
 Initialization                                          *ku-initialization*
+                                                        *KuLoaded*
+        Most part of Ku isn't loaded until one of its functions or commands is
+        actually used.  After all part of Ku is loaded, "User KuLoaded" event
+        will be published.  Use this event to delay applying user's settings
+        until all part of Ku is loaded.
                                                         *KuBufferInitialize*
         Ku has its own buffer to do its work.  Whenever the buffer is created,
@@ -168 +181 @@
 <
         If there is no autocommand for |KuBufferInitialize|, Ku will call
-        |ku#default_key_mappings()|.
+        |ku#default_key_mappings()| to define some useful key mappings.
+        Otherwise, no key mapping will be defined.  So you have to call it
+        explicitly if you use |KuBufferInitialize|.
 
 Write New Type                                          *ku-write-new-type*
@@ -184 +199 @@
 
         'initialize'    funcref         (optional)
-                The function which will be called with no argument whenever
-                the ku window is opened.  The main purpose of this function is
-                to do some initialization for 'gather'.
+                The function which will be called whenever the ku window is
+                opened.  It's called with 1 argument which indicates the
+                timing of calling.  The possible values are:
+
+                'before-open'   before opening the |ku-buffer|
+                'after-open'    after opening the |ku-buffer|
+
+                The main purpose of this function is to do some initialization
+                for 'gather'.
 
         'keys'          dictionary