[gentoo-commits] proj/R_overlay:master commit in: roverlay/depres/simpledeprule/, roverlay/depres/

[André Erdmann]

commit:     92289de61ffeb2cf33954d12f7fbc615111ed604
Author:     André Erdmann <dywi <AT> mailerd <DOT> de>
AuthorDate: Mon Sep  2 16:19:39 2013 +0000
Commit:     André Erdmann <dywi <AT> mailerd <DOT> de>
CommitDate: Mon Sep  2 16:19:39 2013 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/R_overlay.git;a=commit;h=92289de6

dynamic selfdep pool: try repo-specific match first

Try to resolve selfdeps within a repo first, before trying to get a match in any
repo.

---
 roverlay/depres/depenv.py                |   4 +
 roverlay/depres/deprule.py               | 237 +++++++++++++++++++++----------
 roverlay/depres/simpledeprule/dynpool.py |  52 +++++--
 3 files changed, 210 insertions(+), 83 deletions(-)

diff --git a/roverlay/depres/depenv.py b/roverlay/depres/depenv.py
index 2e6417e..b20e0b5 100644
--- a/roverlay/depres/depenv.py
+++ b/roverlay/depres/depenv.py
@@ -176,8 +176,12 @@ class DepEnv ( object ):
       self.package_ref  = package_ref
       if package_ref is not None:
          self.get_package_info = self._deref_package_info
+         self.repo_id          = (
+            package_ref.deref_safe().get ( 'origin' ).get_identifier()
+         )
       else:
          self.get_package_info = self._deref_none
+         self.repo_id          = None
 
 
       self.dep_str      = dep_str

diff --git a/roverlay/depres/deprule.py b/roverlay/depres/deprule.py
index 800d2af..66a43f2 100644
--- a/roverlay/depres/deprule.py
+++ b/roverlay/depres/deprule.py
@@ -8,6 +8,8 @@
 
 __all__ = [ 'DependencyRule', 'DependencyRulePool', ]
 
+import roverlay.util.objects
+
 import roverlay.depres.depresult
 
 from roverlay.depres import deptype
@@ -47,26 +49,16 @@ class DependencyRule ( object ):
 # --- end of DependencyRule ---
 
 
-class DependencyRulePool ( object ):
-
-   def __init__ ( self, name, priority, deptype_mask, initial_rules=None ):
-      """Initializes an DependencyRulePool, which basically is a set of
-      dependency rules with methods like "search for x in all rules."
+class DependencyRulePoolBase ( object ):
+   """Base object for dependency rule pools."""
 
-      arguments:
-      * name -- name of this rule pool
-      * priority -- priority of this pool (lower is better)
-      """
-      super ( DependencyRulePool, self ).__init__()
-      if initial_rules is None:
-         self.rules = list()
-      else:
-         self.rules = list ( initial_rules )
-      self._rule_add    = self.rules.append
-      self.name         = name
-      self.priority     = priority
+   def __init__ ( self, name, priority, deptype_mask ):
+      super ( DependencyRulePoolBase, self ).__init__()
+      self.name = name
+      self.priority = priority
       # filter out deptype flags like "mandatory"
       self.deptype_mask = deptype_mask & deptype.RESOLVE_ALL
+
       # the "rule weight" is the sum of the rules' priorities
       #  it's used to compare/sort dependency pools with
       #  the same priority (lesser weight is better)
@@ -75,56 +67,50 @@ class DependencyRulePool ( object ):
 
    def empty ( self ):
       """Returns True if this pool has no rules."""
-      return len ( self.rules ) == 0
+      for rule in self.iter_rules():
+         return False
+      return True
    # --- end of empty (...) ---
 
+   @roverlay.util.objects.abstractmethod
+   def sort_rules ( self ):
+      pass
+   # --- end of sort_rules (...) ---
+
    def sort ( self ):
       """Sorts this rule pool and determines its weight which is used
       to compare rule pools.
       """
-
-      self.rules.sort ( key=lambda rule : rule.priority )
-
-      rule_priority_sum = 0
-      for r in self.rules: rule_priority_sum += r.priority
-      self.rule_weight = rule_priority_sum
-
-      return None
+      self.sort_rules()
+      self.set_rule_weight()
    # --- end of sort (...) ---
 
-   def accepts_mask ( self, deptype_mask ):
-      """Returns True if this pool accepts the given deptype_mask."""
-      return bool ( self.deptype_mask & deptype_mask )
-   # --- end of accepts_mask (...) ---
-
-   def accepts ( self, dep_env ):
-      """Returns True if this pool accepts the given dep env."""
-      return bool ( self.deptype_mask & dep_env.deptype_mask )
-   # --- end of accepts (...) ---
-
-   def accepts_other ( self, dep_env ):
-      """Returns True if this pool can be used to resolve a dep env whose
-      deptype mask is rejected by this pool.
-      (Not necessarily the inverse of accepts().)
-      """
-      return not self.accepts ( dep_env )
-   # --- end of accepts_other (...) ---
+   @roverlay.util.objects.abstractmethod
+   def iter_rules ( self ):
+      return
+   # --- end of iter_rules (...) ---
 
