[gentoo-commits] proj/R_overlay:master commit in: roverlay/packagerules/, roverlay/packagerules/abstract/, ...

[André Erdmann]

commit:     2333b3c2779ae8e832db338af93f82f320457d24
Author:     André Erdmann <dywi <AT> mailerd <DOT> de>
AuthorDate: Wed Jan 30 20:07:31 2013 +0000
Commit:     André Erdmann <dywi <AT> mailerd <DOT> de>
CommitDate: Wed Jan 30 20:07:31 2013 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/R_overlay.git;a=commit;h=2333b3c2

Introducing package rules

A PackageRule matches zero or more PackageInfo instances and manipulates them,
e.g by filtering it out ("do not process") or adding ebuild variables
("KEYWORDS='amd64 -86', ...).

This commit adds the abstract layout of such rules,
each rule consists of acceptors (Acceptor objects) that determine if the rule
matches a package, and actions (PackageRuleAction objects) that manipulate the
PackageInfo instance.
NestedPackageRules add the ability to add subordinate rules to a rule.

Acceptors can also be part of boolean expressions,
e.g. "match package if name == 'seewave' or repo == 'CRAN'" (just an example).

What's missing is the creation of such rules from file (PackageRulesLoader),
so the added code doesn't do much (currently).

---
 roverlay/packagerules/__init__.py           |   11 ++
 roverlay/packagerules/abstract/__init__.py  |    5 +
 roverlay/packagerules/abstract/acceptors.py |  157 +++++++++++++++++++++++++++
 roverlay/packagerules/abstract/actions.py   |   32 ++++++
 roverlay/packagerules/abstract/rules.py     |  149 +++++++++++++++++++++++++
 roverlay/packagerules/actions/__init__.py   |    5 +
 roverlay/packagerules/actions/evar.py       |   60 ++++++++++
 roverlay/packagerules/loader.py             |   33 ++++++
 roverlay/packagerules/rules.py              |   54 +++++++++
 9 files changed, 506 insertions(+), 0 deletions(-)

diff --git a/roverlay/packagerules/__init__.py b/roverlay/packagerules/__init__.py
new file mode 100644
index 0000000..100cd2f
--- /dev/null
+++ b/roverlay/packagerules/__init__.py
@@ -0,0 +1,11 @@
+# R overlay -- package rules
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 André Erdmann <dywi@×××××××.de>
+# Distributed under the terms of the GNU General Public License;
+# either version 2 of the License, or (at your option) any later version.
+
+# TODO:
+# * load rules from a file (make them accessible)
+# -> syntax
+# * logging
+# * doc/rst

diff --git a/roverlay/packagerules/abstract/__init__.py b/roverlay/packagerules/abstract/__init__.py
new file mode 100644
index 0000000..2434c5d
--- /dev/null
+++ b/roverlay/packagerules/abstract/__init__.py
@@ -0,0 +1,5 @@
+# R overlay -- abstract package rules
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 André Erdmann <dywi@×××××××.de>
+# Distributed under the terms of the GNU General Public License;
+# either version 2 of the License, or (at your option) any later version.

diff --git a/roverlay/packagerules/abstract/acceptors.py b/roverlay/packagerules/abstract/acceptors.py
new file mode 100644
index 0000000..fa28dd0
--- /dev/null
+++ b/roverlay/packagerules/abstract/acceptors.py
@@ -0,0 +1,157 @@
+# R overlay -- abstract package rules, acceptors
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 André Erdmann <dywi@×××××××.de>
+# Distributed under the terms of the GNU General Public License;
+# either version 2 of the License, or (at your option) any later version.
+
+import roverlay.util
+
+__all__ = [
+	'Acceptor',
+	'Acceptor_AND', 'Acceptor_OR', 'Acceptor_XOR1', 'Acceptor_NOR',
+]
+
+class EmptyAcceptor ( ValueError ):
+	"""
+	Exception for "empty" Acceptors (Acceptor represents a boolean
+	expression, but has no Acceptors attached).
+	"""
+	pass
+# --- end of EmptyAcceptor ---
+
+
+class Acceptor ( object ):
+	"""An Acceptor is able to determine whether it matches a PackageInfo
+	instance or not.
+	"""
+
+	def __init__ ( self, priority ):
+		super ( Acceptor, self ).__init__()
+		self.priority = priority
+	# --- end of __init__ (...) ---
+
+	def prepare ( self ):
+		"""Prepare the Acceptor for usage (typically used after loading
+		it from a file).
+		"""
+		pass
+	# --- end of prepare (...) ---
+
+	def accepts ( self, p_info ):
+		"""Returns True if this Acceptor matches the given PackageInfo, else
+		False.
+
+		arguments:
+		* p_info --
+		"""
+		raise NotImplementedError()
+	# --- end of accepts (...) ---
+
+# --- end of Acceptor ---
+
+class _AcceptorCompound ( Acceptor ):
+	"""The base class for Acceptors that represent a boolean expression."""
+
+	def __init__ ( self, priority ):
+		super ( _AcceptorCompound, self ).__init__ ( priority )
+		self._acceptors = list()
+	# --- end of __init__ (...) ---
+
+	def prepare ( self ):
+		"""Prepare the Acceptor for usage (typically used after loading
+		it from a file).
+
+		Sorts all Acceptors according to their priority.
+
+		Raises: EmptyAcceptor
+		"""
+		if len ( self._acceptors ) > 0:
+			self._acceptors = roverlay.util.priosort ( self._acceptors )
+			for acceptor in self._acceptors:
+				acceptor.prepare()
+		else:
+			raise EmptyAcceptor()
+	# --- end of prepare (...) ---
+
+	def add_acceptor ( self, acceptor ):
+		"""Adds an Acceptor.
+
+		arguments:
+		* acceptor --
+		"""
+		self._acceptors.append ( acceptor )
+	# --- end of add_acceptor (...) ---
+
+# --- end of _AcceptorCompound ---
+
+class Acceptor_OR ( _AcceptorCompound ):
+	"""OR( <Acceptors> )"""
+
+	def accepts ( self, p_info ):
+		"""Returns True if any attached Acceptor returns True, else False.
+
+		arguments:
+		* p_info --
+		"""
+		for acceptor in self._acceptors:
+			if acceptor.accepts ( p_info ):
+				return True
+		return False
+	# --- end of accepts (...) ---
+
+# --- end of Acceptor_OR ---
+
+class Acceptor_AND ( _AcceptorCompound ):
+	"""AND( <Acceptors> )"""
+
+	def accepts ( self, p_info ):
+		"""Returns True if all acceptors accept p_info, else False.
+
+		arguments:
+		* p_info --
+		"""
+		for acceptor in self._acceptors:
+			if not acceptor.accepts ( p_info ):
+				return False
+		return True
+	# --- end of accepts (...) ---
+
+# --- end of Acceptor_AND ---
+
+class Acceptor_XOR1 ( _AcceptorCompound ):
+	"""XOR( <Acceptors> )"""
+
+	# XOR  := odd number of matches
+	# XOR1 := exactly one match
+
+	def accepts ( self, p_info ):
+		"""Returns True if exactly one acceptor accepts p_info, else False.
+
+		arguments:
+		* p_info --
+		"""
+		any_true = False
+		for acceptor in self._acceptors:
+			if acceptor.accepts ( p_info ):
+				if any_true:
+					return False
+				else:
+					any_true = True
+		return any_true
+	# --- end of accepts (...) ---
+
+# --- end of Acceptor_XOR1 ---
+
+class Acceptor_NOR ( Acceptor_OR ):
+	"""NOR( <Acceptors> )"""
+
+	def accepts ( self, p_info ):
+		"""Returns True if no acceptor accepts p_info, else False.
+
+		arguments:
+		* p_info --
+		"""
+		return not super ( Acceptor_NOR, self ).accepts ( p_info )
+	# --- end of accepts (...) ---
+
+# --- end of Acceptor_NOR ---

diff --git a/roverlay/packagerules/abstract/actions.py b/roverlay/packagerules/abstract/actions.py
new file mode 100644
index 0000000..1204f53
--- /dev/null
+++ b/roverlay/packagerules/abstract/actions.py
@@ -0,0 +1,32 @@
+# R overlay -- abstract package rules, actions
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 André Erdmann <dywi@×××××××.de>
+# Distributed under the terms of the GNU General Public License;
+# either version 2 of the License, or (at your option) any later version.
+
+__all__ = [ 'PackageRuleAction', ]
+
+class PackageRuleAction ( object ):
+	"""PackageRuleActions manipulate PackageInfo instances."""
+
+	def __init__ ( self, priority=1000 ):
+		super ( PackageRuleAction, self ).__init__()
+		self.priority = priority
+	# --- end of __init__ (...) ---
+
+	def apply_action ( self, p_info ):
+		"""Applies the action to the given PackageInfo.
+
+		Returns False if the package should be filtered out.
+		Any other value, especially None, should be interpreted as
+		"successfully processed"
+		(In constrast to the PackageRule.apply_actions(), where any false value
+		means "package should be filtered out".)
+
+		arguments:
+		* p_info --
+		"""
+		raise NotImplementedError()
+	# --- end of apply_action (...) ---
+
+# --- end of PackageRuleAction ---

diff --git a/roverlay/packagerules/abstract/rules.py b/roverlay/packagerules/abstract/rules.py
new file mode 100644
index 0000000..b9e057c
--- /dev/null
+++ b/roverlay/packagerules/abstract/rules.py
@@ -0,0 +1,149 @@
+# R overlay -- abstract package rules, rules
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 André Erdmann <dywi@×××××××.de>
+# Distributed under the terms of the GNU General Public License;
+# either version 2 of the License, or (at your option) any later version.
+
+import roverlay.util
+
+__all__ = [ 'PackageRule', 'NestedPackageRule', 'IgnorePackageRule', ]
+
+class PackageRule ( object ):
+	"""A package rule is able to determine whether it matches
+	a given PackageInfo instance (using Acceptor instances)
+	and applies zero or more actions (using PackageAction instances) to the
+	package info.
+	"""
+
+	def __init__ ( self, priority=1000 ):
+		super ( PackageRule, self ).__init__()
+		self.priority   = priority
+		self._actions   = list()
+		self._acceptors = list()
+	# --- end of __init__ (...) ---
+
+	def prepare ( self ):
+		"""
+		Prepares this rule for usage. Has to be called after adding actions.
+		"""
+		self._actions   = roverlay.util.priosort ( self._actions )
+		self._acceptors = roverlay.util.priosort ( self._acceptors )
+		for acceptor in self._acceptors:
+			acceptor.prepare()
+	# --- end of prepare (...) ---
+
+	def accepts ( self, p_info ):
+		"""Returns True if this rule matches the given PackageInfo else False.
+
+		arguments:
+		* p_info --
+		"""
+		for acceptor in self._acceptors:
+			if not acceptor.accepts ( p_info ):
+				return False
+		return True
+	# --- end of accepts (...) ---
+
+	def apply_actions ( self, p_info ):
+		"""Applies all actions to the given PackageInfo.
+
+		The return value indicates whether the package has been filtered out
+		(do not process it any longer -> False) or not (True).
+
+		arguments:
+		* p_info -- PackageInfo object that will be modified
+		"""
+		for action in self._actions:
+			# "is False" - see ./actions.py
+			if action.apply_action ( p_info ) is False:
+				return False
+		return True
+	# --- end of apply_actions (...) ---
+
+	def add_action ( self, action ):
+		"""Adds an action to this rule.
+
+		arguments:
+		* action --
+		"""
+		self._actions.append ( action )
+	# --- end of add_action (...) ---
+
+	def add_acceptor ( self, acceptor ):
+		"""Adds an acceptor to this rule. Such objects are used to match
+		PackageInfo instances (in self.accepts()).
+
+		arguments:
+		* acceptor
+		"""
+		self._acceptors.append ( acceptor )
+	# --- end of add_acceptor (...) ---
+
+# --- end of PackageRule ---
+
+
+class IgnorePackageRule ( PackageRule ):
+	"""A rule that has only one action: filter packages."""
+
+	def __init__ ( self, priority=100 ):
+		super ( PackageRule, self ).__init__( priority )
+	# --- end of __init__ (...) ---
+
+	def apply_actions ( self, p_info ):
+		"""Ignores a PackageInfo by returning False.
+
+		arguments:
+		* p_info --
+		"""
+		return False
+	# --- end of apply_actions (...) ---
+
+# --- end of IgnorePackageRule ---
+
+
+class NestedPackageRule ( PackageRule ):
+	"""A rule that consists of zero or more subordinate rules."""
+
+	def __init__ ( self, priority=2000 ):
+		super ( NestedPackageRule, self ).__init__ ( priority )
+		self._rules = list()
+	# --- end of __init__ (...) ---
+
+	def prepare ( self ):
+		"""
+		Prepares this rule for usage. Has to be called after adding actions.
+		"""
+		super ( NestedPackageRule, self ).prepare()
+		self._rules = roverlay.util.priosort ( self._rules )
+		for rule in self._rules:
+			rule.prepare()
+	# --- end of prepare (...) ---
+
+	def apply_actions ( self, p_info ):
+		"""Applies all actions to the given PackageInfo.
+
+		The return value indicates whether the package has been filtered out
+		(do not process it any longer -> False) or not (True).
+
+		arguments:
+		* p_info -- PackageInfo object that will be modified
+		"""
+		if super ( NestedPackageRule, self ).apply_actions ( p_info ):
+			for rule in self._rules:
+				if rule.accepts ( p_info ) and not rule.apply_actions ( p_info ):
+					return False
+			return True
+		else:
+			return False
+	# --- end of apply_actions (...) ---
+
+	def add_rule ( self, rule ):
+		"""Adds a rule.
+
+		arguments:
+		* rule --
+		"""
+		self._rules.append ( rule )
+	# --- end of add_rule (...) ---
+
+# --- end of NestedPackageRule ---

diff --git a/roverlay/packagerules/actions/__init__.py b/roverlay/packagerules/actions/__init__.py
new file mode 100644
index 0000000..1a6cb02
--- /dev/null
+++ b/roverlay/packagerules/actions/__init__.py
@@ -0,0 +1,5 @@
+# R overlay -- package rules, actions
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 André Erdmann <dywi@×××××××.de>
+# Distributed under the terms of the GNU General Public License;
+# either version 2 of the License, or (at your option) any later version.

diff --git a/roverlay/packagerules/actions/evar.py b/roverlay/packagerules/actions/evar.py
new file mode 100644
index 0000000..d2a4580
--- /dev/null
+++ b/roverlay/packagerules/actions/evar.py
@@ -0,0 +1,60 @@
+# R overlay -- package rule actions, add/set ebuild variables
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 André Erdmann <dywi@×××××××.de>
+# Distributed under the terms of the GNU General Public License;
+# either version 2 of the License, or (at your option) any later version.
+
+import roverlay.packagerules.abstract.actions
+
+import roverlay.ebuild.evars
+
+__all__ = [
+	'EvarAction',
+	'KeywordsEvarAction',
+]
+
+class EvarAction ( roverlay.packagerules.abstract.actions.PackageRuleAction ):
+	"""An EvarAction adds an ebuild variable to a PackageInfo."""
+
+	def __init__ ( self, evar, priority=1000 ):
+		"""Constructor for EvarAction.
+
+		arguments:
+		* evar     -- ebuild variable that will be added whenever calling
+		              apply_action()
+		* priority -- priority of this action (used for sorting)
+		"""
+		super ( EvarAction, self ).__init__ ( priority=priority )
+		self._evar = evar
+	# --- end of __init__ (...) ---
+
+	def apply_action ( self, p_info ):
+		"""Adds the stored ebuild variable to p_info.
+
+		Note:
+		 Since the ebuild variable will be added as reference, ebuild creation
+		 has to copy it before editing, else *all* ebuilds using this variable
+		 will be affected!
+		 (At least those that get processed after the evar modification.)
+
+		arguments:
+		* p_info --
+		"""
+		# add ref to self._evar
+		p_info.update_unsafe ( EVAR=self._evar )
+	# --- end of apply_action (...) ---
+
+# --- end of EvarAction (...) ---
+
+
+class KeywordsEvarAction ( EvarAction ):
+	"""A KeywordsEvarAction adds a KEYWORDS=... variable to a PackageInfo."""
+
+	def __init__ ( self, keywords, priority=1000 ):
+		super ( KeywordsEvarAction, self ).__init__ (
+			evar     = roverlay.ebuild.evars.KEYWORDS ( keywords ),
+			priority = priority,
+		)
+	# --- end of __init__ (...) ---
+
+# --- end of KeywordsEvarAction ---

diff --git a/roverlay/packagerules/loader.py b/roverlay/packagerules/loader.py
new file mode 100644
index 0000000..601264f
--- /dev/null
+++ b/roverlay/packagerules/loader.py
@@ -0,0 +1,33 @@
+# R overlay -- package rules, package rule loader (from files)
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 André Erdmann <dywi@×××××××.de>
+# Distributed under the terms of the GNU General Public License;
+# either version 2 of the License, or (at your option) any later version.
+
+__all__ = [ 'PackageRulesLoader', ]
+
+class PackageRulesLoader ( object ):
+	"""Loads PackageRules from a file."""
+
+	# TODO
+
+	def __init__ ( self, rules ):
+		"""Constructor for PackageRulesLoader.
+
+		arguments:
+		* rules -- object where new rules will be added to
+		            has to implement an "add_rule()" function
+		"""
+		self.rules = rules
+	# --- end of __init__ (...) ---
+
+	def load ( self, rule_file ):
+		"""Loads a rule file.
+
+		arguments:
+		* rule_file --
+		"""
+		raise NotImplementedError ( "TODO" )
+	# --- end of load (...) ---
+
+# --- end of PackageRulesLoader ---

diff --git a/roverlay/packagerules/rules.py b/roverlay/packagerules/rules.py
new file mode 100644
index 0000000..1c1adbc
--- /dev/null
+++ b/roverlay/packagerules/rules.py
@@ -0,0 +1,54 @@
+# R overlay -- package rules
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 André Erdmann <dywi@×××××××.de>
+# Distributed under the terms of the GNU General Public License;
+# either version 2 of the License, or (at your option) any later version.
+
+__all__ = [ 'PackageRules', ]
+
+import roverlay.packagerules.abstract.rules
+import roverlay.packagerules.loader
+
+#import roverlay.packagerules.actions.evar
+
+class PackageRules ( roverlay.packagerules.abstract.rules.NestedPackageRule ):
+	"""The top level rule.
+	Matches all PackageInfo instances and applies any rule that matches.
+	"""
+
+	@classmethod
+	def get_configured ( cls ):
+		"""Returns a PackageRules instance that uses the configured rules
+		(roverlay.config).
+
+		arguments:
+		* cls --
+
+		This is a stub since package rule loading is not implemented.
+		"""
+		rules = PackageRules()
+		f = rules.get_loader()
+		# "example usage" (just a reminder for PackageRulesLoader)
+#		rules.add_action (
+#			roverlay.packagerules.actions.evar.KeywordsEvarAction ( "amd64" )
+#		)
+		return rules
+	# --- end of get_configured (...) ---
+
+	def __init__ ( self ):
+		super ( PackageRules, self ).__init__ ( priority=-1 )
+	# --- end of __init__ (...) ---
+
+	def get_loader ( self ):
+		"""Returns a PackageRulesLoader that reads files and adds rules to
+		this PackageRules instance.
+		"""
+		return roverlay.packagerules.loader.PackageRulesLoader ( self )
+	# --- end of get_loader (...) ---
+
+	def accepts ( self, p_info ):
+		"""Returns True (and therefore doesn't need to be called)."""
+		return True
+	# --- end of accepts (...) ---
+
+# --- end of PackageRules ---