Cyclone-Team/gramps
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* src/Filters/_GenericFilter.py (GenericFilterFactory): Add

Browse Source 
factory function.
	* src/Filters/_FilterParser.py (FilterParser.startElement): Use
	factory function.
	* src/Filters/Rules/_MatchesFilterBase.py: Add base module.
	* src/Filters/Rules/Person/_MatchesFilter.py: Derive from base.
	* src/Filters/Rules/Family/_MatchesFilter.py: Add rule.
	* src/Filters/Rules/Family/_MotherHasIdOf.py: Add rule.
	* src/Filters/Rules/Family/_FatherHasIdOf.py: Add rule.
	* src/Filters/Rules/Family/_MotherHasNameOf.py: Add rule.
	* src/Filters/Rules/Family/_ChildHasIdOf.py: Add rule.
	* src/Filters/Rules/Family/_FatherHasNameOf.py: Add rule.
	* src/Filters/Rules/Family/_ChildHasNameOf.py: Add rule.
	* src/Filters/Rules/Family/__init__.py: Expose new rules.
	


svn: r7117
This commit is contained in:
Alex Roitman 2006-08-04 05:05:59 +00:00
parent b6be1b4369
commit 929c918486
13 changed files with 500 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
ChangeLog
View File

@ -1,4 +1,19 @@
2006-08-03 Alex Roitman <shura@gramps-project.org>
* src/Filters/_GenericFilter.py (GenericFilterFactory): Add
factory function.
* src/Filters/_FilterParser.py (FilterParser.startElement): Use
factory function.
* src/Filters/Rules/_MatchesFilterBase.py: Add base module.
* src/Filters/Rules/Person/_MatchesFilter.py: Derive from base.
* src/Filters/Rules/Family/_MatchesFilter.py: Add rule.
* src/Filters/Rules/Family/_MotherHasIdOf.py: Add rule.
* src/Filters/Rules/Family/_FatherHasIdOf.py: Add rule.
* src/Filters/Rules/Family/_MotherHasNameOf.py: Add rule.
* src/Filters/Rules/Family/_ChildHasIdOf.py: Add rule.
* src/Filters/Rules/Family/_FatherHasNameOf.py: Add rule.
* src/Filters/Rules/Family/_ChildHasNameOf.py: Add rule.
* src/Filters/Rules/Family/__init__.py: Expose new rules.
* src/GrampsLogger/_ErrorReportAssistant.py (build_page5): Typo.
* src/Filters/Rules/Person/_HasIdOf.py: Cleanup.
* src/Filters/Rules/Person/__init__.py (editor_rule_list): Add

56
src/Filters/Rules/Family/_ChildHasIdOf.py Normal file
View File

@ -0,0 +1,56 @@
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2002-2006 Donald N. Allingham
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# $Id: _HasNameOf.py 6529 2006-05-03 06:29:07Z rshura $
#-------------------------------------------------------------------------
#
# Standard Python modules
#
#-------------------------------------------------------------------------
from gettext import gettext as _
#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------
from Filters.Rules import HasGrampsId
#-------------------------------------------------------------------------
#
# HasNameOf
#
#-------------------------------------------------------------------------
class ChildHasIdOf(HasGrampsId):
"""Rule that checks for a person with a specific GRAMPS ID"""
labels = [ _('Person ID:') ]
name = _('Families with child with the <Id>')
description = _("Matches familis where child has a specified "
"GRAMPS ID")
category = _('Child filters')
def apply(self,db,family):
for child_ref in family.get_child_ref_list():
child = db.get_person_from_handle(child_ref.ref)
if HasGrampsId.apply(self,db,child):
return True
return False

55
src/Filters/Rules/Family/_ChildHasNameOf.py Normal file
View File

@ -0,0 +1,55 @@
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2002-2006 Donald N. Allingham
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# $Id: _HasNameOf.py 6529 2006-05-03 06:29:07Z rshura $
#-------------------------------------------------------------------------
#
# Standard Python modules
#
#-------------------------------------------------------------------------
from gettext import gettext as _
#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------
from Filters.Rules.Person import HasNameOf
#-------------------------------------------------------------------------
#
# HasNameOf
#
#-------------------------------------------------------------------------
class ChildHasNameOf(HasNameOf):
"""Rule that checks for full or partial name matches"""
name = _('Families with child with the <name>')
description = _("Matches familis where child has a specified "
"(partial) name")
category = _('Child filters')
def apply(self,db,family):
for child_ref in family.get_child_ref_list():
child = db.get_person_from_handle(child_ref.ref)
if HasNameOf.apply(self,db,child):
return True
return False

54
src/Filters/Rules/Family/_FatherHasIdOf.py Normal file
View File

@ -0,0 +1,54 @@
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2002-2006 Donald N. Allingham
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# $Id: _HasNameOf.py 6529 2006-05-03 06:29:07Z rshura $
#-------------------------------------------------------------------------
#
# Standard Python modules
#
#-------------------------------------------------------------------------
from gettext import gettext as _
#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------
from Filters.Rules import HasGrampsId
#-------------------------------------------------------------------------
#
# HasNameOf
#
#-------------------------------------------------------------------------
class FatherHasIdOf(HasGrampsId):
"""Rule that checks for a person with a specific GRAMPS ID"""
labels = [ _('Person ID:') ]
name = _('Families with father with the <Id>')
description = _("Matches familis whose father has a specified "
"GRAMPS ID")
category = _('Father filters')
def apply(self,db,family):
father_handle = family.get_father_handle()
father = db.get_person_from_handle(father_handle)
return HasGrampsId.apply(self,db,father)

53
src/Filters/Rules/Family/_FatherHasNameOf.py Normal file
View File

@ -0,0 +1,53 @@
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2002-2006 Donald N. Allingham
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# $Id: _HasNameOf.py 6529 2006-05-03 06:29:07Z rshura $
#-------------------------------------------------------------------------
#
# Standard Python modules
#
#-------------------------------------------------------------------------
from gettext import gettext as _
#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------
from Filters.Rules.Person import HasNameOf
#-------------------------------------------------------------------------
#
# HasNameOf
#
#-------------------------------------------------------------------------
class FatherHasNameOf(HasNameOf):
"""Rule that checks for full or partial name matches"""
name = _('Families with father with the <name>')
description = _("Matches familis whose father has a specified "
"(partial) name")
category = _('Father filters')
def apply(self,db,family):
father_handle = family.get_father_handle()
father = db.get_person_from_handle(father_handle)
return HasNameOf.apply(self,db,father)

47
src/Filters/Rules/Family/_MatchesFilter.py Normal file
View File

@ -0,0 +1,47 @@
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2002-2006 Donald N. Allingham
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# $Id: _MatchesFilter.py 6932 2006-06-21 16:30:35Z dallingham $
#-------------------------------------------------------------------------
#
# Standard Python modules
#
#-------------------------------------------------------------------------
from gettext import gettext as _
#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------
from Filters.Rules._MatchesFilterBase import MatchesFilterBase
#-------------------------------------------------------------------------
#
# MatchesFilter
#
#-------------------------------------------------------------------------
class MatchesFilter(MatchesFilterBase):
"""Rule that checks against another filter"""
name = _('Families matching the <filter>')
description = _("Matches families macthed by the specified filter name")
namespace = 'Family'

54
src/Filters/Rules/Family/_MotherHasIdOf.py Normal file
View File

