public inbox for gentoo-commits@lists.gentoo.org
 help / color / mirror / Atom feed
* [gentoo-commits] proj/R_overlay:gsoc13/next commit in: roverlay/depres/simpledeprule/
@ 2013-07-03 10:04 André Erdmann
  2013-07-03 10:05 ` [gentoo-commits] proj/R_overlay:master " André Erdmann
  0 siblings, 1 reply; 6+ messages in thread
From: André Erdmann @ 2013-07-03 10:04 UTC (permalink / raw
  To: gentoo-commits

commit:     6cb202e96bfd7e9e34bdc0abe64688595ab8142b
Author:     André Erdmann <dywi <AT> mailerd <DOT> de>
AuthorDate: Wed Jul  3 09:59:16 2013 +0000
Commit:     André Erdmann <dywi <AT> mailerd <DOT> de>
CommitDate: Wed Jul  3 10:03:57 2013 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/R_overlay.git;a=commit;h=6cb202e9

roverlay/depres: restrict calculated slot value

This commit changes the behavior when using slot restrictions.
A slot value is now accepted if the _calculated_ slot value (taken from the dep
strings version) is in the list of allowed values. This is only relevant for
rules that use "immediate" slot values.

---
 roverlay/depres/simpledeprule/rules.py | 26 ++++++++++------------
 roverlay/depres/simpledeprule/util.py  | 40 +++++++++++++++++++++++-----------
 2 files changed, 39 insertions(+), 27 deletions(-)

diff --git a/roverlay/depres/simpledeprule/rules.py b/roverlay/depres/simpledeprule/rules.py
index 999a8b4..dea5f38 100644
--- a/roverlay/depres/simpledeprule/rules.py
+++ b/roverlay/depres/simpledeprule/rules.py
@@ -308,15 +308,6 @@ class SimpleFuzzySlotDependencyRule ( FuzzySimpleRule ):
    # --- end of noexport (...) ---
 
    def get_resolving_str ( self ):
-      ## 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"
@@ -360,20 +351,27 @@ class SimpleFuzzySlotDependencyRule ( FuzzySimpleRule ):
          if self.mode == 2:
             res = self._resolving_str
          elif vmod & dep_env.VMOD_EQ:
-            slot_str = None
-            slot     = self.slotparts.get_slot ( fuzzy )
+            slot_str  = None
+            vslot_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
+                     slot_str  = slot + '/' + subslot
+                     vslot_str = (
+                        self.slotparts.calculate_slot ( fuzzy, slot )
+                        + '/'
+                        + self.subslotparts.calculate_slot ( fuzzy, subslot )
+                     )
                else:
-                  slot_str = slot
+                  vslot_str = self.slotparts.calculate_slot ( fuzzy, slot )
+                  slot_str  = slot
 
                if slot_str and (
                   not self.slot_restrict
-                  or self.slot_restrict.accepts ( slot )
+                  or self.slot_restrict.accepts ( vslot_str )
                ):
                   res = self._resolving_fmt.format (
                      slot=slot_str,

diff --git a/roverlay/depres/simpledeprule/util.py b/roverlay/depres/simpledeprule/util.py
index 0a8311c..0ce5aa4 100644
--- a/roverlay/depres/simpledeprule/util.py
+++ b/roverlay/depres/simpledeprule/util.py
@@ -68,6 +68,9 @@ class SlotSetRestrict ( SlotRestrict ):
 
 class SlotValueCreatorBase ( object ):
 
+   def calculate_slot ( self, fuzzy, slot_value ):
+      return slot_value
+
    def get_slot ( self, *args, **kwargs ):
       raise NotImplementedError()
    # --- end of get_slot (...) ---
@@ -77,19 +80,6 @@ class SlotValueCreatorBase ( object ):
    # --- 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__()
@@ -129,6 +119,30 @@ class IndexRangeSlotValueCreator ( SlotValueCreatorBase ):
          ( self._high - 1 ) if self._high > 0 else self._high
       )
 
+class ImmediateSlotValueCreator ( SlotValueCreatorBase ):
+   def __init__ ( self, v_str ):
+      super ( ImmediateSlotValueCreator, self ).__init__()
+      self._value = v_str
+      numparts = len ( v_str.split ( "." ) )
+      assert numparts > 0
+
+      if numparts < 2:
+         self._slot_calculator = SingleIndexValueCreator ( 0 )
+      else:
+         self._slot_calculator = IndexRangeSlotValueCreator ( 0, numparts-1 )
+   # --- end of __init__ (...) ---
+
+   def calculate_slot ( self, fuzzy, slot_value ):
+      cval = self._slot_calculator.get_slot ( fuzzy )
+      return slot_value if cval is None else cval
+   # --- end of calculate_slot (...) ---
+
+   def get_slot ( self, *args, **kwargs ):
+      return self._value
+   # --- end of get_slot (...) ---
+
+   def __str__ ( self ):
+      return "i" + self._value
 
 def get_slot_parser ( vstr ):
    if vstr [0] == 'i':


^ permalink raw reply related	[flat|nested] 6+ messages in thread
* [gentoo-commits] proj/R_overlay:master commit in: roverlay/depres/simpledeprule/
@ 2013-07-23  7:51 André Erdmann
  2013-07-19 18:00 ` [gentoo-commits] proj/R_overlay:gsoc13/next " André Erdmann
  0 siblings, 1 reply; 6+ messages in thread
