def getRootDir(self): if self._rootDir is None: r = ReflectionObject(self) self._rootDir = os.path.dirname(r.getFileName()).replace( '\\', '/') return self._rootDir
class TestReflextion(unittest.TestCase, Object): def setUp(self): self.subject = ReflectionObject(self) def testConstructor(self): self.assertEqual(self.subject._class, self.__class__) def testGetFileName(self): self.assertEqual(inspect.getabsfile(self.__class__), self.subject.getFileName()) def testGetmro(self): self.assertEqual(self.__class__.__mro__, self.subject.getmro())
def getServiceIds(self): """Gets all service ids. @return: list An array of all defined service ids """ ids = list() r = ReflectionObject(self) for method in r.getMethods(): match = re.search('^get(.+)Service$', method.getName()) if match: ids.append(self.underscore(match.group(1))) return Array.uniq(ids + list(self._services.keys()))
def addObjectResource(self, objectResource): """Adds the object class hierarchy as resources. @param: object object An object instance @return RouteCollection The current instance """ assert isinstance(objectResource, Object) parent = ReflectionObject(objectResource) while parent: self.addResource(FileResource(parent.getFileName())) parent = parent.getParentClass() return self
def showAction(self, request, exception): assert isinstance(request, Request) if isinstance(exception, NotFoundConsoleException): title = 'Sorry, the command you are executing for could not be found.' else: title = 'Whoops, looks like something went wrong.' debug = self._container.getParameter('kernel.debug') verbose = False if request.hasOption('verbose'): verbose = request.getOption('verbose') content = "" nl = "\n" if debug: try: content += self._renderException(exception, nl, verbose) except Exception as e: message = e.getMessage() if isinstance( e, StandardException) else str(e) title = 'Exception thrown when handling an exception ({0}: {1})'.format( ReflectionObject(e).getName(), message) return Response("<error>{0}</error>{nl}{1}".format(title, content, nl=nl))
def getArguments(self, request, controller, response=None): """Returns the arguments to pass to the controller. @param Request request A Request instance @param mixed controller A PYTHON callable @param Response response A Response instance @return list @raise RuntimeException When value for argument given is not provided @api """ assert isinstance(request, Request) if None is response: response = Response() else: assert isinstance(response, Response) if inspect.ismethod(controller): r = ReflectionMethod(controller) elif inspect.isfunction(controller) or isinstance(controller, String): r = ReflectionFunction(controller) else: r = ReflectionObject(controller) r = r.getMethod('__call__') return self._doGetArguments(request, controller, r.getParameters(), response)
def getConfiguration(self, configs, container): assert isinstance(configs, list) assert isinstance(container, ContainerBuilder) className = ReflectionObject( self).getNamespaceName() + '.' + 'Configuration' r = ReflectionClass(className) if r.exists(): configuration = r.newInstance() path = ReflectionObject(configuration).getFileName() container.addResource(FileResource(path)) return configuration return None
def addObjectResource(self, objectResource): """Adds the object class hierarchy(, as resources.): @param: object object An object instance @return ContainerBuilder The current instance @api """ assert isinstance(objectResource, Object) if not self.__trackResources: return self parent = ReflectionObject(objectResource) while parent: self.addResource(FileResource(parent.getFileName())) parent = parent.getParentClass() return self
def getBundle(self, name, first=True): if name not in self._bundleMap: raise InvalidArgumentException( 'Bundle "{0}" does not exist or it is not enabled. Maybe you ' 'forgot to add it in the registerBundles() method of your {1} ' 'file?'.format(name, ReflectionObject(self).getFileName())) if first is True: return self._bundleMap[name][0] return self._bundleMap[name]
def getController(self, request): """Returns the Controller instance associated with a Request. As several resolvers can exist for a single application, a resolver must return False when it is not able to determine the controller. The resolver must only raise an exception when it should be able to load controller but cannot because of some errors made by the developer. @param Request request A ArgvInput instance @return mixed|Boolean A PYTHON callable representing the Controller, or False if this resolver is not able to determine the controller: @raise InvalidArgumentException|\LogicException If the controller can't be found @api """ assert isinstance(request, Request) controller = request.attributes.get('_controller') if (not controller): return False if Tool.isCallable(controller): return controller if not isinstance(controller, String): return False if ':' not in controller: r = ReflectionClass(controller) if r.exists(): instance = r.newInstance() if Tool.isCallable(instance): return instance controller, method = self._createController(controller) if not hasattr(controller, method): raise InvalidArgumentException( 'Method "{0}.{1}" does not exist.'.format( ReflectionObject(controller).getName(), method)) return getattr(controller, method)
def _getKernelParameters(self): bundles = dict() for name, bundle in self._bundles.items(): bundles[name] = ReflectionObject(bundle).getName() parameters = { 'kernel.root_dir': self._rootDir, 'kernel.environment': self._environment, 'kernel.debug': self._debug, 'kernel.name': self._name, 'kernel.cache_dir': self.getCacheDir(), 'kernel.logs_dir': self.getLogDir(), 'kernel.bundles': bundles, 'kernel.charset': self.getCharset(), 'kernel.container_class': self._getContainerClass(), 'kernel.version': self.getVersion(), } parameters.update(self._getEnvParameters()) return parameters
def __init__(self, argument): ReflectionObject.__init__(self, argument); self.bla = None;
def __init__(self, argument): ReflectionObject.__init__(self, argument) self.bla = None
def getRootDir(self): if self._rootDir is None: r = ReflectionObject(self); self._rootDir = os.path.dirname(r.getFileName()).replace('\\', '/'); return self._rootDir;
class Bundle(ContainerAware, BundleInterface): """An implementation of BundleInterface that adds a few conventions for DependencyInjection extensions. """ def __init__(self): self._name = None self._reflected = None self._extension = None def boot(self): pass def shutdown(self): pass def build(self, container): assert isinstance(container, ContainerBuilder) def getContainerExtension(self): """Returns the bundle's container extension. @return: ExtensionInterface|null The container extension @raise LogicException: When alias not respect the naming convention """ if self._extension is None: basename = re.sub(r"Bundle$", "", self.getName()) moduleName = "{0}.dependency".format(self.getNamespace()) className = "{0}.{1}Extension".format(moduleName, basename) r = ReflectionClass(className) if r.exists(): extension = r.newInstance() # check naming convention expectedAlias = ContainerBuilder.underscore(basename) if expectedAlias != extension.getAlias(): raise LogicException( 'The extension alias for the default extension of a ' 'bundle must be the underscored version of the ' 'bundle name ("{0}" instead of "{1}")' ''.format(expectedAlias, extension.getAlias())) self._extension = extension else: self._extension = False if self._extension: return self._extension def getNamespace(self): if self._reflected is None: self._reflected = ReflectionObject(self) return self._reflected.getNamespaceName() def getPath(self): if self._reflected is None: self._reflected = ReflectionObject(self) return dirname(self._reflected.getFileName()) @final def getName(self): if self._name is None: self._name = str(type(self).__name__) return self._name def getParent(self): return None def registerCommands(self, collection): """Registers Commands.
def getPath(self): if self._reflected is None: self._reflected = ReflectionObject(self) return dirname(self._reflected.getFileName())
def getNamespace(self): if self._reflected is None: self._reflected = ReflectionObject(self) return self._reflected.getNamespaceName()
def setUp(self): self.subject = ReflectionObject(self)
def _renderException(self, e, nl="\n", verbose=False): content = "" while e: title = ' [{0}] '.format(ReflectionObject(e).getName()) lenght = len(title) width = 80 # TODO: console width - 1 lines = list() message = e.getMessage() if isinstance( e, StandardException) else str(e) for line in list(re.split('\r?\n', message)): for line in filter( None, re.split('(.{{1,{0}}})'.format(str(width - 4)), line)): lines.append(' {0} '.format(line)) lenght = max(len(line) + 4, lenght) messages = [ ' ' * lenght, title + (' ' * max(0, lenght - len(title))) ] for line in lines: messages.append(line + (' ' * (lenght - len(line)))) messages.append(' ' * lenght) content += nl content += nl for message in messages: content += '<error>' + message + '</error>' + nl content += nl content += nl if verbose and isinstance(e, StandardException): content += '<comment>Exception trace:</comment>' + nl # exception related properties trace = e.getTrace() for stack in trace: className = ReflectionObject( stack['locals']['self']).getName( ) if 'self' in stack['locals'] else '' function = stack['name'] file = stack['filename'] if 'filename' in stack else 'n/a' line = stack['lineno'] if 'lineno' in stack else 'n/a' content += ' {0}.{1}() at <info>{2}:{3}</info>{4}'.format( className, function, file, line, nl, ) content += nl content += nl if isinstance(e, StandardException): e = e.getPrevious() else: e = False return content
def format(self, cpass, message): assert isinstance(cpass, CompilerPassInterface) return '{0}: {1}'.format(ReflectionObject(cpass).getName(), message)