-   def add ( self, rule ):
-      """Adds a DependencyRule to this rule pool.
+   @roverlay.util.objects.abstractmethod ( params=[ 'dep_env' ] )
+   def iter_rules_resolving ( self, dep_env ):
+      pass
+   # --- end of iter_rules_resolving (...) ---
 
-      arguments:
-      * rule --
-      """
-      if issubclass ( rule, DependencyRule ):
-         self._rule_add ( rule )
-      else:
-         raise Exception ( "bad usage (dependency rule expected)." )
+   def get_all_matches ( self, dep_env ):
+      for rule in self.iter_rules_resolving ( dep_env ):
+         result = rule.matches ( dep_env )
+         if result:
+            yield result
+   # --- end of get_all_matches (...) ---
 
+   def matches ( self, dep_env ):
+      for rule in self.iter_rules_resolving ( dep_env ):
+         result = rule.matches ( dep_env )
+         if result:
+            return result
       return None
-   # --- end of add (...) ---
+   # --- end of matches (...) ---
 
-   def matches ( self, dep_env, skip_matches=0 ):
+   def matches_all ( self, dep_env, skip_matches=0 ):
       """Tries to find a match in this dependency rule pool.
       The first match is immediatly returned unless skip_matches is != 0, in
       which case the first (>0) / last (<0) skip_matches matches are skipped.
@@ -141,35 +127,55 @@ class DependencyRulePool ( object ):
          #  cannot expect a result in this case - abort now
          pass
 
-      elif skip_matches == 0:
-         for rule in self.rules:
-            result = rule.matches ( dep_env )
-            if result:
-               return result
-      else:
+      elif skip_matches >= 0:
          skipped = 0
-         # python3 requires list ( range ... )
-         order = list ( range ( len ( self.rules ) ) )
-
-         if skip_matches < 0:
-            skip_matches *= -1
-            order.reverse()
+         for result in self.get_all_matches ( dep_env ):
+            if skipped < skip_matches:
+               skipped += 1
+            else:
+               return result
 
-         for index in order:
-            result = self.rules [index].matches ( dep_env )
-            if result:
-               if skipped < skip_matches:
-                  skipped += 1
-               else:
-                  return result
+      else:
+         matches = list ( self.get_all_matches() )
+         try:
+            return matches [skip_matches]
+         except IndexError:
+            pass
 
       # default return
       return None
-   # --- end of matches (...) ---
+   # --- end of matches_all (...) ---
+
+   def set_rule_weight ( self ):
+      priosum = 0
+      for rule in self.iter_rules():
+         priosum += rule.priority
+      self.rule_weight = priosum
+      return self.rule_weight
+   # --- end of set_rule_weight (...) ---
+
+   def accepts_mask ( self, deptype_mask ):
+      """Returns True if this pool accepts the given deptype_mask."""
+      return bool ( self.deptype_mask & deptype_mask )
+   # --- end of accepts_mask (...) ---
+
+   def accepts ( self, dep_env ):
+      """Returns True if this pool accepts the given dep env."""
+      return bool ( self.deptype_mask & dep_env.deptype_mask )
+   # --- end of accepts (...) ---
+
+   @roverlay.util.objects.abstractmethod
+   def accepts_other ( self, dep_env ):
+      """Returns True if this pool can be used to resolve a dep env whose
+      deptype mask is rejected by this pool.
+      (Not necessarily the inverse of accepts().)
+      """
+      pass
+   # --- end of accepts_other (...) ---
 
    def export_rules ( self ):
       """Exports all rules. Typically, this generates text lines."""
-      for rule in self.rules:
+      for rule in self.iter_rules():
          for item in rule.export_rule():
             yield item
    # --- end of export_rules (...) ---
@@ -184,4 +190,85 @@ class DependencyRulePool ( object ):
       for item in self.export_rules():
          fh.write ( str ( item ) )
          fh.write ( NL )
+   # --- end of exports_rules_into (...) ---
+
+# --- end of DependencyRulePoolBase ---
+
+
+class DependencyRulePool ( DependencyRulePoolBase ):
+
+   def __init__ ( self, name, priority, deptype_mask, initial_rules=None ):
+      """Initializes an DependencyRulePool, which basically is a set of
+      dependency rules with methods like "search for x in all rules."
+
+      arguments:
+      * name -- name of this rule pool
+      * priority -- priority of this pool (lower is better)
+      """
+      super ( DependencyRulePool, self ).__init__(
+         name, priority, deptype_mask
+      )
+      if initial_rules is None:
+         self.rules = list()
+      else:
+         self.rules = list ( initial_rules )
+      self._rule_add    = self.rules.append
+   # --- end of __init__ (...) ---
+
+   def iter_rules ( self ):
+      return iter ( self.rules )
+   # --- end of iter_rules (...) ---
+
+   def iter_rules_resolving ( self, dep_env ):
+      return iter ( self.rules )
+   # --- end of iter_rules_resolving (...) ---
+
+   def empty ( self ):
+      """Returns True if this pool has no rules."""
+      return len ( self.rules ) == 0
+   # --- end of empty (...) ---
+
+   def sort_rules ( self ):
+      """Sorts this rule pool and determines its weight which is used
+      to compare rule pools.
+      """
+      self.rules.sort ( key=lambda rule : rule.priority )
+   # --- end of sort_rules (...) ---
+
+   def accepts_other ( self, dep_env ):
+      """Returns True if this pool can be used to resolve a dep env whose
+      deptype mask is rejected by this pool.
+      (Not necessarily the inverse of accepts().)
+      """
+      return not self.accepts ( dep_env )
+   # --- end of accepts_other (...) ---
+
+   def add ( self, rule ):
+      """Adds a DependencyRule to this rule pool.
+
+      arguments:
+      * rule --
+      """
+      if issubclass ( rule, DependencyRule ):
+         self._rule_add ( rule )
+      else:
+         raise Exception ( "bad usage (dependency rule expected)." )
+
+      return None
+   # --- end of add (...) ---
+
 # --- end of DependencyRulePool ---
+
+
+class DynamicDependencyRulePool ( DependencyRulePoolBase ):
+
+   @roverlay.util.objects.abstractmethod
+   def reload ( self ):
+      pass
+   # --- end of reload (...) ---
+
+   def accepts_other ( self, dep_env ):
+      return False
+   # --- end of accepts_other (...) ---
+
+# --- end of DynamicDependencyRulePool ---

diff --git a/roverlay/depres/simpledeprule/dynpool.py b/roverlay/depres/simpledeprule/dynpool.py
index 21e5a1b..7688bf1 100644
--- a/roverlay/depres/simpledeprule/dynpool.py
+++ b/roverlay/depres/simpledeprule/dynpool.py
@@ -18,36 +18,72 @@ whose dependency type contains deptype.internal.
 
 __all__ = [ 'DynamicSelfdepRulePool', 'get' ]
 
+import collections
+
 from roverlay.depres import deptype
-from roverlay.depres.simpledeprule.pool import SimpleDependencyRulePool
+from roverlay.depres.deprule import DynamicDependencyRulePool
 from roverlay.depres.simpledeprule.rules import SimpleFuzzyDependencyRule
 
-class DynamicSelfdepRulePool ( SimpleDependencyRulePool ):
+class DynamicSelfdepRulePool ( DynamicDependencyRulePool ):
    """A rule pool that gets its rules from a function."""
 
-   def __init__ ( self, rule_kw_function, rule_class, priority=120, **kwargs ):
+   def __init__ ( self, rule_generator, rule_class, priority=120, **kwargs ):
       super ( DynamicSelfdepRulePool, self ). __init__ (
          name='dynamic selfdeps', priority=priority,
          deptype_mask=deptype.internal,
          **kwargs
       )
 
-      self._rule_class       = rule_class
-      self._rule_kw_function = rule_kw_function
+      self.rules           = None
+      self._rule_generator = rule_generator
+      self.set_rule_class ( rule_class )
    # --- end of __init__ (...) ---
 
+   def sort_rules ( self ):
+      # TODO: sort self.rules itself ("sort repos")
+      priokey = lambda k: k.priority
+
+      if self.rules:
+         for rules in self.rules.values():
+            rules.sort ( key=priokey )
+   # --- end of sort_rules (...) ---
+
+   def iter_rules ( self ):
+      if self.rules:
+         for rules in self.rules.values():
+            for rule in rules:
+               yield rule
+   # --- end of iter_rules (...) ---
+
+   def iter_rules_resolving ( self, dep_env ):
+      specific_rules = self.rules.get ( dep_env.repo_id, None )
+      if specific_rules is not None:
+         for rule in specific_rules:
+            yield rule
+
+      for rules in self.rules.values():
+         if rules is not specific_rules:
+            for rule in rules:
+               yield rule
+   # --- end of iter_rules_resolving (...) ---
+
+   def set_rule_class ( self, rule_class ):
+      self._rule_generator.rule_class = rule_class
+   # --- end of set_rule_class (...) ---
+
    def accepts_other ( self, dep_env ):
       # never resolve external deps as selfdeps
       return False
    # --- end of accepts_other (...) ---
 
    def reload ( self ):
-      self.rules = list (
-         self._rule_class ( **kwargs ) for kwargs in self._rule_kw_function()
-      )
+      self.rules = self._rule_generator.make_rule_dict()
    # --- end of reload (...) ---
 
 
+# --- end of DynamicSelfdepRulePool ---
+
+
 def get ( rule_kw_function ):
    """Returns a default DynamicSelfdepRulePool for rule_kw_function."""
    return DynamicSelfdepRulePool (