Coverage for config.py: 87%

1"""idlelib.config -- Manage IDLE configuration information. 

2 

3The comments at the beginning of config-main.def describe the 

4configuration files and the design implemented to update user 

5configuration information. In particular, user configuration choices 

6which duplicate the defaults will be removed from the user's 

7configuration files, and if a user file becomes empty, it will be 

8deleted. 

9 

10The configuration database maps options to values. Conceptually, the 

11database keys are tuples (config-type, section, item). As implemented, 

12there are separate dicts for default and user values. Each has 

13config-type keys 'main', 'extensions', 'highlight', and 'keys'. The 

14value for each key is a ConfigParser instance that maps section and item 

15to values. For 'main' and 'extensions', user values override 

16default values. For 'highlight' and 'keys', user sections augment the 

17default sections (and must, therefore, have distinct names). 

18 

19Throughout this module there is an emphasis on returning usable defaults 

20when a problem occurs in returning a requested configuration value back to 

21idle. This is to allow IDLE to continue to function in spite of errors in 

22the retrieval of config information. When a default is returned instead of 

23a requested config value, a message is printed to stderr to aid in 

24configuration problem notification and resolution. 

25""" 

26# TODOs added Oct 2014, tjr 

27 

28from configparser import ConfigParser (empty)

29import os (empty)

30import sys (empty)

31 

32from tkinter.font import Font (empty)

33import idlelib (empty)

34 

35class InvalidConfigType(Exception): pass (empty)

36class InvalidConfigSet(Exception): pass (empty)

37class InvalidTheme(Exception): pass (empty)

38 

39class IdleConfParser(ConfigParser): (empty)

40 """ 

41 A ConfigParser specialised for idle configuration file handling 

42 """ 

43 def __init__(self, cfgFile, cfgDefaults=None): (empty)

44 """ 

45 cfgFile - string, fully specified configuration file name 

46 """ 

47 self.file = cfgFile # This is currently '' when testing. 29 ctx1aNTLYIngpflRhuemEvJAHOwXDGKqF

48 ConfigParser.__init__(self, defaults=cfgDefaults, strict=False) 29 ctx1aNTLYIngpflRhuemEvJAHOwXDGKqF

49 

50 def Get(self, section, option, type=None, default=None, raw=False): (empty)

51 """ 

52 Get an option value for given section/option or return default. 

53 If type is specified, return as type. 

54 """ 

55 # TODO Use default as fallback, at least if not None 

56 # Should also print Warning(file, section, option). 

57 # Currently may raise ValueError 

58 if not self.has_option(section, option): 29 ctx1aBsxortyNLngpflbdichuemvAwFQP

59 return default 2 ctx1Nh

60 if type == 'bool': 29 ctx1aBsxortyNLngpflbdichuemvAwFQP

61 return self.getboolean(section, option) 17 ctx1asxortyNnflbdiceQ

62 elif type == 'int': 27 ctx1aBsxortyNLngpflbdchuemvAwFP

63 return self.getint(section, option) 4 ctx1aNmP

64 else: 

65 return self.get(section, option, raw=raw) 26 ctx1aBsxortyNLngpflbdchuemvAwF

66 

67 def GetOptionList(self, section): (empty)

68 "Return a list of options for given section, else []." 

69 if self.has_section(section): 11 ctx1TLgbdceADGq

70 return self.options(section) 11 ctx1TLgbdceADGq

71 else: #return a default value 

72 return [] 1 ctx1T

73 

74 def Load(self): (empty)

75 "Load the configuration file from disk." 

76 if self.file: 4 ctx1aLYA

77 self.read(self.file) 3 ctx1aLA

78 

79class IdleUserConfParser(IdleConfParser): (empty)

80 """ 

81 IdleConfigParser specialised for user configuration handling. 

82 """ 

83 

84 def SetOption(self, section, option, value): (empty)

85 """Return True if option is added or changed to value, else False. 

86 

87 Add section if required. False means option already had value. 

88 """ 

89 if self.has_option(section, option): 12 ctx1CjkBghwDGKqF

90 if self.get(section, option) == value: 3 ctx1jBF

91 return False 3 ctx1jBF

92 else: 

93 self.set(section, option, value) 1 ctx1F

94 return True 1 ctx1F

95 else: 

96 if not self.has_section(section): 12 ctx1CjkBghwDGKqF

97 self.add_section(section) 9 ctx1CjkBhwDGF

98 self.set(section, option, value) 12 ctx1CjkBghwDGKqF

99 return True 12 ctx1CjkBghwDGKqF

100 

101 def RemoveOption(self, section, option): (empty)

102 """Return True if option is removed from section, else False. 

103 

104 False if either section does not exist or did not have option. 

105 """ 

106 if self.has_section(section): 2 ctx1BK

107 return self.remove_option(section, option) 2 ctx1BK

108 return False 1 ctx1K

109 

110 def AddSection(self, section): (empty)

