remove old depres console

1 files changed, 0 insertions, 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 (...) ---