Commits

ZyX_I  committed 0622b00

Replaced some double strikes with single

  • Participants
  • Parent commits 4e9af11

Comments (0)

Files changed (17)

File autoload/frawor.vim

 let s:_functions+=['frawor#Reload']
 "▶1 frawor#Lockvar    :: p:, varnamelist → + :lockvar
 function frawor#Lockvar(s, nolock)
-    let nolock=split(a:nolock, ",")
+    let nolock=split(a:nolock, ',')
     for varname in filter(keys(a:s), 'index(nolock, v:val)==-1')
         lockvar! a:s[varname]
     endfor

File plugin/frawor.vim

         "   (split(...))                 split runtimepath on non-escaped «,»
         " → (last substitute)           unescape commas and backward slashes
         " → (last but one substitute)   expand ${VAR} using eval()
-        " → (fnamemodify(..., ":p"))    turn path into full
+        " → (fnamemodify(..., ':p'))    turn path into full
         " → (filter(..., isdirectory))  filter out existing directories
         " → (v:val[:-2])                remove trailing path separator (resolve
         "                               does not work with it)
 "▶1 newplugin       :: version, sid, file, dependencies, oneload, g → +s:pls,
 function s:F.newplugin(version, sid, file, dependencies, oneload, g)
     "▶2 Checking whether a:file is a string
-    if type(a:file)!=type("")
+    if type(a:file)!=type('')
         call s:_f.throw('filenotstr')
     elseif empty(a:file)
         call s:_f.throw('fileempty')
 " Returns a list of files that should be sourced to load plugin back
 function s:F.unloadplugin(plid)
     "▶2 Get plugdict
-    if type(a:plid)==type("")
+    if type(a:plid)==type('')
         let plid=s:F.expandplid(a:plid)
         if has_key(s:pls, plid)
             let plugdict=s:pls[plid]
         call s:_f.throw('nomessages', a:plugdict.id)
     elseif type(a:plugdict.g._messages)!=type({})
         call s:_f.throw('mesnotdct', a:plugdict.id)
-    elseif type(a:msgid)!=type("")
+    elseif type(a:msgid)!=type('')
         call s:_f.throw('mesnotstr', a:plugdict.id)
     elseif !has_key(a:plugdict.g._messages, a:msgid)
         call s:_f.throw('nomessage', a:plugdict.id, a:msgid)
     for msgline in split(message, "\n", 1)
         if empty(msgline)
             echohl None
-            echomsg " "
+            echomsg ' '
             echohl ErrorMsg
         else
             echomsg msgline

File plugin/frawor/autocommands.vim

 endif
 "▶1 wipeau       :: agname → + :autocmd
 function s:F.wipeau(agname)
-    execute "augroup ".a:agname
+    execute 'augroup' a:agname
         autocmd!
     augroup END
-    execute "augroup! ".a:agname
+    execute 'augroup!' a:agname
 endfunction
 "▶1 add_augroups :: {f} → + p:_augroups
 function s:F.add_augroups(plugdict, fdict)
 endfunction
 "▶2 createau     :: augroup → + :autocmd
 function s:F.createau(augroup)
-    execute "augroup ".a:augroup.agname
+    execute 'augroup' a:augroup.agname
         autocmd!
         for auargs in a:augroup.events
-            execute "autocmd ".auargs
+            execute 'autocmd' auargs
         endfor
     augroup END
 endfunction
             "▲3
             let [d.command; augroup.args[i]]=d.command
         endif