111 "If section doesn't exist, add it." 

112 if not self.has_section(section): 5 ctx1XDGKq

113 self.add_section(section) 5 ctx1XDGKq

114 

115 def RemoveEmptySections(self): (empty)

116 "Remove any sections that have no options." 

117 for section in self.sections(): 3 ctx1DGq

118 if not self.GetOptionList(section): 3 ctx1DGq

119 self.remove_section(section) 2 ctx1DG

120 

121 def IsEmpty(self): (empty)

122 "Return True if no sections after removing empty sections." 

123 self.RemoveEmptySections() 2 ctx1Dq

124 return not self.sections() 2 ctx1Dq

125 

126 def Save(self): (empty)

127 """Update user configuration file. 

128 

129 If self not empty after removing empty sections, write the file 

130 to disk. Otherwise, remove the file from disk if it exists. 

131 """ 

132 fname = self.file 4 ctx1Cjkq

133 if fname and fname[0] != '#': 4 ctx1Cjkq

134 if not self.IsEmpty(): 1 ctx1q

135 try: 1 ctx1q

136 cfgFile = open(fname, 'w') 1 ctx1q

137 except OSError: 

138 os.unlink(fname) 

139 cfgFile = open(fname, 'w') 

140 with cfgFile: 1 ctx1q

141 self.write(cfgFile) 1 ctx1q

142 elif os.path.exists(self.file): 142 ↛ exitline 142 didn't return from function 'Save', because the condition on line 142 was never false1 ctx1q

143 os.remove(self.file) 1 ctx1q

144 

145class IdleConf: (empty)

146 """Hold config parsers for all idle config files in singleton instance. 

147 

148 Default config files, self.defaultCfg -- 

149 for config_type in self.config_types: 

150 (idle install dir)/config-{config-type}.def 

151 

152 User config files, self.userCfg -- 

153 for config_type in self.config_types: 

154 (user home dir)/.idlerc/config-{config-type}.cfg 

155 """ 

156 def __init__(self, _utest=False): (empty)

157 self.config_types = ('main', 'highlight', 'keys', 'extensions') 21 ctx1aInMgpflRhuemEvzJAHOw

158 self.defaultCfg = {} 21 ctx1aInMgpflRhuemEvzJAHOw

159 self.userCfg = {} 21 ctx1aInMgpflRhuemEvzJAHOw

160 self.cfg = {} # TODO use to select userCfg vs defaultCfg 21 ctx1aInMgpflRhuemEvzJAHOw

161 # self.blink_off_time = <first editor text>['insertofftime'] 

162 # See https:/bugs.python.org/issue4630, msg356516. 

163 

164 if not _utest: 21 ctx1aInMgpflRhuemEvzJAHOw

165 self.CreateConfigHandlers() (empty)

166 self.LoadCfgFiles() (empty)

167 

168 def CreateConfigHandlers(self): (empty)

169 "Populate default and user config parser dictionaries." 

170 idledir = os.path.dirname(__file__) 2 ctx1aI

171 self.userdir = userdir = '' if idlelib.testing else self.GetUserCfgDir() 2 ctx1aI

172 for cfg_type in self.config_types: 2 ctx1aI

173 self.defaultCfg[cfg_type] = IdleConfParser( 2 ctx1aI

174 os.path.join(idledir, f'config-{cfg_type}.def')) 

175 self.userCfg[cfg_type] = IdleUserConfParser( 2 ctx1aI

176 os.path.join(userdir or '#', f'config-{cfg_type}.cfg')) 

177 

178 def GetUserCfgDir(self): (empty)

179 """Return a filesystem directory for storing user config files. 

180 

181 Creates it if required. 

182 """ 

183 cfgDir = '.idlerc' 2 ctx1az

184 userDir = os.path.expanduser('~') 2 ctx1az

185 if userDir != '~': # expanduser() found user home dir 2 ctx1az

186 if not os.path.exists(userDir): 186 ↛ 187line 186 didn't jump to line 187, because the condition on line 186 was never true2 ctx1az

187 if not idlelib.testing: 

188 warn = ('\n Warning: os.path.expanduser("~") points to\n ' + 

189 userDir + ',\n but the path does not exist.') 

190 try: 

191 print(warn, file=sys.stderr) 

192 except OSError: 

193 pass 

194 userDir = '~' 

195 if userDir == "~": # still no path to home! 2 ctx1az

196 # traditionally IDLE has defaulted to os.getcwd(), is this adequate? 

197 userDir = os.getcwd() 1 ctx1z

198 userDir = os.path.join(userDir, cfgDir) 2 ctx1az

199 if not os.path.exists(userDir): 2 ctx1az

200 try: 1 ctx1z

201 os.mkdir(userDir) 1 ctx1z

202 except OSError: 1 ctx1z

203 if not idlelib.testing: 203 ↛ 204line 203 didn't jump to line 204, because the condition on line 203 was never true1 ctx1z

204 warn = ('\n Warning: unable to create user config directory\n' + 

205 userDir + '\n Check path and permissions.\n Exiting!\n') 

206 try: 

207 print(warn, file=sys.stderr) 

208 except OSError: 

209 pass 

210 raise SystemExit 1 ctx1z

211 # TODO continue without userDIr instead of exit 

212 return userDir 2 ctx1az

213 

214 def GetOption(self, configType, section, option, default=None, type=None, (empty)

215 warn_on_default=True, raw=False): 

216 """Return a value for configType section option, or default. 

217 

218 If type is not None, return a value of that type. Also pass raw 

219 to the config parser. First try to return a valid value 

220 (including type) from a user configuration. If that fails, try 

221 the default configuration. If that fails, return default, with a 

222 default of None. 

223 

224 Warn if either user or default configurations have an invalid value. 

225 Warn if default is returned and warn_on_default is True. 

226 """ 

227 try: 21 ctx1asxortynpflbdicuemwQP

228 if self.userCfg[configType].has_option(section, option): 21 ctx1asxortynpflbdicuemwQP

229 return self.userCfg[configType].Get(section, option, 18 ctx1sxortynpflbdicuemw

230 type=type, raw=raw) 

231 except ValueError: 1 ctx1m

232 warning = ('\n Warning: config.py - IdleConf.GetOption -\n' 1 ctx1m

233 ' invalid %r value for configuration option %r\n' 

234 ' from section %r: %r' % 

235 (type, option, section, 

236 self.userCfg[configType].Get(section, option, raw=raw))) 

237 _warn(warning, configType, section, option) 1 ctx1m

238 try: 12 ctx1aorbdicuemQP

239 if self.defaultCfg[configType].has_option(section,option): 12 ctx1aorbdicuemQP

240 return self.defaultCfg[configType].Get( 11 ctx1aorbdicemQP

241 section, option, type=type, raw=raw) 

242 except ValueError: 1 ctx1m

243 pass 1 ctx1m

244 #returning default, print warning 

245 if warn_on_default: 2 ctx1um

246 warning = ('\n Warning: config.py - IdleConf.GetOption -\n' 1 ctx1m

247 ' problem retrieving configuration option %r\n' 

248 ' from section %r.\n' 

249 ' returning default value: %r' % 

250 (option, section, default)) 

251 _warn(warning, configType, section, option) 1 ctx1m

252 return default 2 ctx1um

253 

254 def SetOption(self, configType, section, option, value): (empty)

255 """Set section option to value in user config file.""" 

256 self.userCfg[configType].SetOption(section, option, value) 2 ctx1hw

257 

258 def GetSectionList(self, configSet, configType): (empty)

259 """Return sections for configSet configType configuration. 

260 

261 configSet must be either 'user' or 'default' 

262 configType must be in self.config_types. 

263 """ 

264 if not (configType in self.config_types): 9 ctx1afbdiceEH

265 raise InvalidConfigType('Invalid configType specified') 1 ctx1E

266 if configSet == 'user': 9 ctx1afbdiceEH

267 cfgParser = self.userCfg[configType] 8 ctx1afbdiceE

268 elif configSet == 'default': 9 ctx1afbdiceEH

269 cfgParser=self.defaultCfg[configType] 9 ctx1afbdiceEH

270 else: 

271 raise InvalidConfigSet('Invalid configSet specified') 1 ctx1E

272 return cfgParser.sections() 9 ctx1afbdiceEH

273 

274 def GetHighlight(self, theme, element): (empty)

275 """Return dict of theme element highlight colors. 

276 

277 The keys are 'foreground' and 'background'. The values are 

278 tkinter color strings for configuring backgrounds and tags. 

279 """ 

280 cfg = ('default' if self.defaultCfg['highlight'].has_section(theme) 2 ctx1ah

281 else 'user') 

282 theme_dict = self.GetThemeDict(cfg, theme) 2 ctx1ah

283 fore = theme_dict[element + '-foreground'] 2 ctx1ah

284 if element == 'cursor': 2 ctx1ah

285 element = 'normal' 1 ctx1h

286 back = theme_dict[element + '-background'] 2 ctx1ah

287 return {"foreground": fore, "background": back} 2 ctx1ah

288 

289 def GetThemeDict(self, type, themeName): (empty)

290 """Return {option:value} dict for elements in themeName. 

291 

292 type - string, 'default' or 'user' theme type 

293 themeName - string, theme name 

294 Values are loaded over ultimate fallback defaults to guarantee 

295 that all theme elements are present in a newly created theme. 

296 """ 

297 if type == 'user': 3 ctx1ahv

298 cfgParser = self.userCfg['highlight'] 2 ctx1hv

299 elif type == 'default': 3 ctx1ahv

300 cfgParser = self.defaultCfg['highlight'] 3 ctx1ahv

301 else: 

302 raise InvalidTheme('Invalid theme type specified') 1 ctx1v