@ -0,0 +1,54 @@
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2002-2006 Donald N. Allingham
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# $Id: _HasNameOf.py 6529 2006-05-03 06:29:07Z rshura $
#-------------------------------------------------------------------------
#
# Standard Python modules
#
#-------------------------------------------------------------------------
from gettext import gettext as _
#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------
from Filters.Rules import HasGrampsId
#-------------------------------------------------------------------------
#
# HasNameOf
#
#-------------------------------------------------------------------------
class MotherHasIdOf(HasGrampsId):
"""Rule that checks for a person with a specific GRAMPS ID"""
labels = [ _('Person ID:') ]
name = _('Families with mother with the <Id>')
description = _("Matches familis whose mother has a specified "
"GRAMPS ID")
category = _('Mother filters')
def apply(self,db,family):
mother_handle = family.get_mother_handle()
mother = db.get_person_from_handle(mother_handle)
return HasGrampsId.apply(self,db,mother)

53
src/Filters/Rules/Family/_MotherHasNameOf.py Normal file
View File

@ -0,0 +1,53 @@
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2002-2006 Donald N. Allingham
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# $Id: _HasNameOf.py 6529 2006-05-03 06:29:07Z rshura $
#-------------------------------------------------------------------------
#
# Standard Python modules
#
#-------------------------------------------------------------------------
from gettext import gettext as _
#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------
from Filters.Rules.Person import HasNameOf
#-------------------------------------------------------------------------
#
# HasNameOf
#
#-------------------------------------------------------------------------
class MotherHasNameOf(HasNameOf):
"""Rule that checks for full or partial name matches"""
name = _('Families with mother with the <name>')
description = _("Matches familis whose mother has a specified "
"(partial) name")
category = _('Mother filters')
def apply(self,db,family):
mother_handle = family.get_mother_handle()
mother = db.get_person_from_handle(mother_handle)
return HasNameOf.apply(self,db,mother)

14
src/Filters/Rules/Family/__init__.py
View File

