remove most of the resolver boilerplate, keep the interesting functions

Signed-off-by: Nico Schottelius <nico@brief.schottelius.org>

cdist/core/cdist_object.py

@@ -213,78 +213,6 @@ class CdistObject(object):
     def satisfied_requirements(self):
 
 
-
-# -*- coding: utf-8 -*-
-#
-# 2011 Steven Armstrong (steven-cdist at armstrong.cc)
-#
-# This file is part of cdist.
-#
-# cdist is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# cdist is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with cdist. If not, see <http://www.gnu.org/licenses/>.
-#
-#
-
-import logging
-import os
-import itertools
-import fnmatch
-
-import cdist
-
-log = logging.getLogger(__name__)
-
-
-class CircularReferenceError(cdist.Error):
-    def __init__(self, cdist_object, required_object):
-        self.cdist_object = cdist_object
-        self.required_object = required_object
-
-    def __str__(self):
-        return 'Circular reference detected: %s -> %s' % (self.cdist_object.name, self.required_object.name)
-
-
-class RequirementNotFoundError(cdist.Error):
-    def __init__(self, requirement):
-        self.requirement = requirement
-
-    def __str__(self):
-        return 'Requirement could not be found: %s' % self.requirement
-
-
-class DependencyResolver(object):
-    """Cdist's dependency resolver.
-
-    Usage:
-    >> resolver = DependencyResolver(list_of_objects)
-    # Easy access to the objects we are working with
-    >> resolver.objects['__some_type/object_id']
-    <CdistObject __some_type/object_id>
-    # Easy access to a specific objects dependencies
-    >> resolver.dependencies['__some_type/object_id']
-    [<CdistObject __other_type/dependency>, <CdistObject __some_type/object_id>]
-    # Pretty print the dependency graph
-    >> from pprint import pprint
-    >> pprint(resolver.dependencies)
-    # Iterate over all existing objects in the correct order
-    >> for cdist_object in resolver:
-    >>     do_something_with(cdist_object)
-    """
-    def __init__(self, objects, logger=None):
-        self.objects = dict((o.name, o) for o in objects)
-        self._dependencies = None
-        self.log = logger or log
-
     @property
     def dependencies(self):
         """Build the dependency graph.
@@ -348,37 +276,22 @@ class DependencyResolver(object):
                 # preprocessed again if someone would call us multiple times.
                 cdist_object.autorequire = []
 
-    def _resolve_object_dependencies(self, cdist_object, resolved, unresolved):
-        """Resolve all dependencies for the given cdist_object and store them
-        in the list which is passed as the 'resolved' arguments.
 
-        e.g.
+class CircularReferenceError(cdist.Error):
-        resolved = []
+    def __init__(self, cdist_object, required_object):
-        unresolved = []
+        self.cdist_object = cdist_object
-        resolve_object_dependencies(some_object, resolved, unresolved)
+        self.required_object = required_object
-        print("Dependencies for %s: %s" % (some_object, resolved))
+
-        """
+    def __str__(self):
-        self.log.debug('Resolving dependencies for: %s' % cdist_object.name)
+        return 'Circular reference detected: %s -> %s' % (self.cdist_object.name, self.required_object.name)
-        try:
+
-            unresolved.append(cdist_object)
+
-            for required_object in self.find_requirements_by_name(cdist_object.requirements):
+class RequirementNotFoundError(cdist.Error):
-                self.log.debug("Object %s requires %s", cdist_object, required_object)
+    def __init__(self, requirement):
-                if required_object not in resolved:
+        self.requirement = requirement
-                    if required_object in unresolved:
+
-                        raise CircularReferenceError(cdist_object, required_object)
+    def __str__(self):
-                    self._resolve_object_dependencies(required_object, resolved, unresolved)
+        return 'Requirement could not be found: %s' % self.requirement
-            resolved.append(cdist_object)
+
-            unresolved.remove(cdist_object)
+
-        except RequirementNotFoundError as e:
-            raise cdist.CdistObjectError(cdist_object, "requires non-existing " + e.requirement)
 
-    def __iter__(self):
-        """Iterate over all unique objects and yield them in the correct order.
-        """
-        iterable = itertools.chain(*self.dependencies.values())
-        # Keep record of objects that have already been seen
-        seen = set()
-        seen_add = seen.add
-        for cdist_object in itertools.filterfalse(seen.__contains__, iterable):
-            seen_add(cdist_object)
-            yield cdist_object