303 # Provide foreground and background colors for each theme 

304 # element (other than cursor) even though some values are not 

305 # yet used by idle, to allow for their use in the future. 

306 # Default values are generally black and white. 

307 # TODO copy theme from a class attribute. 

308 theme ={'normal-foreground':'#000000', 3 ctx1ahv

309 'normal-background':'#ffffff', 

310 'keyword-foreground':'#000000', 

311 'keyword-background':'#ffffff', 

312 'builtin-foreground':'#000000', 

313 'builtin-background':'#ffffff', 

314 'comment-foreground':'#000000', 

315 'comment-background':'#ffffff', 

316 'string-foreground':'#000000', 

317 'string-background':'#ffffff', 

318 'definition-foreground':'#000000', 

319 'definition-background':'#ffffff', 

320 'hilite-foreground':'#000000', 

321 'hilite-background':'gray', 

322 'break-foreground':'#ffffff', 

323 'break-background':'#000000', 

324 'hit-foreground':'#ffffff', 

325 'hit-background':'#000000', 

326 'error-foreground':'#ffffff', 

327 'error-background':'#000000', 

328 'context-foreground':'#000000', 

329 'context-background':'#ffffff', 

330 'linenumber-foreground':'#000000', 

331 'linenumber-background':'#ffffff', 

332 #cursor (only foreground can be set) 

333 'cursor-foreground':'#000000', 

334 #shell window 

335 'stdout-foreground':'#000000', 

336 'stdout-background':'#ffffff', 

337 'stderr-foreground':'#000000', 

338 'stderr-background':'#ffffff', 

339 'console-foreground':'#000000', 

340 'console-background':'#ffffff', 

341 } 

342 for element in theme: 3 ctx1ahv

343 if not (cfgParser.has_option(themeName, element) or 3 ctx1ahv

344 # Skip warning for new elements. 

345 element.startswith(('context-', 'linenumber-'))): 

346 # Print warning that will return a default color 

347 warning = ('\n Warning: config.IdleConf.GetThemeDict' 1 ctx1h

348 ' -\n problem retrieving theme element %r' 

349 '\n from theme %r.\n' 

350 ' returning default color: %r' % 

351 (element, themeName, theme[element])) 

352 _warn(warning, 'highlight', themeName, element) 1 ctx1h

353 theme[element] = cfgParser.Get( 3 ctx1ahv

354 themeName, element, default=theme[element]) 

355 return theme 3 ctx1ahv

356 

357 def CurrentTheme(self): (empty)

358 "Return the name of the currently active text color theme." 

359 return self.current_colors_and_keys('Theme') 2 ctx1al

360 

361 def CurrentKeys(self): (empty)

362 """Return the name of the currently active key set.""" 

363 return self.current_colors_and_keys('Keys') 6 ctx1aflbdc

364 

365 def current_colors_and_keys(self, section): (empty)

366 """Return the currently active name for Theme or Keys section. 

367 

368 idlelib.config-main.def ('default') includes these sections 

369 

370 [Theme] 

371 default= 1 

372 name= IDLE Classic 

373 name2= 

374 

375 [Keys] 

376 default= 1 

377 name= 

378 name2= 

379 

380 Item 'name2', is used for built-in ('default') themes and keys 

381 added after 2015 Oct 1 and 2016 July 1. This kludge is needed 

382 because setting 'name' to a builtin not defined in older IDLEs 

383 to display multiple error messages or quit. 

384 See https://bugs.python.org/issue25313. 

385 When default = True, 'name2' takes precedence over 'name', 

386 while older IDLEs will just use name. When default = False, 

387 'name2' may still be set, but it is ignored. 

388 """ 

389 cfgname = 'highlight' if section == 'Theme' else 'keys' 13 ctx1asxortynflbdc

390 default = self.GetOption('main', section, 'default', 13 ctx1asxortynflbdc

391 type='bool', default=True) 

392 name = '' 13 ctx1asxortynflbdc

393 if default: 13 ctx1asxortynflbdc

394 name = self.GetOption('main', section, 'name2', default='') 11 ctx1asxornflbdc

395 if not name: 13 ctx1asxortynflbdc

396 name = self.GetOption('main', section, 'name', default='') 11 ctx1aortynflbdc

397 if name: 13 ctx1asxortynflbdc

398 source = self.defaultCfg if default else self.userCfg 9 ctx1asxortynl

399 if source[cfgname].has_section(name): 9 ctx1asxortynl

400 return name 9 ctx1asxortynl

401 return "IDLE Classic" if section == 'Theme' else self.default_keys() 12 ctx1asxortyflbdc

402 

403 @staticmethod (empty)

404 def default_keys(): (empty)

405 if sys.platform[:3] == 'win': 10 ctx1asotMflbdc

406 return 'IDLE Classic Windows' 1 ctx1M

407 elif sys.platform == 'darwin': 10 ctx1asotMflbdc

408 return 'IDLE Classic OSX' 9 ctx1asotMlbdc

409 else: 

410 return 'IDLE Modern Unix' 2 ctx1Mf

411 

412 def GetExtensions(self, active_only=True, (empty)

413 editor_only=False, shell_only=False): 

414 """Return extensions in default and user config-extensions files. 

415 

416 If active_only True, only return active (enabled) extensions 

417 and optionally only editor or shell extensions. 

418 If active_only False, return all extensions. 

419 """ 

420 extns = self.RemoveKeyBindNames( 7 ctx1afbdice

421 self.GetSectionList('default', 'extensions')) 

422 userExtns = self.RemoveKeyBindNames( 7 ctx1afbdice

423 self.GetSectionList('user', 'extensions')) 

424 for extn in userExtns: 7 ctx1afbdice

425 if extn not in extns: #user has added own extension 6 ctx1fbdice

426 extns.append(extn) 1 ctx1i

427 for extn in ('AutoComplete','CodeContext', 7 ctx1afbdice

428 'FormatParagraph','ParenMatch'): 

429 extns.remove(extn) 7 ctx1afbdice

430 # specific exclusions because we are storing config for mainlined old 

431 # extensions in config-extensions.def for backward compatibility 

432 if active_only: 7 ctx1afbdice

433 activeExtns = [] 7 ctx1afbdice

434 for extn in extns: 7 ctx1afbdice

435 if self.GetOption('extensions', extn, 'enable', default=True, 7 ctx1afbdice

436 type='bool'): 

437 #the extension is enabled 

438 if editor_only or shell_only: # TODO both True contradict 5 ctx1bdice

439 if editor_only: 1 ctx1i

440 option = "enable_editor" 1 ctx1i

441 else: 

442 option = "enable_shell" 1 ctx1i

443 if self.GetOption('extensions', extn,option, 1 ctx1i

444 default=True, type='bool', 

445 warn_on_default=False): 

446 activeExtns.append(extn) 1 ctx1i

447 else: 

448 activeExtns.append(extn) 5 ctx1bdice

449 return activeExtns 7 ctx1afbdice

450 else: 

451 return extns 2 ctx1ic

452 

453 def RemoveKeyBindNames(self, extnNameList): (empty)

454 "Return extnNameList with keybinding section names removed." 

455 return [n for n in extnNameList if not n.endswith(('_bindings', '_cfgBindings'))] 8 ctx1afbdiceH

456 

457 def GetExtnNameForEvent(self, virtualEvent): (empty)

458 """Return the name of the extension binding virtualEvent, or None. 

459 

460 virtualEvent - string, name of the virtual event to test for, 

461 without the enclosing '<< >>' 

462 """ 

463 extName = None 1 ctx1c

464 vEvent = '<<' + virtualEvent + '>>' 1 ctx1c

465 for extn in self.GetExtensions(active_only=0): 1 ctx1c

466 for event in self.GetExtensionKeys(extn): 1 ctx1c

467 if event == vEvent: 1 ctx1c

468 extName = extn # TODO return here? 1 ctx1c

469 return extName 1 ctx1c

470 

471 def GetExtensionKeys(self, extensionName): (empty)

472 """Return dict: {configurable extensionName event : active keybinding}. 

473 

474 Events come from default config extension_cfgBindings section. 

475 Keybindings come from GetCurrentKeySet() active key dict, 

476 where previously used bindings are disabled. 

477 """ 

478 keysName = extensionName + '_cfgBindings' 3 ctx1bdc

479 activeKeys = self.GetCurrentKeySet() 3 ctx1bdc

480 extKeys = {} 3 ctx1bdc

481 if self.defaultCfg['extensions'].has_section(keysName): 3 ctx1bdc

482 eventNames = self.defaultCfg['extensions'].GetOptionList(keysName) 3 ctx1bdc

483 for eventName in eventNames: 3 ctx1bdc

484 event = '<<' + eventName + '>>' 3 ctx1bdc

485 binding = activeKeys[event] 3 ctx1bdc

486 extKeys[event] = binding 3 ctx1bdc

487 return extKeys 3 ctx1bdc

488 

489 def __GetRawExtensionKeys(self,extensionName): (empty)

490 """Return dict {configurable extensionName event : keybinding list}. 

491 

492 Events come from default config extension_cfgBindings section. 

493 Keybindings list come from the splitting of GetOption, which 

494 tries user config before default config. 

495 """ 

496 keysName = extensionName+'_cfgBindings' 4 ctx1bdce

497 extKeys = {} 4 ctx1bdce

498 if self.defaultCfg['extensions'].has_section(keysName): 498 ↛ 505line 498 didn't jump to line 505, because the condition on line 498 was never false4 ctx1bdce

499 eventNames = self.defaultCfg['extensions'].GetOptionList(keysName) 4 ctx1bdce

500 for eventName in eventNames: 4 ctx1bdce