From: André Erdmann @ 2013-07-23  7:51 UTC (permalink / raw
  To: gentoo-commits

commit:     85ff4fac2f8260042d242da5f28fea2532520c03
Author:     André Erdmann <dywi <AT> mailerd <DOT> de>
AuthorDate: Fri Jul 19 17:40:51 2013 +0000
Commit:     André Erdmann <dywi <AT> mailerd <DOT> de>
CommitDate: Fri Jul 19 17:40:51 2013 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/R_overlay.git;a=commit;h=85ff4fac

remove old depres console

---
 roverlay/depres/simpledeprule/console.py | 674 -------------------------------
 1 file changed, 674 deletions(-)

diff --git a/roverlay/depres/simpledeprule/console.py b/roverlay/depres/simpledeprule/console.py
deleted file mode 100644
index a845d41..0000000
--- a/roverlay/depres/simpledeprule/console.py
+++ /dev/null
@@ -1,674 +0,0 @@
-# R overlay -- simple dependency rules, console
-# -*- coding: utf-8 -*-
-# Copyright (C) 2012 André Erdmann <dywi@mailerd.de>
-# Distributed under the terms of the GNU General Public License;
-# either version 2 of the License, or (at your option) any later version.
-
-"""dependency resolution console
-
-This module provides console access to a (self-managed) dependency resolver
-and is meant for testing.
-
-Furthermore, its commands can be given through a stdin-pipe:
-echo -e 'lc\n? <dep str>\n? <dep str2>' | roverlay depres
-"""
-__all__ = [ 'DepResConsole', ]
-
-import re
-import os
-import sys
-import shlex
-import logging
-
-from roverlay                                import config, strutil
-from roverlay.errorqueue                     import ErrorQueue
-from roverlay.depres                         import deptype
-from roverlay.depres.depresolver             import DependencyResolver
-from roverlay.depres.channels                import EbuildJobChannel
-from roverlay.depres.simpledeprule           import rules
-from roverlay.depres.simpledeprule.pool      import SimpleDependencyRulePool
-from roverlay.depres.simpledeprule.rulemaker import SimpleRuleMaker
-
-class PackageDirRuleMaker ( object ):
-   """Scans a distdir and creates selfdep rules for it.
-   Part of the console module 'cause only used here. The overlay package
-   has its own implementation that automatically uses all added packages
-   for resolving dependencies.
-   """
-   def __init__ ( self, fuzzy=True ):
-      """Initializes a PackageDirRuleMaker that will create fuzzy rules if
-      'fuzzy' is True, else normal ones.
-      """
-      self.fuzzy = fuzzy
-      self.package_regex = re.compile (
-         "^(?P<name>[^_]+)_.+{}$".format (
-            config.get_or_fail ( 'R_PACKAGE.suffix_regex' )
-         )
-      )
-   # --- end of __init__ (...) ---
-
-   def _scan ( self, distdir ):
-      """
-      Traverses through a distdir and yields the names of found R packages.
-
-      arguments:
-      * distdir --
-      """
-      for dirpath, dirnames, filenames in os.walk ( distdir ):
-         for filename in filenames:
-            m = self.package_regex.match ( filename )
-            if m is not None:
-               yield m.group ( 'name' )
-   # --- end of _scan (...) ---
-
-   def make_rules ( self, distdir ):
-      """Consecutively creates and yields dependency rules for R packages
-      found in the given distdir.
-
-      arguments:
-      * distdir --
-      """
-      cat = config.get_or_fail ( 'OVERLAY.category' ) + '/'
-      if self.fuzzy:
-         for dep in self._scan ( distdir ):
-            yield rules.SimpleFuzzyDependencyRule (
-               resolving_package = strutil.fix_ebuild_name ( cat + dep ),
-               dep_str = dep,
-               is_selfdep=2
-            )
-      else:
-         for dep in self._scan ( distdir ):
-            yield rules.SimpleDependencyRule (
-               resolving_package = strutil.fix_ebuild_name ( cat + dep ),
-               dep_str = dep,
-               is_selfdep=2
-            )
-   # --- end of make_rules (...) ---
-
-
-class DepResConsole ( object ):
-   # !! The console is really inefficient in terms of using cached data,
-   # saving functions calls, ...
-   # It's assumed that the user is still slower ;)
-
-   shlex      = shlex.shlex()
-   whitespace = re.compile ( "\s+" )
-
-   # the command usage dict
-   CMD_USAGE = {
-      'add_pool' : """
-         Creates a new pool on top of any existing ones.
-
-         Arguments: None (ignored)
-
-         Usage:
-         * add_pool|<<
-      """,
-      'addrule' : """
-         Creates a new dependency rule and adds it to the current rule pool.
-         The console supports single-line rules only at this time.
-
-         Arguments: a list of quoted rule strings if shlex mode is active,
-         else one rule string
-
-         Usage:
-         * +|addrule <rule>
-         * +|addrule "<rule>" ["<rule>"]*
-
-      """,
-      'help' : """
-         Prints a general help message, a list of all help topics if --list\\
-         is given, or a specific help message for the given command.
-
-         Arguments: None, '--list', or a command
-
-         Usage:
-         * help
-         * help --list
-         * help <command>
-      """,
-      'load' : """
-         Loads a rule file or directory into a new dependency rule pool.
-
-         Arguments: a file
-
-         Usage:
-         * load|li|l <file|dir>
-      """,
-      'load_conf' : """
-         Loads the rule files listed in the config file.
-
-         Arguments: None (ignored)
-
-         Usage:
-         * load_conf|lc
-      """,
-      'mkhelp' : """
-         Verifies that all usable commands have a help message.
-
-         Arguments: None (ignored)
-
-         Usage:
-         * mkhelp
-      """,
-      'print': """
-         Prints the content of the current pool or all pools.
-
-         Arguments: 'all' (=> print all pools)
-
-         Usage:
-         * print
-         * print all
-      """,
-      'resolve': """
-         Resolves one or more dependency strings.
-
-         Arguments: a list of quoted dependency strings if shlex mode is\\
-         active, else one dependency string.
-
-         Usage:
-         * resolve|r|? <dependency string>
-         * resolve|r|? "<dependency string>" ["<dependency string>"]*
-      """,
-      'scandir' : """
-         Scans a directory for R packages and creates dependency rules\\
-         for them.
-
-         Arguments: a directory
-
-         Usage:
-         * scandir|sd <directory>
-      """,
-      'set' : """
-         Set or unset modes. Prints all modes and their state when called\\
-         with no args.
-         Currently, the only available mode is 'shlex' which enables/disables\\
-         shell-like argument parsing.\\
-         Shlex mode allows to specify more than one arg when running certain
-         commands, but requires args to be enclosed with quotes.
-
-         Arguments: None or a mode
-
-         Usage:
-         * set
-         * unset
-         * set <mode>
-         * unset <mode>
-      """,
-      'unwind' : """
-         Removes the top-most (latest) dependency rule pool and all of its\\
-         rules.
-
-         Arguments: None (ignored)
-
-         Usage:
-         * unwind|>>
-      """,
-      'write' : """
-         Writes the rules of the top-most (latest) dependency rule pool to\\
-         a file that later be loaded.
-
-         Arguments: file to write
-
-         Usage:
-         * write|w <file>
-      """,
-      'cd' : """
-         Changes the working directory to the given one. Also creates it\\
-         if necessary.
-
-         Arguments: a directory
-
-         Usage:
-         * cd <directory>
-      """,
-   }
-
-   CMD_USAGE_REDIRECT = {
-      'r'     : 'resolve',
-      '?'     : 'resolve',
-      'sd'    : 'scandir',
-      '+'     : 'addrule',
-      'li'    : 'load',
-      'l'     : 'load',
-      'lc'    : 'load_conf',
-      'w'     : 'write',
-      'p'     : 'print',
-      '>>'    : 'unwind',
-      '<<'    : 'add_pool',
-      'unset' : 'set',
-      'h'     : 'help',
-   }
-
-   def _create_command_table ( self ):
-      # the command table
-      #  each command string is mapped to a function/method
-      self.cmd_table = {
-         'resolve'   : self.cmd_resolve,
-         'scandir'   : self.cmd_rule_scandir,
-         'addrule'   : self.cmd_rule_add,
-         'load'      : self.cmd_rule_load,
-         'load_conf' : self.cmd_rule_load_from_config,
-         'write'     : self.cmd_pool_write,
-         'print'     : self.cmd_pool_print,
-         'unwind'    : self.cmd_pool_unwind,
-         'add_pool'  : self.cmd_pool_add,
-         'cd'        : self.cmd_cd,
-         'set'       : self.cmd_set,
-         'unset'     : self.cmd_unset,
-         'help'      : self.cmd_help,
-         'mkhelp'    : self.cmd_mkhelp,
-      }
-
-      for alias, real in self.__class__.CMD_USAGE_REDIRECT.items():
-         self.cmd_table [alias] = self.cmd_table [real]
-   # --- end of _create_command_table (...) ---
-
-   def _get_usage ( self, func_name ):
-      """Returns the usage string for the given function (by name).
-
-      arguments:
-      * func_name
-      """
-      if func_name in self.__class__.CMD_USAGE_REDIRECT:
-         fname = self.__class__.CMD_USAGE_REDIRECT [func_name]
-      else:
-         fname = func_name
-
-      if fname not in self._usage_dict:
-         lines = list()
-         for line in self.__class__.CMD_USAGE [fname].split ( '\n' ):
-            line = line.strip()
-            if len ( line ) or len ( lines ):
-               lines.append ( line )
-
-         if len ( lines ) and not len ( lines [-1] ):
-            lines.pop()
-
-         self._usage_dict [fname] = '\n'.join ( lines ).replace ( '\\\n', ' ' )
-
-      return self._usage_dict [fname]
-   # --- end of _get_usage (...) ---
-
-   def _print_usage ( self, func_name ):
-      """Prints a usage message for the given function (by name)."""
-      print (
-         "command {!r}, usage:\n".format ( func_name ) + \
-         self._get_usage ( func_name )
-      )
-   # --- end of _print_usage (...) ---
-
-   def usage ( self ):
-      """Prints a usage message for the command currently running and
-      returns False."""
-      self._print_usage ( self._current_command )
-      return False
-   # --- end of usage (...) ---
-
-   def __init__ ( self ):
-      """Initializes a dependency resolution console."""
-      self.err_queue = ErrorQueue()
-
-      # set up the resolver
-      self.resolver = DependencyResolver ( err_queue=self.err_queue )
-      # log everything
-      self.resolver.set_logmask ( -1 )
-      # disable passing events to listeners
-      self.resolver.set_listenermask ( 0 )
-
-      # dependency rule pools (a set of rules) are organized in a FIFO
-      # structure that allows to create and delete new pools at runtime
-      self.poolstack = self.resolver.static_rule_pools
-      self.pool_id   = 0
-
-      # this rule maker is used to convert input (strings) into dependency
-      # rules
-      self._rule_maker     = SimpleRuleMaker()
-
-      # this rule maker is used to create rules for R packages found in
-      # directories
-      self._dir_rule_maker = PackageDirRuleMaker()
-
-      # used for relative file paths (rule file writing,...)
-      self._cwd = None
-
-      # shlex mode:
-      #  if True: split command args using shell syntax
-      #  else   : treat command args as one arg
-
-      # e.g. 'resolve zoo >= 5',
-      # => command is 'resolve'
-      # => args:
-      #      shlex: [ 'zoo', '>=' , '5', ]
-      #   no-shlex: [ 'zoo >= 5', ]
-      self.shlex_active = False
-
-      # each command line is prefixed by this string
-      self.PS1 = "cmd % "
-
-      # output streams
-      self.stdout = sys.stdout.write
-      self.stderr = sys.stderr.write
-
-      self._create_command_table()
-
-      self._usage_dict      = dict()
-      self._current_command = None
-
-      # the command table of exit commands
-      #  each listed command can be used to exit the depres console
-      self.cmd_exit = frozenset (( 'q', 'qq', 'exit' ))
-
-      if sys.version_info < ( 3, 0 ):
-         self._get_input = raw_input
-      else:
-         self._get_input = input
-   # --- end of __init__ (...) ---
-
-   def _getpool ( self, new=False ):
-      """Returns a dependency rule pool. Creates a new one if no pool exists
-      or 'new' is set to True.
-
-      arguments:
-      * new -- defaults to True
-      """
-      if not self.poolstack or ( new and not self.poolstack [-1].empty() ):
-         pool = SimpleDependencyRulePool (
-            "pool" + str ( self.pool_id ),
-            deptype_mask=deptype.RESOLVE_ALL
-         )
-         self.pool_id += 1
-         self.poolstack.append ( pool )
-         self.resolver._reset_unresolvable()
-
-      return self.poolstack [-1]
-   # --- end of _getpool (...) ---
-
-   def cmd_mkhelp ( self, argv, line ):
-      missing = list()
-      for cmd in self.cmd_table:
-         try:
-            self._get_usage ( cmd )
-         except KeyError:
-            missing.append ( cmd )
-
-      if missing:
-         print (
-            "Please write help messages for the following commands: " + \
-               ', '.join ( sorted ( missing ) )
-         )
-         return False
-      else:
-         print ( "Everything looks ok." )
-         return True
-   # --- end of cmd_mkhelp (...) ---
-
-   def cmd_cd ( self, argv, line ):
-      if argv:
-         self._cwd = os.path.abspath ( os.path.expanduser ( argv [0] ) )
-         if not os.path.isdir ( self._cwd ):
-            os.makedirs ( self._cwd )
-         self.stdout ( "cwd = {!r}\n".format ( self._cwd ) )
-         return True
-      else:
-         return self.usage()
-   # --- end of cmd_cd (...) ---
-
-   def cmd_rule_scandir ( self, argv, line ):
-      """Scans a directory for R packages and creates rules for them.
-
-      Usage: scandir <directory>
-      """
-      if argv and os.path.isdir ( argv[0] ):
-         pool = self._getpool ( new=True )
-         self.stdout ( "new rules:\n" )
-         for r in self._dir_rule_maker.make_rules ( argv [0] ):
-            self.stdout ( str ( r ) + "\n" )
-            pool.add ( r )
-         self.stdout ( "--- ---\n" )
-         pool.sort()
-
-      else:
-         self.stderr ( "arg0 is not a dir\n" )
-         return self.usage()
-   # --- end of cmd_rule_scandir (...) ---
-
-   def cmd_rule_load_from_config ( self, argv, line ):
-      load = config.get_or_fail ( "DEPRES.simple_rules.files" )
-      self.resolver.get_reader().read ( load )
-      # don't write into ^this pool
-      self._getpool ( new=True )
-   # --- end of cmd_rule_load_from_config (...) ---
-
-   def cmd_rule_load ( self, argv, line ):
-      if argv:
-         self.resolver.get_reader().read ( argv )
-      else:
-         return self.usage()
-   # --- end of cmd_rule_load (...) ---
-
-   def cmd_rule_add ( self, argv, line ):
-      if not line:
-         return self.usage()
-      elif self._rule_maker.add ( line ):
-         rules = self._rule_maker.done()
-         pool  = self._getpool()
-
-         self.stdout ( "new rules:\n" )
-         for _deptype, r in rules:
-            self.stdout ( str ( r ) + "\n" )
-            pool.rules.append ( r )
-         self.stdout ( "--- ---\n" )
-
-         pool.sort()
-
-         self.resolver._reset_unresolvable()
-
-         return True
-      else:
-         return False
-   # --- end of cmd_addrule (...) ---
-
-   def cmd_pool_print ( self, argv, line ):
-      if argv and len ( argv ) > 0:
-         if argv[0] == "all":
-            _last = len ( self.poolstack )
-            for n, p in enumerate ( self.poolstack ):
-               self.stdout ( "showing pool {}/{}.\n".format (
-                  n + 1, _last
-               ))
-               p.export_rules ( sys.stdout )
-         else:
-            self.stdout ( "unknown arg1 {!r}.\n".format ( argv[0] ) )
-            return self.usage()
-      else:
-         if len ( self.poolstack ):
-            self.poolstack [-1].export_rules ( sys.stdout )
-   # --- end of cmd_pool_print (...) ---
-
-   def cmd_pool_write ( self, argv, line ):
-      if not argv:
-         return self.usage()
-
-      if argv[0][0] == os.sep:
-         f = argv [0]
-      elif self._cwd is not None:
-         f = self._cwd + os.sep + argv [0]
-      else:
-         f = os.path.abspath ( argv[0] )
-
-      if os.access ( f, os.F_OK ):
-         self.stdout ( "file {!r} exists!\n".format ( f ) )
-         return False
-
-      elif len ( self.poolstack ):
-         try:
-            fh = open ( f, 'w' )
-            self.poolstack[-1].export_rules ( fh )
-            fh.close()
-            self.stdout ( "Wrote {!r}.\n".format ( f ) )
-            return True
-         finally:
-            if 'fh' in locals() and fh: fh.close()
-
-      else:
-         self.stdout ( "no pool in use.\n" )
-         return False
-   # --- end of cmd_pool_write (...) ---
-
-
-   def cmd_pool_unwind ( self, argv, line ):
-      if self.poolstack:
-         self.poolstack.pop()
-         self.stdout ( "Pool removed from resolver.\n" )
-      else:
-         self.stdout ( "Resolver has no pools.\n" )
-   # --- end of cmd_pool_unwind (...) ---
-
-   def cmd_pool_add ( self, argv, line ):
-      self._getpool ( new=True )
-      self.stdout ( "New pool created.\n" )
-   # --- end of cmd_pool_add (...) ---
-
-   def run ( self ):
-      cmd = None
-
-      self.stdout (
-         '== depres console ==\n'
-         'Run \'help\' to list all known commands\n'
-         'More specifically, \'help <cmd>\' prints a help message for the '
-         'given command, and \'help --list\' lists all help topics available\n'
-         'Use \'load_conf\' or \'lc\' to load the configured rule files\n'
-      )
-      if self.shlex_active:
-         self.stdout (
-            'Note: shlex mode is enabled by default. '
-            'This splits all args according to shell syntax. '
-            'You can disable this (useful when resolving) '
-            'with \'unset shlex\'.\n'
-         )
-      self.stdout ( "\n" )
-      self.cmd_help()
-      self.stdout ( "\n" )
-
-      while True:
-         try:
-            #self.stdout ( "\n" )
-            cmd, argv, line = self.split_line ( self._get_input ( self.PS1 ) )
-
-            if cmd is None:
-               pass
-            elif cmd in self.cmd_exit:
-               break
-            elif cmd in self.cmd_table:
-               self._current_command = cmd
-               ret = self.cmd_table [cmd] ( argv=argv, line=line )
-               if ret is True:
-                  self.stdout ( "command succeeded.\n" )
-               elif ret is False:
-                  self.stdout ( "command failed.\n" )
-            else:
-               self.stdout ( "command {!r} not found.\n".format ( cmd ) )
-               self.cmd_help()
-
-         except KeyboardInterrupt:
-            self.stdout ( "\nuse \'exit\' to exit (or close stdin)\n" )
-         except EOFError:
-            self.stderr ( "\nexiting...\n" )
-            break
-         except Exception as e:
-            logging.exception ( e )
-            self.stderr ( str ( e ) + "\n" )
-
-      self.resolver.close()
-   # --- end of run (...) ---
-
-   def split_line ( self, line ):
-      l = line.strip()
-      if not l:
-         return ( None, None, None )
-
-      linev = self.__class__.whitespace.split ( l, 1 )
-
-      if len ( linev ) == 0:
-         return ( None, None, None )
-      elif len ( linev ) == 1:
-         return ( linev [0].lower(), None, None )
-      elif self.shlex_active:
-         return ( linev [0].lower(), shlex.split ( linev [1] ), linev [1] )
-      else:
-         return ( linev [0].lower(), ( linev [1], ), linev [1] )
-   # --- end of split_line (...) ---
-
-   def cmd_help ( self, argv=None, *ignored, **kwargs_ignored ):
-      if argv:
-         if argv [0] == '--list':
-            print (
-               "The following help topics are available: " + \
-               ', '.join ( self.__class__.CMD_USAGE ) + "."
-            )
-         else:
-            for cmd in argv:
-               self._print_usage ( cmd )
-      else:
-         self.stdout ( "commands: {}\n".format (
-            ', '.join ( self.cmd_table.keys() )
-         ) )
-         self.stdout ( "exit-commands: {}\n".format (
-            ', '.join ( self.cmd_exit )
-         ) )
-   # --- end of cmd_help (...) ---
-
-   def cmd_resolve ( self, argv, line ):
-      dep_list = argv
-      if not dep_list:
-         self.stdout ( "Resolve what?\n" )
-         return self.usage()
-      else:
-         channel = EbuildJobChannel (
-            err_queue=self.err_queue, name="channel"
-         )
-         self.resolver.register_channel ( channel )
-
-         self.stdout ( "Trying to resolve {!r}.\n".format ( dep_list ) )
-
-         channel.add_dependencies ( dep_list, deptype.ALL )
-         deps = channel.satisfy_request (
-            close_if_unresolvable=False,
-            preserve_order=True
-         )
-         channel.close()
-
-         if deps is None:
-            self.stdout (
-               'Channel returned None. '
-               'At least one dep couldn\'t be resolved.\n'
-         )
-         else:
-            self.stdout ( "Resolved as: {!r}\n".format ( deps [0] ) )
-   # --- end of cmd_resolve (...) ---
-
-   def _cmd_set_or_unset ( self, argv, is_set ):
-      if not argv:
-         self.stdout ( "shlex mode is {}.\n".format (
-            "on" if self.shlex_active else "off"
-         ) )
-      elif argv [0] == 'shlex':
-         self.shlex_active = is_set
-      elif argv [0].lower() == "ps1":
-         if is_set:
-            self.PS1 = argv [1] + ' '
-         else:
-            self.PS1 = "cmd % "
-      else:
-         self.stdout ( "unknown args: {}.\n".format ( argv ) )
-         return self.usage()
-   # --- end of _cmd_set_or_unset (...) ---
-
-   def cmd_set ( self, argv, line ):
-      self._cmd_set_or_unset ( argv, True )
-   # --- end of cmd_set (...) ---
-
-   def cmd_unset ( self, argv, line ):
-      self._cmd_set_or_unset ( argv, False )
-   # --- end of cmd_unset (...) ---


^ permalink raw reply related	[flat|nested] 6+ messages in thread
* [gentoo-commits] proj/R_overlay:gsoc13/next commit in: roverlay/depres/simpledeprule/
@ 2013-07-10 15:10 André Erdmann
  0 siblings, 0 replies; 6+ messages in thread
From: André Erdmann @ 2013-07-10 15:10 UTC (permalink / raw
  To: gentoo-commits

commit:     1c14f3a2bae0517890589572d90c5f07bdff6f85
Author:     André Erdmann <dywi <AT> mailerd <DOT> de>
AuthorDate: Wed Jul 10 13:29:27 2013 +0000
Commit:     André Erdmann <dywi <AT> mailerd <DOT> de>
CommitDate: Wed Jul 10 13:32:17 2013 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/R_overlay.git;a=commit;h=1c14f3a2

roverlay/depres/simpledeprule: use util.mapreader

* rulemaker: use common code provided by util.mapreader.MapfileParser
* reader: offload file reading/parsing to rulemaker, skip vcs directories when
          scanning directories for rule files

---
 roverlay/depres/simpledeprule/reader.py    |  96 +++--------------------
 roverlay/depres/simpledeprule/rulemaker.py | 120 +++++++++++++----------------
 2 files changed, 61 insertions(+), 155 deletions(-)

diff --git a/roverlay/depres/simpledeprule/reader.py b/roverlay/depres/simpledeprule/reader.py
index d7edc48..e22877b 100644
--- a/roverlay/depres/simpledeprule/reader.py
+++ b/roverlay/depres/simpledeprule/reader.py
@@ -13,12 +13,9 @@ rules from a file.
 __all__ = [ 'SimpleDependencyRuleReader', ]
 
 import os
-import sys
 import logging
 
-import gzip
-import bz2
-import mimetypes
+import roverlay.util
 
 from roverlay.depres.simpledeprule.rulemaker import SimpleRuleMaker
 
@@ -29,19 +26,15 @@ class SimpleDependencyRuleReader ( object ):
       """ A SimpleDependencyRuleReader reads such rules from a file."""
       self.logger = logging.getLogger ( self.__class__.__name__ )
 
-      # note that breakparse is reader-specific (not in SimpleRuleMaker)
-      self.breakparse = set (( '#! NOPARSE', '#! BREAK' ))
-
       self._rmaker = SimpleRuleMaker()
 
-      self._mimetypes = mimetypes.MimeTypes()
-      self.guess_ftype = self._mimetypes.guess_type
+      # bind read method of the rule maker
+      self.read_file = self._rmaker.read_file
 
       self._pool_add = pool_add
       self._when_done = when_done
 
       self._fcount = 0
-
    # --- end of __init__  (...) ---
 
    def read ( self, files_or_dirs ):
@@ -58,11 +51,12 @@ class SimpleDependencyRuleReader ( object ):
 
       for k in files_or_dirs:
          if os.path.isdir ( k ):
-            # without recursion
-            for fname in os.listdir ( k ):
-               f = k + os.sep + fname
-               if os.path.isfile ( f ):
-                  self.read_file ( f )
+            if not roverlay.util.is_vcs_dir ( k ):
+               # without recursion
+               for fname in os.listdir ( k ):
+                  f = k + os.sep + fname
+                  if os.path.isfile ( f ):
+                     self.read_file ( f )
          else:
             self.read_file ( k )
 
@@ -78,75 +72,3 @@ class SimpleDependencyRuleReader ( object ):
       else:
          return pools
    # --- end of read (...) ---
-
-   def read_file ( self, filepath ):
-      """Reads a file that contains simple dependency rules
-      (SimpleIgnoreDependencyRules/SimpleDependencyRules).
-
-      arguments:
-      * filepath -- file to read
-      """
-
-      # line number is used for logging
-      lineno = 0
-
-      self._fcount += 1
-
-      try:
-         self.logger.debug (
-            "Reading simple dependency rule file {!r}.".format ( filepath )
-         )
-         ftype = self.guess_ftype ( filepath )
-
-         compressed = True
-
-         if ftype [1] == 'bzip2':
-            fh = bz2.BZ2File ( filepath, mode='r' )
-         elif ftype [1] == 'gzip':
-            fh = gzip.GzipFile ( filepath, mode='r' )
-         else:
-            fh = open ( filepath, 'r' )
-            compressed = False
-
-
-         if compressed and sys.version_info >= ( 3, ):
-            readlines = ( l.decode().strip() for l in fh.readlines() )
-         else:
-            readlines = ( l.strip() for l in fh.readlines() )
-
-         for line in readlines:
-            lineno += 1
-
-            if not line:
-               # empty (the rule maker catches this, too)
-               pass
-
-            elif line in self.breakparse:
-               # stop reading here
-               break
-
-            elif not self._rmaker.add ( line ):
-               self.logger.error (
-                  "In {!r}, line {}: cannot use this line.".format (
-                     filepath, lineno
-                  )
-               )
-
-         if fh: fh.close()
-
-      except IOError as ioerr:
-         if lineno:
-            self.logger.error (
-               "Failed to read file {!r} after {} lines.".format (
-                  filepath, lineno
-               )
-            )
-         else:
-            self.logger.error (
-               "Could not read file {!r}.".format ( filepath )
-            )
-         raise
-      finally:
-         if 'fh' in locals() and fh: fh.close()
-
-      # --- end of read_file (...) ---

diff --git a/roverlay/depres/simpledeprule/rulemaker.py b/roverlay/depres/simpledeprule/rulemaker.py
index ed39791..3f9ab73 100644
--- a/roverlay/depres/simpledeprule/rulemaker.py
+++ b/roverlay/depres/simpledeprule/rulemaker.py
@@ -15,6 +15,8 @@ __all__ = [ 'SimpleRuleMaker', ]
 import re
 import logging
 
+import roverlay.util.mapreader
+
 from roverlay import config
 
 from roverlay.depres import deptype
@@ -22,15 +24,14 @@ from roverlay.depres.simpledeprule import rules
 from roverlay.depres.simpledeprule.abstractrules import *
 from roverlay.depres.simpledeprule.pool import SimpleDependencyRulePool
 
-class SimpleRuleMaker ( object ):
+class SimpleRuleMaker ( roverlay.util.mapreader.MapFileParser ):
+
+   breakparse = set (( '! NOPARSE', '! BREAK' ))
 
    def __init__ ( self, rule_separator=None ):
+      super ( SimpleRuleMaker, self ).__init__()
       self.logger = logging.getLogger ( self.__class__.__name__ )
 
-      self.single_line_separator = re.compile (
-         '\s+::\s+' if rule_separator is None else rule_separator
-      )
-
       self.DEPTYPE_MAP = {
          'all'     : deptype.ALL,
          'sys'     : deptype.external,
@@ -38,9 +39,6 @@ class SimpleRuleMaker ( object ):
          'selfdep' : deptype.selfdep,
       }
 
-      self.multiline_start = '{'
-      self.multiline_stop  = '}'
-      self.comment_char    = '#'
       self.kw_selfdep_once = '@selfdep'
       self._kwmap          = rules.RuleConstructor (
          eapi = config.get_or_fail ( 'EBUILD.eapi' )
@@ -49,37 +47,23 @@ class SimpleRuleMaker ( object ):
       self.deptype_kw      = 'deptype'
       self._deptype        = deptype.ALL
       self._deptype_once   = deptype.NONE
-      self._next           = None
-      # [ ( deptype, rule ), ... ]
-      self._rules          = list()
    # --- end of __init__ (...) ---
 
-   def zap ( self ):
-      if self._next is not None:
-         self.logger.warning (
-            "Multi line rule does not end at EOF - ignored"
-         )
-      self._next         = None
-      self._rules        = list()
-   # --- end of zap (...) ---
-
-   def done ( self, as_pool=False ):
-      rule_count = len ( self._rules )
+   def make_result ( self, as_pool=False ):
+      rule_count = len ( self._items )
       if as_pool:
          poolmap = dict()
-         for dtype, rule in self._rules:
+         for dtype, rule in self._items:
             if dtype not in poolmap:
                poolmap [dtype] = SimpleDependencyRulePool (
                   name=str ( id ( self ) ),
                   deptype_mask=dtype
                )
             poolmap [dtype].add ( rule )
-         ret = ( rule_count, tuple ( poolmap.values() ) )
+         return ( rule_count, tuple ( poolmap.values() ) )
       else:
-         ret = self._rules
-      self.zap()
-      return ret
-   # --- end of done (...) ---
+         return self._items
+   # --- end of make_result (...) ---
 
    def _parse_deptype ( self, deptype_str ):
       ret = deptype.NONE
@@ -104,7 +88,7 @@ class SimpleRuleMaker ( object ):
          return self._deptype
    # --- end of _get_effective_deptype (...) ---
 
-   def _single_line_rule ( self, dep, dep_str='' ):
+   def handle_entry_line ( self, dep, dep_str='' ):
       # single line rule, either selfdep,
       #  e.g. '~zoo' -> fuzzy sci-R/zoo :: zoo
       #  or normal rule 'dev-lang/R :: R'
@@ -141,52 +125,52 @@ class SimpleRuleMaker ( object ):
          return False
 
       new_rule.done_reading()
-      self._rules.append ( ( rule_deptype, new_rule ) )
+      self._items.append ( ( rule_deptype, new_rule ) )
       return True
-   # --- end of _single_line_rule (...) ---
+   # --- end of handle_entry_line (...) ---
 
-   def add ( self, line ):
-      if len ( line ) == 0:
-         return True
-      elif self._next is not None:
-         if line [0] == self.multiline_stop:
-            # end of a multiline rule,
-            #  add rule to rules and set next_rule to None
-            self._next [1].done_reading()
-            self._rules.append ( self._next )
-            self._next = None
-         else:
-            # new resolved str
-            self._next [1].add_resolved ( line )
+   def handle_multiline_begin ( self, line ):
+      rule_class, resolving, kwargs = self._kwmap.lookup ( line )
 
-         return True
+      self._next = (
+         self._get_effective_deptype(),
+         rule_class ( resolving_package=resolving, **kwargs ),
+      )
+      return True
+   # --- end of handle_multiline_begin (...) ---
 
-      elif line [0] == self.comment_char:
-         if line [ 1 : 1 + len ( self.deptype_kw ) ] == self.deptype_kw :
-            # changing deptype ("#deptype <type>")
-            dtype_str = line [ len ( self.deptype_kw ) + 2 : ].lstrip().lower()
-            self._deptype = self._parse_deptype ( dtype_str )
+   def handle_multiline_end ( self, line ):
+      self._next [1].done_reading()
+      self._items.append ( self._next )
+      self._next = None
+      return True
+   # --- end of handle_multiline_end (...) ---
 
-         # else is a comment,
-         #  it's intented that multi line rules cannot contain comments
-         return True
+   def handle_multiline_append ( self, line ):
+      self._next [1].add_resolved ( line )
+      return True
+   # --- end of handle_multiline_append (...) ---
 
-      elif line == self.kw_selfdep_once:
-         self._deptype_once = self._deptype | deptype.selfdep
-         return True
+   def handle_comment_line ( self, line ):
+      if line[:len ( self.deptype_kw ) ] == self.deptype_kw:
+         # changing deptype ("#deptype <type>")
+         dtype_str = line.partition ( ' ' )[2].lower()
+         self._deptype = self._parse_deptype ( dtype_str )
 
-      elif len ( line ) > 1 and line [-1] == self.multiline_start:
-         l = line [:-1].rstrip()
-         rule_class, resolving, kwargs = self._kwmap.lookup ( l )
+      elif line in self.breakparse:
+         self.stop_reading = True
 
-         self._next = (
-            self._get_effective_deptype(),
-            rule_class ( resolving_package=resolving, **kwargs ),
-         )
-         return True
+      # else is a "real" comment
+      return True
+   # --- end of handle_comment_line (...) ---
 
+   def handle_option_line ( self, line ):
+      if line == self.kw_selfdep_once:
+         self._deptype_once = self._deptype | deptype.selfdep
+         return True
       else:
-         return self._single_line_rule (
-            *self.single_line_separator.split ( line, 1  )
-         )
-   # --- end of add (...) ---
+         return False
+   # --- end of handle_option_line (...) ---
+
+
+# --- end of SimpleRuleMaker ---


^ permalink raw reply related	[flat|nested] 6+ messages in thread
* [gentoo-commits] proj/R_overlay:master commit in: roverlay/depres/simpledeprule/
@ 2013-07-03 10:05 André Erdmann
  2013-06-28 17:18 ` [gentoo-commits] proj/R_overlay:gsoc13/next " André Erdmann
  0 siblings, 1 reply; 6+ messages in thread
From: André Erdmann @ 2013-07-03 10:05 UTC (permalink / raw
  To: gentoo-commits

commit:     56508c012746facf81dc62926dc86646f5b04a60
Author:     André Erdmann <dywi <AT> mailerd <DOT> de>
AuthorDate: Fri Jun 28 17:14:23 2013 +0000
Commit:     André Erdmann <dywi <AT> mailerd <DOT> de>
CommitDate: Fri Jun 28 17:14:23 2013 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/R_overlay.git;a=commit;h=56508c01

roverlay/depres: SLOT handling fixup (part 1)

(rule file-)syntax fixup for fuzzy slot dep rules.

This feature still needs some work.

---
 roverlay/depres/simpledeprule/abstractrules.py |  38 +++--
 roverlay/depres/simpledeprule/rules.py         | 204 ++++++++++++++++++-------
 2 files changed, 175 insertions(+), 67 deletions(-)

diff --git a/roverlay/depres/simpledeprule/abstractrules.py b/roverlay/depres/simpledeprule/abstractrules.py
index 85c365d..0713c81 100644
--- a/roverlay/depres/simpledeprule/abstractrules.py
+++ b/roverlay/depres/simpledeprule/abstractrules.py
@@ -97,21 +97,32 @@ class SimpleRule ( deprule.DependencyRule ):
       return None
    # --- end of matches (...) ---
 
+   def noexport ( self ):
+      """Removes all variables from this object that are used for string
+      creation ("export_rule()") only.
+      """
+      pass
+   # --- end of noexport (...) ---
+
    def export_rule ( self ):
       """Generates text lines for this rule that can later be read using
       the SimpleDependencyRuleReader.
       """
-      if self.resolving_package is None:
-         resolving = ''
+      if hasattr ( self, 'get_resolving_str' ):
+         resolving = self.get_resolving_str()
       else:
-         resolving = self.resolving_package
+         if self.resolving_package is None:
+            resolving = ''
+         else:
+            resolving = self.resolving_package
 
-         if self.is_selfdep:
-            resolving = resolving.rpartition ( '/' ) [2]
+            if self.is_selfdep:
+               resolving = resolving.rpartition ( '/' ) [2]
 
 
-      if hasattr ( self.__class__, 'RULE_PREFIX' ):
-         resolving = self.__class__.RULE_PREFIX + resolving
+         if hasattr ( self.__class__, 'RULE_PREFIX' ):
+            resolving = self.__class__.RULE_PREFIX + resolving
+      # -- end if;
 
       if self.is_selfdep:
          yield resolving
@@ -178,15 +189,12 @@ class FuzzySimpleRule ( SimpleRule ):
    # --- end of log_fuzzy_match (...) ---
 
    def log_standard_match ( self, dep_env, score ):
-      if dep is False:
-         return None
-      else:
-         self.logger.debug (
-            "matches {dep_str} with score {s} and priority {p}.".format (
-               dep_str=dep_env.dep_str, s=score, p=self.priority
-            )
+      self.logger.debug (
+         "matches {dep_str} with score {s} and priority {p}.".format (
+            dep_str=dep_env.dep_str, s=score, p=self.priority
          )
-         return ( score, self.resolving_package )
+      )
+      return ( score, self.resolving_package )
    # --- end of log_standard_match (...) ---
 
    def handle_version_relative_match ( self, dep_env, fuzzy ):

diff --git a/roverlay/depres/simpledeprule/rules.py b/roverlay/depres/simpledeprule/rules.py
index db208d4..ac3fa89 100644
--- a/roverlay/depres/simpledeprule/rules.py
+++ b/roverlay/depres/simpledeprule/rules.py
@@ -23,10 +23,90 @@ __all__ = (
 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
+
+   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.
+
+      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 ):
 
    def __init__ ( self, eapi ):
-      self.eapi = eapi
+      ##self.eapi = eapi
 
       self.kw_ignore       = SimpleIgnoreDependencyRule.RULE_PREFIX
       self.kw_fuzzy        = SimpleFuzzyDependencyRule.RULE_PREFIX
@@ -42,58 +122,59 @@ class RuleConstructor ( object ):
       elif kw == self.kw_fuzzy_ignore:
          return ( SimpleFuzzyIgnoreDependencyRule, get_kwless(), {} )
       elif kw == self.kw_fuzzy:
-         ##TODO
-         ## > "default"
-         ## > "slot only"
-         ## > "combined"
-   ## syntax
-   ## ~cat/pkg:<slot suffix>
-   ## ~cat/pkg:/<slot suffix>
-   ## ~cat/pkg:{major}/{minor}<slot suffix>
-   ##
+         ## syntax
+         ## ~cat/pkg:<slot range>:<slot suffix>
          kwless = get_kwless()
          resolving, sepa, remainder = kwless.partition ( ':' )
 
          if sepa:
             # fuzzy slot rule
-            kwargs = { 'resolving_package_name' : resolving, }
+            kwargs = dict()
             slot_head, slot_sepa, slot_rem = remainder.partition ( ':' )
 
             if slot_sepa:
-               # slot restriction
+               # int range restriction
                istart, isepa, istop = slot_head.partition ( '..' )
                if isepa:
-                  kwargs ['slot_restrict'] = frozenset (
-                     range ( int ( istart or 0 ), int ( istop or 100 ) + 1 )
+                  kwargs ['slot_restrict'] = SlotRangeRestrict (
+                     low=istart, high=istop
                   )
                else:
-                  kwargs ['slot_restrict'] = frozenset (
-                     int ( k ) for k in slot_head.split ( ',' )
+                  # int list restriction
+
+                  # "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 istr_list:
+                     kwargs ['slot_restrict'] = SlotSetRestrict ( istr_list )
+
                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:
-               # <cat>/<pkg>:
-               kwargs ['slot_suffix'] = sepa + '{slot}'
-
+               pass
             elif remainder[0] in { '/', '*', '=' }:
                # subslot, "any slot" operators
-               assert self.eapi >= 5
-               kwargs ['slot_suffix'] = sepa + '{slot}' + remainder
-            else:
-               kwargs ['slot_suffix'] = sepa + remainder
-
+               # (subslots don't seem to make much sense here)
 
-            # verify that slot_suffix can be formatted properly
-##            if kwargs ['slot_suffix'] [0] != ':':
-##               kwargs ['slot_suffix'] = ':' + kwargs ['slot_suffix']
+               ##if self.eapi < 5: raise ...
+               kwargs ['slot_suffix'] = remainder
+            else:
+               raise Exception (
+                  "unknown slot rule remainder {!r}".format ( remainder )
+               )
 
-            DONT_CARE = kwargs ['slot_suffix'].format ( slot='_', version='_' )
             return ( SimpleFuzzySlotDependencyRule, resolving, kwargs )
          else:
             return ( SimpleFuzzyDependencyRule, kwless, {} )
@@ -212,39 +293,55 @@ class SimpleFuzzySlotDependencyRule ( FuzzySimpleRule ):
    RULE_PREFIX = SimpleFuzzyDependencyRule.RULE_PREFIX
 
    def __init__ ( self,
-      priority               = 71,
-      resolving_package      = None,
-      resolving_package_name = None,
-      slot_suffix            = None,
-      slot_restrict          = None,
+      priority          = 71,
+      resolving_package = None,
+      slot_suffix       = None,
+      slot_restrict     = None,
+      with_version      = False,
       **kw
    ):
       super ( SimpleFuzzySlotDependencyRule, self ) . __init__ (
          priority=priority,
          resolving_package = resolving_package,
-         logger_name       = 'FUZZY_SLOT.' + (
-            resolving_package_name if resolving_package_name is not None
-            else resolving_package.partition ( ':' )[0]
-         ),
+         logger_name       = 'FUZZY_SLOT.' + resolving_package,
          **kw
       )
 
-      self.slot_suffix = slot_suffix
+      self.slot_suffix   = slot_suffix
+      self.slot_restrict = slot_restrict
 
-      if slot_restrict:
-         self.slot_restrict = frozenset ( int ( k ) for k in slot_restrict )
+      if with_version:
+         self._resolving_fmt = (
+            '{vmod}' + self.resolving_package + '-{version}:{slot}'
+            + ( slot_suffix or '' )
+         )
+         self.with_version = True
       else:
-         self.slot_restrict = None
+         self._resolving_fmt = (
+            self.resolving_package + ':{slot}' + ( slot_suffix or '' )
+         )
+         self.with_version = False
+
+      if self.is_selfdep:
+         raise NotImplementedError ( "fuzzy slot rule must not be a selfdep." )
    # --- end of __init__ (...) ---
 
-   def __str__ ( self ):
-      # FIXME/TODO
-      return 'TODO! {low}..{high} {s}'.format (
-         low  = ( min ( self.slot_restrict ) if self.slot_restrict else 'X' ),
-         high = ( max ( self.slot_restrict ) if self.slot_restrict else 'X' ),
-         s    = ( super ( SimpleFuzzySlotDependencyRule, self ).__str__() ),
+   def noexport ( self ):
+      del self.slot_suffix
+      del self.with_version
+      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 '' ),
       )
-   # --- end of __str__ (...) ---
+   # --- end of get_resolving_str (...) ---
 
    def handle_version_relative_match ( self, dep_env, fuzzy ):
       res  = False
@@ -256,6 +353,8 @@ class SimpleFuzzySlotDependencyRule ( FuzzySimpleRule ):
          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
@@ -264,10 +363,11 @@ class SimpleFuzzySlotDependencyRule ( FuzzySimpleRule ):
             elif vmod == dep_env.VMOD_GT:
                slot += 1
 
-            if not self.slot_restrict or slot in self.slot_restrict:
-               res = self.resolving_package + self.slot_suffix.format (
-                  slot=slot, version=ver_str,
-                  #vmod=fuzzy ['version_modifier']
+            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


^ permalink raw reply related	[flat|nested] 6+ messages in thread
* [gentoo-commits] proj/R_overlay:gsoc13/next commit in: roverlay/depres/simpledeprule/
@ 2013-06-05 18:08 André Erdmann
  0 siblings, 0 replies; 6+ messages in thread
From: André Erdmann @ 2013-06-05 18:08 UTC (permalink / raw
  To: gentoo-commits

commit:     9fa3b9afb66e6d2c7ae4ac902fe6abb613949c91
Author:     André Erdmann <dywi <AT> mailerd <DOT> de>
AuthorDate: Wed Jun  5 17:59:42 2013 +0000
Commit:     André Erdmann <dywi <AT> mailerd <DOT> de>
CommitDate: Wed Jun  5 17:59:42 2013 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/R_overlay.git;a=commit;h=9fa3b9af

dynamic selfdep pool: dont add rule kwargs

---
 roverlay/depres/simpledeprule/dynpool.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/roverlay/depres/simpledeprule/dynpool.py b/roverlay/depres/simpledeprule/dynpool.py
index b1d008d..8b6cf20 100644
--- a/roverlay/depres/simpledeprule/dynpool.py
+++ b/roverlay/depres/simpledeprule/dynpool.py
@@ -46,8 +46,7 @@ class DynamicSelfdepRulePool ( SimpleDependencyRulePool ):
 
    def reload ( self ):
       self.rules = list (
-         self._rule_class ( is_selfdep=True, **kwargs ) \
-            for kwargs in self._rule_kw_function()
+         self._rule_class ( **kwargs ) for kwargs in self._rule_kw_function()
       )
    # --- end of reload (...) ---
 


^ permalink raw reply related	[flat|nested] 6+ messages in thread
end of thread, other threads:[~2013-07-19 18:00 UTC | newest]

Thread overview: 6+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2013-07-03 10:04 [gentoo-commits] proj/R_overlay:gsoc13/next commit in: roverlay/depres/simpledeprule/ André Erdmann
2013-07-03 10:05 ` [gentoo-commits] proj/R_overlay:master " André Erdmann
  -- strict thread matches above, loose matches on Subject: below --
2013-07-23  7:51 André Erdmann
2013-07-19 18:00 ` [gentoo-commits] proj/R_overlay:gsoc13/next " André Erdmann
2013-07-10 15:10 André Erdmann
2013-07-03 10:05 [gentoo-commits] proj/R_overlay:master " André Erdmann
2013-06-28 17:18 ` [gentoo-commits] proj/R_overlay:gsoc13/next " André Erdmann
2013-06-05 18:08 André Erdmann

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox