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

[André Erdmann]

commit:     bd91581d7a6cc12e2cfe9aa45a69ac5cdfdc6f67
Author:     André Erdmann <dywi <AT> mailerd <DOT> de>
AuthorDate: Tue Jul  2 20:58:50 2013 +0000
Commit:     André Erdmann <dywi <AT> mailerd <DOT> de>
CommitDate: Tue Jul  2 20:58:50 2013 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/R_overlay.git;a=commit;h=bd91581d

roverlay/depres: configurable slot values

This commit (mainly) adds feature to FuzzySlotDependencyRule
* the relevant parts of a version string that make up the slot or subslot value
  are configurable now
* slot rule modes: "open", "with version", "default"
* slot range restrict has been removed

---
 roverlay/depres/depenv.py              |  16 ++
 roverlay/depres/simpledeprule/rules.py | 339 +++++++++++++++++----------------
 roverlay/depres/simpledeprule/util.py  | 160 ++++++++++++++++
 3 files changed, 350 insertions(+), 165 deletions(-)

diff --git a/roverlay/depres/depenv.py b/roverlay/depres/depenv.py
index 9371ef6..c298447 100644
--- a/roverlay/depres/depenv.py
+++ b/roverlay/depres/depenv.py
@@ -175,10 +175,26 @@ class DepEnv ( object ):
                # "normalize"
                vmod = '='
 
+            version_strlist = version.split ( '.' )
+            version_iparts  = list()
+
+            for v in version_strlist:
+               #i = None
+               try:
+                  i = int ( v )
+                  version_iparts.append ( i )
+               except ValueError:
+                  v2 = v.partition ( '_' )[0].partition ( '-' ) [0]
+                  version_iparts.append ( int ( v2 ) if v2 else 0 )
+
+
+
             result.append ( dict (
                name             = m.group ( 'name' ),
                version_modifier = vmod,
                version          = version,
+               version_strlist  = version_strlist,
+               version_tuple    = tuple ( version_iparts ),
                vmod             = self.VMOD.get ( vmod, self.VMOD_UNDEF ),
             ) )
 

diff --git a/roverlay/depres/simpledeprule/rules.py b/roverlay/depres/simpledeprule/rules.py
index ac3fa89..999a8b4 100644
--- a/roverlay/depres/simpledeprule/rules.py
+++ b/roverlay/depres/simpledeprule/rules.py
@@ -20,88 +20,15 @@ __all__ = (
    'SimpleFuzzyDependencyRule', 'SimpleFuzzyIgnoreDependencyRule'
 )
 
-from roverlay.depres.simpledeprule.abstractrules import \
-   SimpleRule, FuzzySimpleRule
-
-class SlotRestrict ( object ):
-   def accepts ( self, k ):
-      """Returns True if k is allowed, else False.
 
-      arguments:
-      * k -- int
-      """
-      return True
+from roverlay.depres.simpledeprule.util import \
+   RuleFileSyntaxError, get_slot_restrict, get_slot_parser
 
-   def __bool__ ( self ):
-      return True
-
-   def noexport ( self ):
-      pass
-
-   def __str__ ( self ):
-      return ':'
-# --- end of SlotRestrict ---
-
-class SlotRangeRestrict ( SlotRestrict ):
-   DEFAULT_LOW  = 0
-   DEFAULT_HIGH = 1000
-
-   def __init__ ( self, low, high ):
-      super ( SlotRangeRestrict, self ).__init__()
-      if low:
-         self.low = int ( low )
-      else:
-         self.low = self.DEFAULT_LOW
-         self._implicit_low = True
-
-      if high:
-         self.high = int ( high )
-      else:
-         self.high = self.DEFAULT_HIGH
-         self._implicit_high = True
-   # --- end of __init__ (...) ---
-
-   def noexport ( self ):
-      if hasattr ( self, '_implicit_low' ):
-         del self._implicit_low
-      if hasattr ( self, '_implicit_high' ):
-         del self._implicit_high
-   # --- end of noexport (...) ---
-
-   def accepts ( self, k ):
-      """Returns True if k is allowed, else False.
-
-      arguments:
-      * k -- int
-      """
-      return k >= self.low and k <= self.high
-
-   def __str__ ( self ):
-      return ":{low}..{high}".format (
-         low  = ( '' if hasattr ( self, '_implicit_low'  ) else self.low  ),
-         high = ( '' if hasattr ( self, '_implicit_high' ) else self.high ),
-      )
-   # --- end of __str__ (...) ---
-
-# --- end of SlotRangeRestrict ---
-
-class SlotSetRestrict ( SlotRestrict ):
-   def __init__ ( self, iterable ):
-      self._iset = frozenset ( int ( k ) for k in iterable )
-
-   def accepts ( self, k ):
-      """Returns True if k is allowed, else False.
+from roverlay.depres.simpledeprule.abstractrules import \
+   SimpleRule, FuzzySimpleRule
 
-      arguments:
-      * k -- int
-      """
-      return k in self._iset
 