501 binding = self.GetOption( 4 ctx1bdce

502 'extensions', keysName, eventName, default='').split() 

503 event = '<<' + eventName + '>>' 4 ctx1bdce

504 extKeys[event] = binding 4 ctx1bdce

505 return extKeys 4 ctx1bdce

506 

507 def GetExtensionBindings(self, extensionName): (empty)

508 """Return dict {extensionName event : active or defined keybinding}. 

509 

510 Augment self.GetExtensionKeys(extensionName) with mapping of non- 

511 configurable events (from default config) to GetOption splits, 

512 as in self.__GetRawExtensionKeys. 

513 """ 

514 bindsName = extensionName + '_bindings' 1 ctx1b

515 extBinds = self.GetExtensionKeys(extensionName) 1 ctx1b

516 #add the non-configurable bindings 

517 if self.defaultCfg['extensions'].has_section(bindsName): 1 ctx1b

518 eventNames = self.defaultCfg['extensions'].GetOptionList(bindsName) 1 ctx1b

519 for eventName in eventNames: 1 ctx1b

520 binding = self.GetOption( 1 ctx1b

521 'extensions', bindsName, eventName, default='').split() 

522 event = '<<' + eventName + '>>' 1 ctx1b

523 extBinds[event] = binding 1 ctx1b

524 

525 return extBinds 1 ctx1b

526 

527 def GetKeyBinding(self, keySetName, eventStr): (empty)

528 """Return the keybinding list for keySetName eventStr. 

529 

530 keySetName - name of key binding set (config-keys section). 

531 eventStr - virtual event, including brackets, as in '<<event>>'. 

532 """ 

533 eventName = eventStr[2:-2] #trim off the angle brackets 8 ctx1apfbdcue

534 binding = self.GetOption('keys', keySetName, eventName, default='', 8 ctx1apfbdcue

535 warn_on_default=False).split() 

536 return binding 8 ctx1apfbdcue

537 

538 def GetCurrentKeySet(self): (empty)

539 "Return CurrentKeys with 'darwin' modifications." 

540 result = self.GetKeySet(self.CurrentKeys()) 5 ctx1afbdc

541 

542 if sys.platform == "darwin": 5 ctx1afbdc

543 # macOS (OS X) Tk variants do not support the "Alt" 

544 # keyboard modifier. Replace it with "Option". 

545 # TODO (Ned?): the "Option" modifier does not work properly 

546 # for Cocoa Tk and XQuartz Tk so we should not use it 

547 # in the default 'OSX' keyset. 

548 for k, v in result.items(): 4 ctx1abdc

549 v2 = [ x.replace('<Alt-', '<Option-') for x in v ] 4 ctx1abdc

550 if v != v2: 550 ↛ 551line 550 didn't jump to line 551, because the condition on line 550 was never true4 ctx1abdc

551 result[k] = v2 

552 

553 return result 5 ctx1afbdc

554 

555 def GetKeySet(self, keySetName): (empty)

556 """Return event-key dict for keySetName core plus active extensions. 

557 

558 If a binding defined in an extension is already in use, the 

559 extension binding is disabled by being set to '' 

560 """ 

561 keySet = self.GetCoreKeys(keySetName) 6 ctx1afbdce

562 activeExtns = self.GetExtensions(active_only=1) 6 ctx1afbdce

563 for extn in activeExtns: 6 ctx1afbdce

564 extKeys = self.__GetRawExtensionKeys(extn) 4 ctx1bdce

565 if extKeys: #the extension defines keybindings 565 ↛ 563line 565 didn't jump to line 563, because the condition on line 565 was never false4 ctx1bdce

566 for event in extKeys: 4 ctx1bdce

567 if extKeys[event] in keySet.values(): 4 ctx1bdce

568 #the binding is already in use 

569 extKeys[event] = '' #disable this binding 1 ctx1e

570 keySet[event] = extKeys[event] #add binding 4 ctx1bdce

571 return keySet 6 ctx1afbdce

572 

573 def IsCoreBinding(self, virtualEvent): (empty)

574 """Return True if the virtual event is one of the core idle key events. 

575 

576 virtualEvent - string, name of the virtual event to test for, 

577 without the enclosing '<< >>' 

578 """ 

579 return ('<<'+virtualEvent+'>>') in self.GetCoreKeys() 1 ctx1J

580 

581# TODO make keyBindings a file or class attribute used for test above 

582# and copied in function below. 

583 

584 former_extension_events = { # Those with user-configurable keys. (empty)

585 '<<force-open-completions>>', '<<expand-word>>', 

586 '<<force-open-calltip>>', '<<flash-paren>>', '<<format-paragraph>>', 

587 '<<run-module>>', '<<check-module>>', '<<zoom-height>>', 

588 '<<run-custom>>', 

589 } 

590 

591 def GetCoreKeys(self, keySetName=None): (empty)