-        if exists("*d.command")
+        if exists('*d.command')
             let augroup.funcs[i]=d.command
             if has_key(augroup.args, i) && !empty(augroup.args[i])
                 let epc+=['call call(s:augroups.'.a:agid.'.funcs.'.i.', '.

File plugin/frawor/base64.vim

     return r
 endfunction
 "▶1 base64.decode      :: b64str[, bytearray::Bool] → str | bytearray
-let s:cd64=map(split("|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\\]^_`abcdefghijklmnopq",
+let s:cd64=map(split('|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\]^_`abcdefghijklmnopq',
             \              '\v.@='),
             \        'char2nr(v:val)')
 function s:F.base64.decode(str, ...)
 endfunction
 "▶1 base64.encode      :: str | bytearray → b64str
 let s:eqsigncode=char2nr('=')
-let s:cb64=map(split("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+let s:cb64=map(split('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
             \        '\v.@='), 'char2nr(v:val)')
 function s:F.base64.encode(str)
     let r=''

File plugin/frawor/commands.vim

                     \           ('+[s:commands.'.a:cmd.id.'.sp], ')).
                     \        '{}).curargs]'
     endif
-    execute      "function ".a:fname."(...)\n"
-                \"    return call(s:commands.".a:cmd.id.".fs.".a:fname[2:].", ".
+    execute      'function '.a:fname."(...)\n"
+                \'    return call(s:commands.'.a:cmd.id.'.fs.'.a:fname[2:].', '.
                 \                 args.", {})\n".
-                \"endfunction"
+                \'endfunction'
 endfunction
 "▶1 add_commands :: {f} → + p:_commands
 function s:F.add_commands(plugdict, fdict)

File plugin/frawor/decorators.vim

 let s:lastdeid=0
 function s:F.adddecorator(plugdict, fdict, deid, Decorator)
     "▶3 Check arguments
-    if type(a:deid)!=type("")
+    if type(a:deid)!=type('')
         call s:_f.throw('deidnstr', a:plugdict.id)
     elseif a:deid!~#'^\w\+$' && a:deid isnot# '_'
         call s:_f.throw('invdeid', a:plugdict.id, a:deid)

File plugin/frawor/decorators/altervars.vim

             call s:_f.throw('altelnlst', a:fname, plid, i)
         elseif empty(a:arg[i]) || len(a:arg[i])>2
             call s:_f.throw('altelinvlen', a:fname, plid, i, len(a:arg[i]))
-        elseif type(a:arg[i][0])!=type("")
+        elseif type(a:arg[i][0])!=type('')
             call s:_f.throw('altelnstr', a:fname, plid, i)
         endif
         "▲2
                             \   'endif',
                             \   'let '.varname.'=']
                 if type(element[1])==type(0) ||
-                            \(has("float") && type(element[1])==type(0.0) &&
+                            \(has('float') && type(element[1])==type(0.0) &&
                             \ string(element[1])!~'\w')
                     let preret[-1].=string(element[1])
                 else
-                    let preret[-1].=fpref."[".i."][1]"
+                    let preret[-1].=fpref.'['.i.'][1]'
                 endif
             else
                 call add(preret, 'endif')
         elseif varname[0] is# '+'
             "▶3 *args, varname
             let saveargs=''
-            let setargs=fpref."[".i."][1]"
+            let setargs=fpref.'['.i.'][1]'
             let set2args='@$@.'.i
             let varname=varname[1:]
             "▲3
                 call add(element, varname[(bidx+1):-2])
                 let varname=varname[:(bidx-1)]
                 let element[0]='+'.varname
-                let saveargs=fpref."[".i."][2]"
-                let setargs.=", ".saveargs
-                let set2args.=", ".saveargs
+                let saveargs=fpref.'['.i.'][2]'
+                let setargs.=', '.saveargs
+                let set2args.=', '.saveargs
                 "▶4 Check existance of special
                 if !has_key(s:ss, varname)
                     call s:_f.throw('usaver', a:fname, plid, i, varname)
 "▶2 addaltspecial   :: {f}, ssid, Saver::Funcref, Setter::Funcref[, ssopts] → +…
 function s:F.addaltspecial(plugdict, fdict, ssid, Saver, Setter, ...)
     "▶3 Check arguments
-    if type(a:ssid)!=type("")
+    if type(a:ssid)!=type('')
         call s:_f.throw('idnotstr', a:plugdict.id)
     elseif a:ssid!~#'^\h\w*$'
         call s:_f.throw('invid', a:plugdict.id, a:ssid)
     endif
     "▲3
     let ssdef={
-                \    "id": a:ssid,
-                \  "plid": a:plugdict.id,
-                \ "saver": s:F.refunction(a:plugdict.sid, a:Saver,
+                \    'id': a:ssid,
+                \  'plid': a:plugdict.id,
+                \ 'saver': s:F.refunction(a:plugdict.sid, a:Saver,
                 \                         'sssavuref', a:ssid, a:plugdict.id),
-                \"setter": s:F.refunction(a:plugdict.sid, a:Setter,
+                \'setter': s:F.refunction(a:plugdict.sid, a:Setter,
                 \                         'ssseturef', a:ssid, a:plugdict.id),
-                \"hasarg": 0,
+                \'hasarg': 0,
             \}
     if a:0
         if has_key(a:1, 'requiresarg')

File plugin/frawor/functions.vim

     "▲2
     let fname=a:fname
     let fdicts=s:{a:fundictsname}
-    let fundef =  {"id": printf('%x', fdicts.nextid),
-                \"name":   fname,
-                \"plid": a:plugdict.id,}
+    let fundef =  {'id': printf('%x', fdicts.nextid),
+                \'name':   fname,
+                \'plid': a:plugdict.id,}
     let fdicts.nextid+=1
     let fdicts[fundef.id]=fundef
     "▶2 Add `function' key
     let args='a:000'
     "▲2
     let fpref='s:'.a:fundictsname.'.'.fundef.id
-    let func=["function ".fname."(...)",
+    let func=['function '.fname.'(...)',
                 \'let _={"d": {}, "F": '.fpref.'.function}',
                 \]
     let decs=map(filter(keys(a:funopts), 'v:val[0] is# "@"'),
         if type(fblocks[-1])!=type([])
                     \|| len(fblocks[-1])!=6
                     \|| type(fblocks[-1][0])!=type(0)
-                    \|| type(fblocks[-1][1])!=type("")
+                    \|| type(fblocks[-1][1])!=type('')
                     \|| type(fblocks[-1][3])!=type([])
                     \|| type(fblocks[-1][4])!=type([])
                     \|| type(fblocks[-1][5])!=type(0)
     call sort(fblocks, function('s:Decsort'))
     let end=[]
     let d={}
-    let fvar="_.F"
+    let fvar='_.F'
     let pvarstart=fpref.'.decvars.'
     for [deid, pref, prior, newargs, d.privvar, preret, postret, rrv] in fblocks
         let pvar=pvarstart.deid
         let args=eval(s:nargsexpr)
     endfor
     if addedrval
-        let func +=  ["let _.r=call(".fvar.", ".args.", _.d)"]+end+
-                    \["return _.r",
-                    \ "endfunction"]
+        let func +=  ['let _.r=call('.fvar.', '.args.', _.d)']+end+
+                    \['return _.r',
+                    \ 'endfunction']
     else
-        let func +=  ["return call(".fvar.", ".args.", _.d)"]+end+
-                    \["endfunction"]
+        let func +=  ['return call('.fvar.', '.args.', _.d)']+end+
+                    \['endfunction']
     endif
     execute join(s:F.beatycode(func), "\n")
-    if fname isnot# "fundef.cons"
+    if fname isnot# 'fundef.cons'
         let fundef.cons=function(fname)
     endif
     return fundef
         if ((has_key(fundef, 'cons'))?
                     \(s:F.delfunction(a:plugdict.sid, fundef.cons)):
                     \(1))
-            for key in ["checker", "filter"]
+            for key in ['checker', 'filter']
                 if has_key(fundef, key)
                     call call(s:_f['del'.key], [fundef[key]], {})
                 endif

File plugin/frawor/fwc.vim

                 \'@%@', 's:FWCs.'.id.'.vars',     'g'),
                 \'@-@', 'variants',               'g'),
                 \'@$@', '',                       'g')."\n".
-            \"endfunction"
+            \'endfunction'
     let s:FWCs[id]=FWC
     return [FWC.f, id]
 endfunction

File plugin/frawor/fwc/intfuncs.vim

 function s:r.bool.check(desc, idx, type)
     let curargstr=self.argstr()
     if !has_key(self.vars, 'bool')
-        let self.vars.bool=((self.o.onlystrings)?(["0", "1"]):([0, 1]))
+        let self.vars.bool=((self.o.onlystrings)?(['0', '1']):([0, 1]))
     endif
     return self.nextthrow('index(@%@.bool, '.curargstr.')==-1',
                 \         'nbool', a:idx, 'string('.curargstr.')')

File plugin/frawor/lua.vim

 endif
 "▶1 s:haslua
 let s:haslua=0
-if (has("lua") || has("lua/dyn")) && exists(':lua')==2
+if (has('lua') || has('lua/dyn')) && exists(':lua')==2
     try
-        silent! lua vim.command("let s:haslua=1")
+        silent! lua vim.command('let s:haslua=1')
     catch
     endtry
 endif
             let s:addedpaths+=1
         else
             let s:addedpaths[dir]=1
-            lua package.path=package.path..vim.eval("pathstr")
+            lua package.path=package.path..vim.eval('pathstr')
         endif
         let a:fdict.imported=dir
         let a:fdict.pathstr=pathstr
         if s:addedpaths[a:fdict.imported]<=0
             unlet s:addedpaths[a:fdict.imported]
             let ppath=[]
-            lua vim.eval("add(ppath,"..string.format("%q", package.path)..")")
+            lua vim.eval('add(ppath,'..string.format('%q', package.path)..')')
             let importidx=stridx(ppath[0], a:fdict.pathstr)
             let importendidx=importidx+len(a:fdict.pathstr)
-            let ppath[0]=((importidx>0)?(ppath[0][:(importidx-1)]):("")).
+            let ppath[0]=((importidx>0)?(ppath[0][:(importidx-1)]):('')).
                         \ppath[0][(importendidx+1):]
-            lua package.path=vim.eval("ppath[0]")
+            lua package.path=vim.eval('ppath[0]')
         endif
     endif
 endfunction

File plugin/frawor/mappings.vim

         else
             let rhs=s:F.hsescape(a:mapdescr.rhs, a:mapdescr.sid)
         endif
-        execute mode.((a:mapdescr.noremap)?("nore"):("")).(a:mapdescr.type)
-                    \ ((a:mapdescr.silent)?("<silent>"):(""))
-                    \ "<special>"
-                    \ ((a:mapdescr.buffer)?("<buffer>"):(""))
-                    \ ((a:mapdescr.expr)?("<expr>"):(""))
+        execute mode.((a:mapdescr.noremap)?('nore'):('')).(a:mapdescr.type)
+                    \ ((a:mapdescr.silent)?('<silent>'):(''))
+                    \ '<special>'
+                    \ ((a:mapdescr.buffer)?('<buffer>'):(''))
+                    \ ((a:mapdescr.expr)?('<expr>'):(''))
                     \ lhs rhs
         if a:mapdescr.type is# 'menu' && has_key(a:mapdescr, 'tip')
             " Deletes text that appears on the right as it is not accepted by 
     let modes=s:F.modrewrite(a:mapdescr.mode, a:mapdescr.type)
     let lhs=s:F.hsescape(a:mapdescr.lhs, a:mapdescr.sid, a:mapdescr.type)
     for mode in modes
-        execute mode."un".(a:mapdescr.type)
-                    \ "<special>"
-                    \ ((a:mapdescr.buffer)?("<buffer>"):(""))
+        execute mode.'un'.(a:mapdescr.type)
+                    \ '<special>'
+                    \ ((a:mapdescr.buffer)?('<buffer>'):(''))
                     \ lhs
     endfor
 endfunction
         return 0
     endif
     for lhs in lhss
-        if lhs isnot 0 && type(lhs)!=type("")
+        if lhs isnot 0 && type(lhs)!=type('')
             call s:_f.warn('olhsnstr')
             return 0
         endif
 endfunction
 "▶1 leadchecker   :: leader → Bool
 function s:F.leadchecker(leader)
-    return (type(a:leader[0])==type("") || a:leader[0] is 0)
+    return (type(a:leader[0])==type('') || a:leader[0] is 0)
 endfunction
 "▶1 mapmgroup     :: mgroup, mlist, a:0::Bool → + s:mapped, s:bufmapped, :map
 let s:mapped={}
         unlet s:keystofeed
         return r
     endif
-    return ""
+    return ''
 endfunction
 "▶1 feedfunc      :: [key] → + s:keystofeed
 function s:F.feedfunc(keys)
-    let s:keystofeed=join(a:keys, "")
+    let s:keystofeed=join(a:keys, '')
 endfunction
 "▶1 maprun        :: mgid, mapname, mode, lhs → <expr> + ?
 let s:mapreplaces={'%lhs': 'a:lhs',
             \                         's:F.feedfunc)',
             \     '%mgid': 'a:mgid',
             \    '%mname': 'a:mapname',}
-let s:replaceexpr='type(v:val)=='.type("").' && has_key(s:mapreplaces, v:val)?'.
+let s:replaceexpr='type(v:val)=='.type('').' && has_key(s:mapreplaces, v:val)?'.
             \           'eval(s:mapreplaces[v:val]):'.
             \           'v:val'
 let s:modeopsuf={'i': "\<C-o>",
 function s:F.getstr(Strfunc, ...)
     "▶2 define variables
     "▶3 time and timeout
-    if &timeout && has("float") && has("reltime")
+    if &timeout && has('float') && has('reltime')
         let timeout=&timeoutlen/1000.0
         let time=reltime()
     endif
     let chars=[]     " :: [char]
     let args=[]      " (char) or (char, addarg)
     let laststatus=1
-    let r=[0, "", 0] " next character index, {gotstring}, {retvalue}
+    let r=[0, '', 0] " next character index, {gotstring}, {retvalue}
     "▲2
-    while ((exists("timeout"))?((eval(reltimestr(reltime(time))))<timeout):(1))
+    while ((exists('timeout'))?((eval(reltimestr(reltime(time))))<timeout):(1))
         if getchar(1) || laststatus==1
             let char=s:F.getchar()
             call add(chars, char)
             unlet addarg
             "▲2
             if laststatus==2
-                let r=[len(chars), join(chars, ""), retvalue]
+                let r=[len(chars), join(chars, ''), retvalue]
             elseif laststatus==0
                 break
             elseif laststatus==-1
                 endif
                 break
             elseif laststatus==3
-                let r=[len(chars), join(chars, ""), retvalue]
+                let r=[len(chars), join(chars, ''), retvalue]
                 break
             endif
             "▶2 Update `time' variable, unlet retvalue
-            if exists("time")
+            if exists('time')
                 let time=reltime()
             endif
             unlet retvalue
         if a:0
             call call(a:1, [chars[r[0]:]], {})
         else
-            call feedkeys(join(chars[r[0]:], ""))
+            call feedkeys(join(chars[r[0]:], ''))
         endif
     endif
     "▲2
 "▶2 mapgroup.map   :: {f}, mgid[, bufnr] + s:mgroups → + … (unmapmgroup)
 function s:F.mapgroup.map(plugdict, fdict, mgid, ...)
     "▶3 Check mgid
-    if type(a:mgid)!=type("")
+    if type(a:mgid)!=type('')
         call s:_f.throw('mmmgidnstr', a:plugdict.id)
     elseif !has_key(s:mgroups, a:mgid)
         call s:_f.throw('mmnomgid', a:mgid, a:plugdict.id)
 "▶2 mapgroup.unmap :: {f}, mgid[, bufnr] + s:mgroups → + … (unmapmgroup)
 function s:F.mapgroup.unmap(plugdict, fdict, mgid, ...)
     "▶3 Check mgid
-    if type(a:mgid)!=type("")
+    if type(a:mgid)!=type('')
         call s:_f.throw('ummgidnstr', a:plugdict.id)
     elseif !has_key(s:mgroups, a:mgid)
         call s:_f.throw('umnomgid', a:mgid, a:plugdict.id)
 let s:fts={}
 function s:F.mapgroup.add(plugdict, fdict, mgid, mappings, ...)
     "▶3 Check arguments
-    if type(a:mgid)!=type("")
+    if type(a:mgid)!=type('')
         call s:_f.throw('mgidnotstr', a:plugdict.id)
     elseif type(a:mappings)!=type({})
         call s:_f.throw('mapsndct', a:mgid, a:plugdict.id)
     if a:0
         if has_key(a:1, 'leader')
             "▶4 Check leader
-            if type(a:1.leader)!=type("") && a:1.leader isnot 0
+            if type(a:1.leader)!=type('') && a:1.leader isnot 0
                 call s:_f.throw('mleadnstr', mgid, a:plugdict.id)
             endif
             "▲4
         "▶4 string -> mapdescrdef (mode, type)
         for key in ['mode', 'type']
             if has_key(a:1, key)
-                if type(a:1[key])!=type("")
+                if type(a:1[key])!=type('')
                     call s:_f.throw('mg'.key.'nstr', mgid, a:plugdict.id)
                 endif
                 let mapdescrdef[key]=a:1[key]
             if !has_key(mapdescr, key)
                 let map[key]=mapdescrdef[key]
             else
-                if type(mapdescrdef[key])==type("")
+                if type(mapdescrdef[key])==type('')
                     let map[key]=mapdescr[key]
                 elseif type(mapdescr[key])!=type(0)
                     call s:_f.throw('mdnbool', mapname, mgid, a:plugdict.id,key)
             endif
         endfor
         "▶3 Check map keys
-        if map.lhs isnot 0 && type(map.lhs)!=type("")
+        if map.lhs isnot 0 && type(map.lhs)!=type('')
             call s:_f.throw('lhsnstr', mapname, mgid, a:plugdict.id)
-        elseif type(map.type)!=type("")
+        elseif type(map.type)!=type('')
             call s:_f.throw('mtypenstr', mapname, mgid, a:plugdict.id)
         elseif !has_key(s:maptypes, map.type)
             call s:_f.throw('invmtype', mapname, mgid, a:plugdict.id, map.type)
-        elseif (map.type is# 'abbr') && type(map.lhs)==type("") &&
-                    \type(mgroup.leader)==type("") &&
+        elseif (map.type is# 'abbr') && type(map.lhs)==type('') &&
+                    \type(mgroup.leader)==type('') &&
                     \((mgroup.leader).(map.lhs)!~#s:ablhsreg)
             call s:_f.throw('invabbrlhs', mapname, mgid, a:plugdict.id,
                         \                 (mgroup.leader).(map.lhs))
-        elseif type(map.mode)!=type("")
+        elseif type(map.mode)!=type('')
             call s:_f.throw('mmodenstr', mapname, mgid, a:plugdict.id)
         elseif (map.mode)!~#'^['.s:maptypes[(map.type)].']\+$'
             call s:_f.throw('invmode', mapname, mgid, a:plugdict.id, map.mode)
             let map.expr=0
             let map.buffer=0
             if has_key(mapdescr, 'tip')
-                if type(mapdescr.tip)!=type("")
+                if type(mapdescr.tip)!=type('')
                     call s:_f.throw('tipnstr', mapname, mgid, a:plugdict.id)
                 endif
                 let map.tip=mapdescr.tip
             let map.rhs=evalstr.'("s:F").maprun("'.mgroup.id.'", '.
                         \                      '"'.(map.id).'", %s)'
         "▶3 map.rhs :: String
-        elseif type(map.rhs)==type("")
+        elseif type(map.rhs)==type('')
             if empty(map.rhs)
-                let map.rhs="<Nop>"
+                let map.rhs='<Nop>'
             elseif has_key(map, 'strfunc')
                 let map.rhs=substitute((map.rhs), '%str',
                             \evalstr.'("s:F.getstr(s:mgroups.'.(mgroup.id).'.'.
         endif
         "▲3
         if map.expr
-            let map.rhs.=".(".evalstr.'("s:F.runfeed()"))'
+            let map.rhs.='.('.evalstr.'("s:F.runfeed()"))'
         endif
         "▶3 mapping option
         if !mgroup.nouser
 "▶2 mapgroup.del   :: {f}, mgid
 function s:F.mapgroup.del(plugdict, fdict, mgid)
     "▶3 Check mgid
-    if type(a:mgid)!=type("")
+    if type(a:mgid)!=type('')
         call s:_f.throw('dmmgidnstr', a:plugdict.id)
     elseif !has_key(s:mgroups, a:mgid)
         call s:_f.throw('dmnomgid', a:mgid, a:plugdict.id)

File plugin/frawor/options.vim

                 \'oprefnotstr': 'префикс не является строкой',
                 \ 'invoprefix': 'строка «%s» не может являться '.
                 \               'префиксом переменной',
-            \}, "'Ошибка получения настройки для дополнения %s: '.v:val")
+            \}, '"Ошибка получения настройки для дополнения %s: ".v:val')
     call extend(s:_messages, map({
                 \  'nooptions': 'глобальная переменная не содержит '.
                 \               'описания настроек (_options)',
                 \  'optnotstr': 'option name is not a String',
                 \'oprefnotstr': 'prefix is not a String',
                 \ 'invoprefix': 'string `%s'' is not a valid option prefix',
-            \}, "'Error while obtaining option for plugin %s: '.v:val")
+            \}, '"Error while obtaining option for plugin %s: ".v:val')
     call extend(s:_messages, map({
                 \  'nooptions': 'global variable does not contain _options',
                 \'_optnotdict': '_messages key value is not a Dictionary',
 function s:F.getoption(plugdict, fdict, oid, ...)
     "▶2 Check arguments
     if s:dochecks
-        if type(a:oid)!=type("")
+        if type(a:oid)!=type('')
             call s:_f.throw('optnotstr', a:plugdict.id)
         elseif !has_key(a:plugdict.g, '_options')
             call s:_f.throw('nooptions', a:oid, a:plugdict.id)
             endif
         endif
         "▶3 `checker' and `filter' keys
-        for key in ["checker", "filter"]
+        for key in ['checker', 'filter']
             if has_key(option, key)
                 let oshadow[key]=s:_f['cons'.key](option[key], a:plugdict.g)
             endif
     if !has_key(a:fdict, 'oprefix')
         if has_key(a:plugdict.g, '_oprefix')
             let oprefix=a:plugdict.g._oprefix
-            if type(oprefix)!=type("")
+            if type(oprefix)!=type('')
                 call s:_f.throw('oprefnotstr', a:plugdict.id)
             endif
         else
     endif
     "▶3 Get scopes
     if a:0
-        if type(a:1)!=type("")
+        if type(a:1)!=type('')
             call s:_f.throw('scopesanstr', a:oid, a:plugdict.id)
         elseif a:1!~#'^[wtbg]\+$'
             call s:_f.throw('invscopesa', a:oid, a:plugdict.id, a:1)

File plugin/frawor/os.vim

 "▶1 os resource
 let s:os={}
 "▶2 os.fullname
-for s:os.fullname in ["unix", "win16", "win32", "win64", "win32unix", "win95",
-            \         "mac", "macunix", "amiga", "os2", "qnx", "beos", "vms"]
+for s:os.fullname in ['unix', 'win16', 'win32', 'win64', 'win32unix', 'win95',
+            \         'mac', 'macunix', 'amiga', 'os2', 'qnx', 'beos', 'vms']
     if has(s:os.fullname)
         break
     endif
 function s:os.chdir(path, ...)
     if s:os.path.isdir(a:path)
         try
-            execute ((a:0 && a:1)?("lcd"):("cd")) fnameescape(a:path)
+            execute ((a:0 && a:1)?('lcd'):('cd')) fnameescape(a:path)
             return 1
         catch
             return 0
     endtry
 endfunction
 "▶2 mkdir, makedirs
-if exists("*mkdir")
+if exists('*mkdir')
     "▶3 os.makedirs       :: path[, mode] → Bool + FS
     function s:os.makedirs(path, ...)
         let mode=get(a:000, 0, 0755)
             return 0
         endif
         try
-            call mkdir(a:path, "", mode)
+            call mkdir(a:path, '', mode)
             return 1
         catch
             return 0
     if !(s:os.path.isdir(path) && empty(s:os.listdir(path)))
         return 0
     endif
-    if s:os.name is# "posix"
-        if executable("rmdir")
-            return !s:os.run(["rmdir", path])
-        elseif executable("rm") && empty(s:os.listdir(path))
-            return !s:os.run(["rm", "-r", path])
+    if s:os.name is# 'posix'
+        if executable('rmdir')
+            return !s:os.run(['rmdir', path])
+        elseif executable('rm') && empty(s:os.listdir(path))
+            return !s:os.run(['rm', '-r', path])
         endif
-    elseif s:os.name is# "nt"
+    elseif s:os.name is# 'nt'
         " For some reason |executable()| function does not work
-        return ((!s:os.run(["rmdir", path])) || (!s:os.run(["deltree", path])))
+        return ((!s:os.run(['rmdir', path])) || (!s:os.run(['deltree', path])))
     endif
     return 0
 endfunction
 "▶2 os.removedirs     :: path → UInt + FS
 function s:os.removedirs(path)
     let path=s:os.path.normpath(a:path)
-    let prevpath=""
+    let prevpath=''
     let i=0
     while path isnot# '.' && path isnot# prevpath && s:os.rmdir(path)
         let prevpath=path

File plugin/frawor/perl.vim

 endif
 "▶1 s:hasperl
 let s:hasperl=0
-if (has("perl") || has("perl/dyn")) && exists(':perl')==2
+if (has('perl') || has('perl/dyn')) && exists(':perl')==2
     try
-        silent! perl VIM::DoCommand("let s:hasperl=1")
+        silent! perl VIM::DoCommand('let s:hasperl=1')
     catch
     endtry
 endif
             let s:addedpaths+=1
         else
             let s:addedpaths[dir]=1
-            perl push @INC, [VIM::Eval("dir")]->[1];
+            perl push @INC, [VIM::Eval('dir')]->[1];
         endif
         let a:fdict.imported=dir
     endif
         let s:addedpaths[a:fdict.imported]-=1
         if s:addedpaths[a:fdict.imported]<=0
             unlet s:addedpaths[a:fdict.imported]
-            perl @INC=(grep {$_ ne VIM::Eval("a:fdict.imported")} @INC);
+            perl @INC=(grep {$_ ne VIM::Eval('a:fdict.imported')} @INC);
         endif
     endif
 endfunction

File plugin/frawor/ruby.vim

 endif
 "▶1 s:hasruby
 let s:hasruby=0
-if (has("ruby") || has("ruby/dyn")) && exists(':ruby')==2
+if (has('ruby') || has('ruby/dyn')) && exists(':ruby')==2
     try
-        silent! ruby VIM::command("let s:hasruby=1")
+        silent! ruby VIM::command('let s:hasruby=1')
     catch
     endtry
 endif
             let s:addedpaths+=1
         else
             let s:addedpaths[dir]=1
-            ruby $LOAD_PATH << VIM::evaluate("dir")
+            ruby $LOAD_PATH << VIM::evaluate('dir')
         endif
         let a:fdict.imported=dir
     endif
         let s:addedpaths[a:fdict.imported]-=1
         if s:addedpaths[a:fdict.imported]<=0
             unlet s:addedpaths[a:fdict.imported]
-            ruby $LOAD_PATH.delete(VIM::evaluate("a:fdict.imported"))
+            ruby $LOAD_PATH.delete(VIM::evaluate('a:fdict.imported'))
         endif
     endif
 endfunction

File plugin/frawor/tcl.vim

 endif
 "▶1 s:hastcl
 let s:hastcl=0
-if has("tcl") && exists(':tcl')==2
+if has('tcl') && exists(':tcl')==2
     try
-        silent! tcl ::vim::command "let s:hastcl=1"
+        silent! tcl ::vim::command 'let s:hastcl=1'
     catch
     endtry
 endif
             let s:addedpaths+=1
         else
             let s:addedpaths[dir]=1
-            tcl lappend auto_path [::vim::expr "dir"] ; list
+            tcl lappend auto_path [::vim::expr 'dir'] ; list
         endif
         let a:fdict.imported=dir
     endif
                         \ [lreplace $auto_path
                         \ {*}[lrepeat 2
                         \ [lsearch -exact $auto_path
-                        \ [::vim::expr "a:fdict.imported"]]]] ; list
+                        \ [::vim::expr 'a:fdict.imported']]]] ; list
         endif
     endif
 endfunction