-   def __str__ ( self ):
-      return ':' + ','.join ( str ( k ) for k in sorted ( self._iset ) )
-   # --- end of __str__ (...) ---
 
-# --- end of SlotSetRestrict ---
 
 class RuleConstructor ( object ):
 
@@ -123,61 +50,85 @@ class RuleConstructor ( object ):
          return ( SimpleFuzzyIgnoreDependencyRule, get_kwless(), {} )
       elif kw == self.kw_fuzzy:
          ## syntax
-         ## ~cat/pkg:<slot range>:<slot suffix>
-         kwless = get_kwless()
-         resolving, sepa, remainder = kwless.partition ( ':' )
-
-         if sepa:
-            # fuzzy slot rule
+         ## ~<cat>/<pkg>[:[<slot option>]]*
+         ##  where slot option is any of
+         ##  * slot restrict (range, list)
+         ##  * "with version", "open" ("*" and "=" slot operators)
+         ##  * relevant version parts ("1.2.3.4" => "1" if 1, "1.2" if 2, ...)
+         ##  * relevant subslot version parts ("1.2.3.4" => <SLOT>/<SUBSLOT?>)
+         ##  * slot operator ("=")
+
+         kwless          = get_kwless()
+         line_components = kwless.split ( ':' )
+
+         if len ( line_components ) < 2:
+            # non-slot fuzzy rule
+            return ( SimpleFuzzyDependencyRule, kwless, {} )
+         else:
             kwargs = dict()
-            slot_head, slot_sepa, slot_rem = remainder.partition ( ':' )
-
-            if slot_sepa:
-               # int range restriction
-               istart, isepa, istop = slot_head.partition ( '..' )
-               if isepa:
-                  kwargs ['slot_restrict'] = SlotRangeRestrict (
-                     low=istart, high=istop
-                  )
-               else:
-                  # int list restriction
+            lc_iter = iter ( line_components )
+            # drop first item as it's the resolving string and not an option
+            next ( lc_iter )
+            for opt_str in lc_iter:
+               opt, has_value, value = opt_str.partition ( '=' )
 
-                  # "filter(None,...)" filters 0 but not '0'
-                  istr_list = list (
-                     filter ( None, slot_head.split ( ',' ) )
-                     #filter ( lambda s : s or s == 0, slot_head.split ( ',' ) )
-                  )
+               if not opt_str:
+                  # empty
+                  pass
+               elif opt == 'default':
+                  kwargs ['slot_mode'] = 0
 
-                  if istr_list:
-                     kwargs ['slot_restrict'] = SlotSetRestrict ( istr_list )
+               elif opt == 'with_version' or opt == '+v':
+                  kwargs ['slot_mode'] = 1
 