592 """Return dict of core virtual-key keybindings for keySetName. 

593 

594 The default keySetName None corresponds to the keyBindings base 

595 dict. If keySetName is not None, bindings from the config 

596 file(s) are loaded _over_ these defaults, so if there is a 

597 problem getting any core binding there will be an 'ultimate last 

598 resort fallback' to the CUA-ish bindings defined here. 

599 """ 

600 keyBindings={ 8 ctx1apfbdceJ

601 '<<copy>>': ['<Control-c>', '<Control-C>'], 

602 '<<cut>>': ['<Control-x>', '<Control-X>'], 

603 '<<paste>>': ['<Control-v>', '<Control-V>'], 

604 '<<beginning-of-line>>': ['<Control-a>', '<Home>'], 

605 '<<center-insert>>': ['<Control-l>'], 

606 '<<close-all-windows>>': ['<Control-q>'], 

607 '<<close-window>>': ['<Alt-F4>'], 

608 '<<do-nothing>>': ['<Control-x>'], 

609 '<<end-of-file>>': ['<Control-d>'], 

610 '<<python-docs>>': ['<F1>'], 

611 '<<python-context-help>>': ['<Shift-F1>'], 

612 '<<history-next>>': ['<Alt-n>'], 

613 '<<history-previous>>': ['<Alt-p>'], 

614 '<<interrupt-execution>>': ['<Control-c>'], 

615 '<<view-restart>>': ['<F6>'], 

616 '<<restart-shell>>': ['<Control-F6>'], 

617 '<<open-class-browser>>': ['<Alt-c>'], 

618 '<<open-module>>': ['<Alt-m>'], 

619 '<<open-new-window>>': ['<Control-n>'], 

620 '<<open-window-from-file>>': ['<Control-o>'], 

621 '<<plain-newline-and-indent>>': ['<Control-j>'], 

622 '<<print-window>>': ['<Control-p>'], 

623 '<<redo>>': ['<Control-y>'], 

624 '<<remove-selection>>': ['<Escape>'], 

625 '<<save-copy-of-window-as-file>>': ['<Alt-Shift-S>'], 

626 '<<save-window-as-file>>': ['<Alt-s>'], 

627 '<<save-window>>': ['<Control-s>'], 

628 '<<select-all>>': ['<Alt-a>'], 

629 '<<toggle-auto-coloring>>': ['<Control-slash>'], 

630 '<<undo>>': ['<Control-z>'], 

631 '<<find-again>>': ['<Control-g>', '<F3>'], 

632 '<<find-in-files>>': ['<Alt-F3>'], 

633 '<<find-selection>>': ['<Control-F3>'], 

634 '<<find>>': ['<Control-f>'], 

635 '<<replace>>': ['<Control-h>'], 

636 '<<goto-line>>': ['<Alt-g>'], 

637 '<<smart-backspace>>': ['<Key-BackSpace>'], 

638 '<<newline-and-indent>>': ['<Key-Return>', '<Key-KP_Enter>'], 

639 '<<smart-indent>>': ['<Key-Tab>'], 

640 '<<indent-region>>': ['<Control-Key-bracketright>'], 

641 '<<dedent-region>>': ['<Control-Key-bracketleft>'], 

642 '<<comment-region>>': ['<Alt-Key-3>'], 

643 '<<uncomment-region>>': ['<Alt-Key-4>'], 

644 '<<tabify-region>>': ['<Alt-Key-5>'], 

645 '<<untabify-region>>': ['<Alt-Key-6>'], 

646 '<<toggle-tabs>>': ['<Alt-Key-t>'], 

647 '<<change-indentwidth>>': ['<Alt-Key-u>'], 

648 '<<del-word-left>>': ['<Control-Key-BackSpace>'], 

649 '<<del-word-right>>': ['<Control-Key-Delete>'], 

650 '<<force-open-completions>>': ['<Control-Key-space>'], 

651 '<<expand-word>>': ['<Alt-Key-slash>'], 

652 '<<force-open-calltip>>': ['<Control-Key-backslash>'], 

653 '<<flash-paren>>': ['<Control-Key-0>'], 

654 '<<format-paragraph>>': ['<Alt-Key-q>'], 

655 '<<run-module>>': ['<Key-F5>'], 

656 '<<run-custom>>': ['<Shift-Key-F5>'], 

657 '<<check-module>>': ['<Alt-Key-x>'], 

658 '<<zoom-height>>': ['<Alt-Key-2>'], 

659 } 

660 

661 if keySetName: 8 ctx1apfbdceJ

662 if not (self.userCfg['keys'].has_section(keySetName) or 662 ↛ 664line 662 didn't jump to line 6647 ctx1apfbdce

663 self.defaultCfg['keys'].has_section(keySetName)): 

664 warning = ( 

665 '\n Warning: config.py - IdleConf.GetCoreKeys -\n' 

666 ' key set %r is not defined, using default bindings.' % 

667 (keySetName,) 

668 ) 