@ -34,6 +34,13 @@ from _HasNoteRegexp import HasNoteRegexp
from _HasNoteMatchingSubstringOf import HasNoteMatchingSubstringOf
from _FamilyPrivate import FamilyPrivate
from _HasEvent import HasEvent
from _MatchesFilter import MatchesFilter
from _FatherHasNameOf import FatherHasNameOf
from _FatherHasIdOf import FatherHasIdOf
from _MotherHasNameOf import MotherHasNameOf
from _MotherHasIdOf import MotherHasIdOf
from _ChildHasNameOf import ChildHasNameOf
from _ChildHasIdOf import ChildHasIdOf
editor_rule_list = [
AllFamilies,
@ -44,4 +51,11 @@ editor_rule_list = [
HasNoteMatchingSubstringOf,
FamilyPrivate,
HasEvent,
MatchesFilter,
FatherHasNameOf,
FatherHasIdOf,
MotherHasNameOf,
MotherHasIdOf,
ChildHasNameOf,
ChildHasIdOf,
]

44
src/Filters/Rules/Person/_MatchesFilter.py
View File

@ -32,54 +32,16 @@ from gettext import gettext as _
# GRAMPS modules
#
#-------------------------------------------------------------------------
import Filters
#from Filters import SystemFilters, CustomFilters
from Filters.Rules._Rule import Rule
from Filters.Rules._MatchesFilterBase import MatchesFilterBase
#-------------------------------------------------------------------------
#
# MatchesFilter
#
#-------------------------------------------------------------------------
class MatchesFilter(Rule):
class MatchesFilter(MatchesFilterBase):
"""Rule that checks against another filter"""
labels = [_('Filter name:')]
name = _('People matching the <filter>')
description = _("Matches people macthed by the specified filter name")
category = _('General filters')
def prepare(self,db):
if Filters.SystemFilters:
for filt in Filters.SystemFilters.get_filters('Person'):
if filt.get_name() == self.list[0]:
for rule in filt.flist:
rule.prepare(db)
if Filters.CustomFilters:
for filt in Filters.CustomFilters.get_filters('Person'):
if filt.get_name() == self.list[0]:
for rule in filt.flist:
rule.prepare(db)
def reset(self):
if Filters.SystemFilters:
for filt in Filters.SystemFilters.get_filters('Person'):
if filt.get_name() == self.list[0]:
for rule in filt.flist:
rule.reset()
if Filters.CustomFilters:
for filt in Filters.CustomFilters.get_filters('Person'):
if filt.get_name() == self.list[0]:
for rule in filt.flist:
rule.reset()
def apply(self,db,person):
if Filters.SystemFilters:
for filt in Filters.SystemFilters.get_filters('Person'):
if filt.get_name() == self.list[0]:
return filt.check(db,person.handle)
if Filters.CustomFilters:
for filt in Filters.CustomFilters.get_filters('Person'):
if filt.get_name() == self.list[0]:
return filt.check(db,person.handle)
return False
namespace = 'Person'

89
src/Filters/Rules/_MatchesFilterBase.py Normal file
View File

@ -0,0 +1,89 @@
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2002-2006 Donald N. Allingham
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# $Id: _MatchesFilter.py 6932 2006-06-21 16:30:35Z dallingham $
#-------------------------------------------------------------------------
#
# Standard Python modules
#
#-------------------------------------------------------------------------
from gettext import gettext as _
#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------
import Filters
from _Rule import Rule
#-------------------------------------------------------------------------
#
# MatchesFilter
#
#-------------------------------------------------------------------------
class MatchesFilterBase(Rule):
"""
Rule that checks against another filter.
This is a base rule for subclassing by specific objects.
Subclasses need to define the namespace class attribute.
"""
labels = [_('Filter name:')]
name = _('Objects matching the <filter>')
description = _("Matches objects macthed by the specified filter name")
category = _('General filters')
def prepare(self,db):
if Filters.SystemFilters:
for filt in Filters.SystemFilters.get_filters(self.namespace):
if filt.get_name() == self.list[0]:
for rule in filt.flist:
rule.prepare(db)
if Filters.CustomFilters:
for filt in Filters.CustomFilters.get_filters(self.namespace):
if filt.get_name() == self.list[0]:
for rule in filt.flist:
rule.prepare(db)
def reset(self):
if Filters.SystemFilters:
for filt in Filters.SystemFilters.get_filters(self.namespace):
if filt.get_name() == self.list[0]:
for rule in filt.flist:
rule.reset()
if Filters.CustomFilters:
for filt in Filters.CustomFilters.get_filters(self.namespace):
if filt.get_name() == self.list[0]:
for rule in filt.flist:
rule.reset()
def apply(self,db,obj):
if Filters.SystemFilters:
for filt in Filters.SystemFilters.get_filters(self.namespace):
if filt.get_name() == self.list[0]:
return filt.check(db,obj.handle)
if Filters.CustomFilters:
for filt in Filters.CustomFilters.get_filters(self.namespace):
if filt.get_name() == self.list[0]:
return filt.check(db,obj.handle)
return False

4
src/Filters/_FilterParser.py
View File

@ -32,7 +32,7 @@ from xml.sax import handler
# Gramps modules
#
#-------------------------------------------------------------------------
from _GenericFilter import GenericFilter
from _GenericFilter import GenericFilterFactory
import Rules
#-------------------------------------------------------------------------
@ -62,7 +62,7 @@ class FilterParser(handler.ContentHandler):
else:
self.namespace = "generic"
elif tag == "filter":
self.f = GenericFilter()
self.f = GenericFilterFactory(self.namespace)()
self.f.set_name(attrs['name'])
if attrs.has_key('function'):
try:

6
src/Filters/_GenericFilter.py
View File

@ -25,7 +25,6 @@ Package providing filtering framework for GRAMPS.
"""
import RelLib
#-------------------------------------------------------------------------
#
# GenericFilter
@ -210,3 +209,8 @@ class GenericFamilyFilter(GenericFilter):
return db.get_family_from_handle(handle)
def GenericFilterFactory(namespace):
if namespace == 'Person':
return GenericFilter
elif namespace == 'Family':
return GenericFamilyFilter