-               remainder = slot_rem
-            else:
-               #kwargs ['slot_restrict'] = SlotRestrict()
-               remainder = slot_head
-            # -- end if;
-
-            if remainder[:2] == '+v':
-               kwargs ['with_version'] = True
-               remainder = remainder[2:]
-            # -- end if;
-
-            if not remainder:
-               pass
-            elif remainder[0] in { '/', '*', '=' }:
-               # subslot, "any slot" operators
-               # (subslots don't seem to make much sense here)
-
-               ##if self.eapi < 5: raise ...
-               kwargs ['slot_suffix'] = remainder
+               elif opt == 'open':
+                  kwargs ['slot_mode'] = 2
+
+               elif ( opt == 'restrict' or opt == 'r' ) and value:
+                  kwargs ['slot_restrict'] = get_slot_restrict ( value )
+
+               elif ( opt == 'slotparts' or opt == 's' ) and value:
+                  kwargs ['slotparts'] = get_slot_parser ( value )
+
+               elif ( opt == 'subslotparts' or opt == '/' ) and value:
+                  kwargs ['subslotparts'] = get_slot_parser ( value )
+
+               elif opt_str[0] == '/' and not has_value:
+                  kwargs ['subslotparts'] = get_slot_parser ( opt_str[1:] )
+
+#               elif opt == 'operator' and value:
+#                  # unsafe, could be used to inject "$(rm -rf /)" etc.
+#                  kwargs ['slot_operator'] = value
+
+               elif opt == '*':
+                  kwargs ['slot_operator'] = '*'
+
+               elif not opt and has_value:
+                  # "="
+                  kwargs ['slot_operator'] = '='
+                  pass
+
+               else:
+                  raise RuleFileSyntaxError (
+                     "cannot parse option {!r} from {!r}".format (
+                        opt_str, kwless
+                     )
+                  )
+            # -- end for lc_iter
+
+            if (
+               kwargs.get ( 'slot_operator' ) == '*'
+               and kwargs.get ( 'slot_mode' ) != 2
+            ):
+               raise RuleFileSyntaxError (
+                  "The '*' slot operator needs an 'open' rule."
+               )
             else:
-               raise Exception (
-                  "unknown slot rule remainder {!r}".format ( remainder )
+               return (
+                  SimpleFuzzySlotDependencyRule, line_components[0], kwargs
                )
+         # -- end if line_components
 
-            return ( SimpleFuzzySlotDependencyRule, resolving, kwargs )
-         else:
-            return ( SimpleFuzzyDependencyRule, kwless, {} )
       else:
          return ( SimpleDependencyRule, keyworded_str, {} )
    # --- end of lookup (...) ---
@@ -295,9 +246,11 @@ class SimpleFuzzySlotDependencyRule ( FuzzySimpleRule ):
    def __init__ ( self,
       priority          = 71,
       resolving_package = None,
-      slot_suffix       = None,
+      slot_mode         = None,
       slot_restrict     = None,
-      with_version      = False,
+      slotparts         = None,
+      subslotparts      = None,
+      slot_operator     = None,
       **kw
    ):
       super ( SimpleFuzzySlotDependencyRule, self ) . __init__ (
@@ -307,39 +260,93 @@ class SimpleFuzzySlotDependencyRule ( FuzzySimpleRule ):
          **kw
       )
 
-      self.slot_suffix   = slot_suffix
+      self.mode          = 0 if slot_mode is None else slot_mode
       self.slot_restrict = slot_restrict
-
-      if with_version:
+      self.slot_operator = slot_operator
+      self.slotparts     = get_slot_parser ("0") if slotparts is None else slotparts
+      self.subslotparts  = subslotparts
+
+      if self.mode == 0:
+         # "default"
+         self._resolving_fmt = self.resolving_package + ':{slot}'
+         if self.slot_operator:
+            self._resolving_fmt += self.slot_operator
+
+      elif self.mode == 1:
+         # "with version"
          self._resolving_fmt = (
             '{vmod}' + self.resolving_package + '-{version}:{slot}'
-            + ( slot_suffix or '' )
          )
-         self.with_version = True
+         if self.slot_operator:
+            self._resolving_fmt += self.slot_operator
+
+      elif self.mode == 2:
+         # "open" slot
+         if not self.slot_operator:
+            self.slot_operator = '='
+
+         del self.slot_restrict
+
+         self._orig_resolving_package = self.resolving_package
+         self.resolving_package += ':' + self.slot_operator
       else:
-         self._resolving_fmt = (
-            self.resolving_package + ':{slot}' + ( slot_suffix or '' )
+         raise Exception (
+            "unknown fuzzy slot rule mode {}".format ( self.mode )
          )
-         self.with_version = False
+
+
 
       if self.is_selfdep:
          raise NotImplementedError ( "fuzzy slot rule must not be a selfdep." )
    # --- end of __init__ (...) ---
 
    def noexport ( self ):
-      del self.slot_suffix
-      del self.with_version
+      del self.slot_operator
+      del self.mode
       if self.slot_restrict:
          self.slot_restrict.noexport()
    # --- end of noexport (...) ---
 
    def get_resolving_str ( self ):
-      return "{prefix}{resolv}{restrict}:{flags}{slot}".format (
-         prefix   = self.RULE_PREFIX,
-         resolv   = self.resolving_package,
-         restrict = ( self.slot_restrict or '' ),
-         flags    = ( '+v' if self.with_version else '' ),
-         slot     = ( self.slot_suffix or '' ),
+      ## syntax
+      ## ~<cat>/<pkg>[:[<slot option>]]*
+      ##  where slot option is any of
+      ##  * slot restrict (range, list)
+      ##  * "with version", "open" ("*" and "=" slot operators)
+      ##  * relevant version parts ("1.2.3.4" => "1" if 1, "1.2" if 2, ...)
+      ##  * relevant subslot version parts ("1.2.3.4" => <SLOT>/<SUBSLOT?>)
+      ##  * slot operator ("=")
+
+      def gen_opts():
+         if self.mode == 2:
+            yield "open"
+         else:
+            if self.mode == 1:
+               yield "with_version"
+
+            if self.slot_restrict:
+               yield "restrict=" + str ( self.slot_restrict )
+
+            if self.slotparts and (
+               not hasattr ( self.slotparts, '_index' )
+               or  self.slotparts._index != 0
+            ):
+               yield "s=" + str ( self.slotparts )
+
+            if self.subslotparts:
+               yield "/" + str ( self.subslotparts )
+         # -- end if
+         if self.slot_operator:
+            yield self.slot_operator
+
+      return "{prefix}{resolv}:{opts}".format (
+         prefix = self.RULE_PREFIX,
+         resolv = (
+            self._orig_resolving_package
+            if hasattr ( self, '_orig_resolving_package' )
+            else self.resolving_package,
+         ),
+         opts   = ':'.join ( gen_opts() )
       )
    # --- end of get_resolving_str (...) ---
 
@@ -350,28 +357,30 @@ class SimpleFuzzySlotDependencyRule ( FuzzySimpleRule ):
       if not ( vmod & dep_env.VMOD_NOT ):
          # can be resolved as slot(ted) dep
 
-         ver_str = fuzzy ['version']
-         v_major, sepa, v_remainder = ver_str.partition ( '.' )
-         try:
-            # TODO/FIXME: slot != int(v_major);
-            #  example: sci-libs/fftw where slots are K.J (2.1, 3.0)
-            slot = int ( v_major )
-
-            # resolve '<' and '>' by decrementing/incrementing slot
-            if vmod == dep_env.VMOD_LT:
-               slot -= 1
-            elif vmod == dep_env.VMOD_GT:
-               slot += 1
-
-            if not self.slot_restrict or self.slot_restrict.accepts ( slot ):
-               res = self._resolving_fmt.format (
-                  slot=slot,
-                  version=ver_str,
-                  vmod=fuzzy ['version_modifier'],
-               )
-         except ValueError:
-            pass
-      # -- end if vmod
+         if self.mode == 2:
+            res = self._resolving_str
+         elif vmod & dep_env.VMOD_EQ:
+            slot_str = None
+            slot     = self.slotparts.get_slot ( fuzzy )
+
+            if slot is not None:
+               if self.subslotparts:
+                  subslot = self.subslotparts.get_slot ( fuzzy )
+                  if subslot is not None:
+                     slot_str = slot + '/' + subslot
+               else:
+                  slot_str = slot
+
+               if slot_str and (
+                  not self.slot_restrict
+                  or self.slot_restrict.accepts ( slot )
+               ):
+                  res = self._resolving_fmt.format (
+                     slot=slot_str,
+                     version=fuzzy['version'], vmod=fuzzy['version_modifier']
+                  )
+
+      # -- end if vmod != NOT
 
       return res
    # --- end of handle_version_relative_match (...) ---

diff --git a/roverlay/depres/simpledeprule/util.py b/roverlay/depres/simpledeprule/util.py
new file mode 100644
index 0000000..0a8311c
--- /dev/null
+++ b/roverlay/depres/simpledeprule/util.py
@@ -0,0 +1,160 @@
+# R overlay -- simple dependency 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.
+
+
+class RuleFileSyntaxError ( Exception ):
+   pass
+
+
+def get_int_range_or_list (
+   value_str, default_low=0, default_high=1000, list_sepa=','
+):
+   low, sepa, high = value_str.partition ( '..' )
+   if sepa:
+      i_low  = int ( low ) if low else default_low
+      i_high = (
+         int ( high ) if high else (
+            i_low if default_high is True else default_high
+         )
+      )
+      return ( True, i_low, i_high )
+   else:
+      return ( False,
+         tuple ( int ( k ) for k in value_str.split ( list_sepa ) )
+      )
+# --- end get_int_range_or_list (...) ---
+
+
+
+class SlotRestrict ( object ):
+   def accepts ( self, k ):
+      """Returns True if k is allowed, else False.
+
+      arguments:
+      * k -- int
+      """
+      return True
+
+   def __bool__ ( self ):
+      return True
+
+   def noexport ( self ):
+      pass
+
+   def __str__ ( self ):
+      return ''
+# --- end of SlotRestrict ---
+
+class SlotSetRestrict ( SlotRestrict ):
+   def __init__ ( self, iterable ):
+      self._slotset = frozenset ( iterable )
+
+   def accepts ( self, k ):
+      """Returns True if k is allowed, else False.
+
+      arguments:
+      * k -- slot (str)
+      """
+      return k in self._slotset
+
+   def __str__ ( self ):
+      return ','.join ( sorted ( self._slotset ) )
+   # --- end of __str__ (...) ---
+
+# --- end of SlotSetRestrict ---
+
+class SlotValueCreatorBase ( object ):
+
+   def get_slot ( self, *args, **kwargs ):
+      raise NotImplementedError()
+   # --- end of get_slot (...) ---
+
+   def __str__ ( self ):
+      raise NotImplementedError()
+   # --- end of __str__ (...) ---
+
+
+class ImmediateSlotValueCreator ( SlotValueCreatorBase ):
+   def __init__ ( self, v_str ):
+      super ( ImmediateSlotValueCreator, self ).__init__()
+      self._value = v_str
+   # --- end of __init__ (...) ---
+
+   def get_slot ( self, *args, **kwargs ):
+      return self._value
+   # --- end of get_slot (...) ---
+
+   def __str__ ( self ):
+      return "i" + self._value
+
+class SingleIndexValueCreator ( SlotValueCreatorBase ):
+   def __init__ ( self, index ):
+      super ( SingleIndexValueCreator, self ).__init__()
+      self._index = index
+   # --- end of __init__ (...) ---
+
+   def get_slot ( self, fuzzy ):
+      version_components = fuzzy ['version_strlist']
+      if len ( version_components ) > self._index:
+         return version_components [self._index]
+      else:
+         return None
+   # --- end of get_slot (...) ---
+
+   def __str__ ( self ):
+      return str ( self._index )
+
+
+class IndexRangeSlotValueCreator ( SlotValueCreatorBase ):
+   def __init__ ( self, low, high ):
+      super ( IndexRangeSlotValueCreator, self ).__init__()
+      self._low  = low
+      self._high = high + 1 if high >= 0 else high
+
+   def get_slot ( self, fuzzy ):
+      # if self._low > self._high
+      # if self._high < 0: -- dont care
+      version_components = fuzzy ['version_strlist']
+      if len ( version_components ) >= self._high:
+         return '.'.join ( version_components [self._low:self._high] )
+      else:
+         return None
+   # --- end of get_slot (...) ---
+
+   def __str__ ( self ):
+      return str ( self._low ) + '..' + str (
+         ( self._high - 1 ) if self._high > 0 else self._high
+      )
+
+
+def get_slot_parser ( vstr ):
+   if vstr [0] == 'i':
+      # "immediate" value
+      s = vstr [1:]
+      return ImmediateSlotValueCreator ( v_str=s )
+   else:
+      range_or_list = get_int_range_or_list ( vstr, default_high=True )
+      if range_or_list [0]:
+         if range_or_list[1] == range_or_list[2]:
+            return SingleIndexValueCreator ( index=range_or_list[1] )
+         else:
+            return IndexRangeSlotValueCreator (
+               low=range_or_list[1], high=range_or_list[2]
+            )
+      elif len ( range_or_list[1] ) < 2:
+         return SingleIndexValueCreator ( index=range_or_list[1][0] )
+      else:
+         raise RuleFileSyntaxError (
+            "slot part selection must not be a list"
+         )
+# --- end of get_slot_parser (...) ---
+
+def get_slot_restrict ( vstr ):
+   if vstr:
+      return SlotSetRestrict ( vstr.split ( ',' ) )
+   else:
+      return None
+# --- end of get_slot_restrict (...) --