669 _warn(warning, 'keys', keySetName) 

670 else: 

671 for event in keyBindings: 7 ctx1apfbdce

672 binding = self.GetKeyBinding(keySetName, event) 7 ctx1apfbdce

673 if binding: 673 ↛ 676line 673 didn't jump to line 676, because the condition on line 673 was never false7 ctx1apfbdce

674 keyBindings[event] = binding 7 ctx1apfbdce

675 # Otherwise return default in keyBindings. 

676 elif event not in self.former_extension_events: 

677 warning = ( 

678 '\n Warning: config.py - IdleConf.GetCoreKeys -\n' 

679 ' problem retrieving key binding for event %r\n' 

680 ' from key set %r.\n' 

681 ' returning default value: %r' % 

682 (event, keySetName, keyBindings[event]) 

683 ) 

684 _warn(warning, 'keys', keySetName, event) 

685 return keyBindings 8 ctx1apfbdceJ

686 

687 def GetExtraHelpSourceList(self, configSet): (empty)

688 """Return list of extra help sources from a given configSet. 

689 

690 Valid configSets are 'user' or 'default'. Return a list of tuples of 

691 the form (menu_item , path_to_help_file , option), or return the empty 

692 list. 'option' is the sequence number of the help resource. 'option' 

693 values determine the position of the menu items on the Help menu, 

694 therefore the returned list must be sorted by 'option'. 

695 

696 """ 

697 helpSources = [] 1 ctx1g

698 if configSet == 'user': 1 ctx1g

699 cfgParser = self.userCfg['main'] 1 ctx1g

700 elif configSet == 'default': 1 ctx1g

701 cfgParser = self.defaultCfg['main'] 1 ctx1g

702 else: 

703 raise InvalidConfigSet('Invalid configSet specified') 1 ctx1g

704 options=cfgParser.GetOptionList('HelpFiles') 1 ctx1g

705 for option in options: 1 ctx1g

706 value=cfgParser.Get('HelpFiles', option, default=';') 1 ctx1g

707 if value.find(';') == -1: #malformed config entry with no ';' 1 ctx1g

708 menuItem = '' #make these empty 1 ctx1g

709 helpPath = '' #so value won't be added to list 1 ctx1g

710 else: #config entry contains ';' as expected 

711 value=value.split(';') 1 ctx1g

712 menuItem=value[0].strip() 1 ctx1g

713 helpPath=value[1].strip() 1 ctx1g

714 if menuItem and helpPath: #neither are empty strings 1 ctx1g

715 helpSources.append( (menuItem,helpPath,option) ) 1 ctx1g

716 helpSources.sort(key=lambda x: x[2]) 1 ctx1g

717 return helpSources 1 ctx1g

718 

719 def GetAllExtraHelpSourcesList(self): (empty)

720 """Return a list of the details of all additional help sources. 

721 

722 Tuples in the list are those of GetExtraHelpSourceList. 

723 """ 

724 allHelpSources = (self.GetExtraHelpSourceList('default') + 1 ctx1g

725 self.GetExtraHelpSourceList('user') ) 

726 return allHelpSources 1 ctx1g

727 

728 def GetFont(self, root, configType, section): (empty)

729 """Retrieve a font from configuration (font, font-size, font-bold) 

730 Intercept the special value 'TkFixedFont' and substitute 

731 the actual font, factoring in some tweaks if needed for 

732 appearance sakes. 

733 

734 The 'root' parameter can normally be any valid Tkinter widget. 

735 

736 Return a tuple (family, size, weight) suitable for passing 

737 to tkinter.Font 

738 """ 

739 family = self.GetOption(configType, section, 'font', default='courier') 

740 size = self.GetOption(configType, section, 'font-size', type='int', 

741 default='10') 

742 bold = self.GetOption(configType, section, 'font-bold', default=0, 

743 type='bool') 

744 if (family == 'TkFixedFont'): 

745 f = Font(name='TkFixedFont', exists=True, root=root) 

746 actualFont = Font.actual(f) 

747 family = actualFont['family'] 

748 size = actualFont['size'] 

749 if size <= 0: 

750 size = 10 # if font in pixels, ignore actual size 

751 bold = actualFont['weight'] == 'bold' 

752 return (family, size, 'bold' if bold else 'normal') 

753 

754 def LoadCfgFiles(self): (empty)

755 "Load all configuration files." 

756 for key in self.defaultCfg: 2 ctx1aA

757 self.defaultCfg[key].Load() 2 ctx1aA

758 self.userCfg[key].Load() #same keys 2 ctx1aA

759 

760 def SaveUserCfgFiles(self): (empty)

761 "Write all loaded user configuration files to disk." 

762 for key in self.userCfg: 1 ctx1O

763 self.userCfg[key].Save() 1 ctx1O

764 

765 

766idleConf = IdleConf() (empty)

767 

768_warned = set() (empty)

769def _warn(msg, *key): (empty)