GitPython/lib/git/config.py at 0.2 · og-python-scripts/GitPython · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

# config.py

# This module is part of GitPython and is released under

# the BSD License: http://www.opensource.org/licenses/bsd-license.php

"""

Module containing module parser implementation able to properly read and write

configuration files

"""

import re

import os

import ConfigParser as cp

import inspect

import cStringIO

from git.odict import OrderedDict

from git.utils import LockFile

class _MetaParserBuilder(type):

"""

Utlity class wrapping base-class methods into decorators that assure read-only properties

"""

def __new__(metacls, name, bases, clsdict):

"""

Equip all base-class methods with a _needs_values decorator, and all non-const methods

with a _set_dirty_and_flush_changes decorator in addition to that.

"""

mutating_methods = clsdict['_mutating_methods_']

for base in bases:

methods = ( t for t in inspect.getmembers(base, inspect.ismethod) if not t[0].startswith("_") )

for name, method in methods:

if name in clsdict:

continue

method_with_values = _needs_values(method)

if name in mutating_methods:

method_with_values = _set_dirty_and_flush_changes(method_with_values)

# END mutating methods handling

clsdict[name] = method_with_values

# END for each base

new_type = super(_MetaParserBuilder, metacls).__new__(metacls, name, bases, clsdict)

return new_type

def _needs_values(func):

"""

Returns method assuring we read values (on demand) before we try to access them

"""

def assure_data_present(self, *args, **kwargs):

self.read()

return func(self, *args, **kwargs)

# END wrapper method

assure_data_present.__name__ = func.__name__

return assure_data_present

def _set_dirty_and_flush_changes(non_const_func):

"""

Return method that checks whether given non constant function may be called.

If so, the instance will be set dirty.

Additionally, we flush the changes right to disk

"""

def flush_changes(self, *args, **kwargs):

rval = non_const_func(self, *args, **kwargs)

self.write()

return rval

# END wrapper method

flush_changes.__name__ = non_const_func.__name__

return flush_changes

class GitConfigParser(cp.RawConfigParser, object):

"""

Implements specifics required to read git style configuration files.

This variation behaves much like the git.config command such that the configuration

will be read on demand based on the filepath given during initialization.

The changes will automatically be written once the instance goes out of scope, but

can be triggered manually as well.

The configuration file will be locked if you intend to change values preventing other

instances to write concurrently.

NOTE

The config is case-sensitive even when queried, hence section and option names

must match perfectly.

"""

__metaclass__ = _MetaParserBuilder

#{ Configuration

# The lock type determines the type of lock to use in new configuration readers.

# They must be compatible to the LockFile interface.

# A suitable alternative would be the BlockingLockFile

t_lock = LockFile

#} END configuration

OPTCRE = re.compile(

r'\s?(?P<option>[^:=\s][^:=]*)' # very permissive, incuding leading whitespace

r'\s*(?P<vi>[:=])\s*' # any number of space/tab,

# followed by separator

# (either : or =), followed

# by any # space/tab

r'(?P<value>.*)$' # everything up to eol

)

# list of RawConfigParser methods able to change the instance

_mutating_methods_ = ("add_section", "remove_section", "remove_option", "set")

__slots__ = ("_sections", "_defaults", "_file_or_files", "_read_only","_is_initialized", '_lock')

def __init__(self, file_or_files, read_only=True):

"""

Initialize a configuration reader to read the given file_or_files and to

possibly allow changes to it by setting read_only False

``file_or_files``

A single file path or file objects or multiple of these

``read_only``

If True, the ConfigParser may only read the data , but not change it.

If False, only a single file path or file object may be given.

"""

super(GitConfigParser, self).__init__()

# initialize base with ordered dictionaries to be sure we write the same

# file back

self._sections = OrderedDict()

self._defaults = OrderedDict()

self._file_or_files = file_or_files

self._read_only = read_only

self._is_initialized = False

self._lock = None

if not read_only:

if isinstance(file_or_files, (tuple, list)):

raise ValueError("Write-ConfigParsers can operate on a single file only, multiple files have been passed")

# END single file check

if not isinstance(file_or_files, basestring):

file_or_files = file_or_files.name

# END get filename from handle/stream

# initialize lock base - we want to write

self._lock = self.t_lock(file_or_files)

self._lock._obtain_lock()

# END read-only check

def __del__(self):

"""

Write pending changes if required and release locks

"""

# checking for the lock here makes sure we do not raise during write()

# in case an invalid parser was created who could not get a lock

if self.read_only or not self._lock._has_lock():

return

try:

self.write()

except IOError,e:

print "Exception during destruction of GitConfigParser: %s" % str(e)

finally:

self._lock._release_lock()

def optionxform(self, optionstr):

"""

Do not transform options in any way when writing

"""

return optionstr

def _read(self, fp, fpname):

"""

A direct copy of the py2.4 version of the super class's _read method

to assure it uses ordered dicts. Had to change one line to make it work.

Future versions have this fixed, but in fact its quite embarassing for the

guys not to have done it right in the first place !

Removed big comments to make it more compact.

Made sure it ignores initial whitespace as git uses tabs

"""

cursect = None # None, or a dictionary

optname = None

lineno = 0

e = None # None, or an exception

while True:

line = fp.readline()

if not line:

break

lineno = lineno + 1

# comment or blank line?

if line.strip() == '' or line[0] in '#;':

continue

if line.split(None, 1)[0].lower() == 'rem' and line[0] in "rR":

# no leading whitespace

continue

else:

# is it a section header?

mo = self.SECTCRE.match(line)

if mo:

sectname = mo.group('header')

if sectname in self._sections:

cursect = self._sections[sectname]

elif sectname == cp.DEFAULTSECT:

cursect = self._defaults

else:

# THE ONLY LINE WE CHANGED !

cursect = OrderedDict((('__name__', sectname),))

self._sections[sectname] = cursect

# So sections can't start with a continuation line

optname = None

# no section header in the file?

elif cursect is None:

raise cp.MissingSectionHeaderError(fpname, lineno, line)

# an option line?

else:

mo = self.OPTCRE.match(line)

if mo:

optname, vi, optval = mo.group('option', 'vi', 'value')

if vi in ('=', ':') and ';' in optval:

pos = optval.find(';')

if pos != -1 and optval[pos-1].isspace():

optval = optval[:pos]

optval = optval.strip()

if optval == '""':

optval = ''

optname = self.optionxform(optname.rstrip())

cursect[optname] = optval

else:

if not e:

e = cp.ParsingError(fpname)

e.append(lineno, repr(line))

# END

# END ?

# END while reading

# if any parsing errors occurred, raise an exception

if e:

raise e

def read(self):

"""

Reads the data stored in the files we have been initialized with. It will

ignore files that cannot be read, possibly leaving an empty configuration

Returns

Nothing

Raises

IOError if a file cannot be handled

"""

if self._is_initialized:

return

files_to_read = self._file_or_files

if not isinstance(files_to_read, (tuple, list)):

files_to_read = [ files_to_read ]

for file_object in files_to_read:

fp = file_object

close_fp = False

# assume a path if it is not a file-object

if not hasattr(file_object, "seek"):

try:

fp = open(file_object)

except IOError,e:

continue

close_fp = True

# END fp handling

try:

self._read(fp, fp.name)

finally:

if close_fp:

fp.close()

# END read-handling

# END for each file object to read

self._is_initialized = True

def _write(self, fp):

"""Write an .ini-format representation of the configuration state in

git compatible format"""

def write_section(name, section_dict):

fp.write("[%s]\n" % name)

for (key, value) in section_dict.items():

if key != "__name__":

fp.write("\t%s = %s\n" % (key, str(value).replace('\n', '\n\t')))

# END if key is not __name__

# END section writing

if self._defaults:

write_section(cp.DEFAULTSECT, self._defaults)

map(lambda t: write_section(t[0],t[1]), self._sections.items())

@_needs_values

def write(self):

"""

Write changes to our file, if there are changes at all

Raise

IOError if this is a read-only writer instance or if we could not obtain

a file lock

"""

self._assure_writable("write")

self._lock._obtain_lock()

fp = self._file_or_files

close_fp = False

if not hasattr(fp, "seek"):

fp = open(self._file_or_files, "w")

close_fp = True

else:

fp.seek(0)

# WRITE DATA

try:

self._write(fp)

finally:

if close_fp:

fp.close()

# END data writing

# we do not release the lock - it will be done automatically once the

# instance vanishes

def _assure_writable(self, method_name):

if self.read_only:

raise IOError("Cannot execute non-constant method %s.%s" % (self, method_name))

@_needs_values

@_set_dirty_and_flush_changes

def add_section(self, section):

"""

Assures added options will stay in order

"""

super(GitConfigParser, self).add_section(section)

self._sections[section] = OrderedDict()

@property

def read_only(self):

"""

Returns

True if this instance may change the configuration file

"""

return self._read_only

def get_value(self, section, option, default = None):

"""

``default``

If not None, the given default value will be returned in case

the option did not exist

Returns

a properly typed value, either int, float or string

Raises TypeError in case the value could not be understood

Otherwise the exceptions known to the ConfigParser will be raised.

"""

try:

valuestr = self.get(section, option)

except Exception:

if default is not None:

return default

raise

types = ( long, float )

for numtype in types:

try:

val = numtype( valuestr )

# truncated value ?

if val != float( valuestr ):

continue

return val

except (ValueError,TypeError):

continue

# END for each numeric type

# try boolean values as git uses them

vl = valuestr.lower()

if vl == 'false':

return False

if vl == 'true':

return True

if not isinstance( valuestr, basestring ):

raise TypeError( "Invalid value type: only int, long, float and str are allowed", valuestr )

return valuestr

@_needs_values

@_set_dirty_and_flush_changes

def set_value(self, section, option, value):

"""Sets the given option in section to the given value.

It will create the section if required, and will not throw as opposed to the default

ConfigParser 'set' method.

``section``

Name of the section in which the option resides or should reside

``option``

Name of the options whose value to set

``value``

Value to set the option to. It must be a string or convertible to a string

"""

if not self.has_section(section):

self.add_section(section)

self.set(section, option, str(value))

GitPython/lib/git/config.py at 0.2 · og-python-scripts/GitPython · GitHub

Repository navigation

Expand file tree

Breadcrumbs

config.py

Latest commit

History

Breadcrumbs

config.py

File metadata and controls