--- /dev/null
+<?php
+
+namespace Drupal\drupalmoduleupgrader;
+
+use Drupal\Component\Serialization\Yaml;
+use Drupal\drupalmoduleupgrader\Utility\Filter\ContainsLogicFilter;
+use Drupal\drupalmoduleupgrader\Utility\Filter\FunctionCallArgumentFilter;
+use Pharborist\DocCommentNode;
+use Pharborist\Filter;
+use Pharborist\Functions\FunctionCallNode;
+use Pharborist\Functions\FunctionDeclarationNode;
+use Pharborist\Functions\ParameterNode;
+use Pharborist\LineCommentBlockNode;
+use Pharborist\Objects\ClassNode;
+use Pharborist\Parser;
+use Pharborist\Variables\VariableNode;
+use Pharborist\WhitespaceNode;
+use Symfony\Component\Filesystem\Filesystem;
+
+/**
+ * Base class for converters.
+ */
+abstract class ConverterBase extends PluginBase implements ConverterInterface {
+
+ // Used by buildFixMe() to determine the comment style of the generated
+ // FIXME notice.
+ const LINE_COMMENT = '//';
+ const DOC_COMMENT = '/**/';
+
+ /**
+ * {@inheritdoc}
+ */
+ public function isExecutable(TargetInterface $target) {
+ // If the plugin applies to particular hook(s), only return TRUE if the
+ // target module implements any of the hooks. Otherwise, return TRUE
+ // unconditionally.
+ if (isset($this->pluginDefinition['hook'])) {
+ return (boolean) array_filter((array) $this->pluginDefinition['hook'], [ $target->getIndexer('function'), 'has' ]);
+ }
+ else {
+ return TRUE;
+ }
+ }
+
+ /**
+ * Executes the target module's implementation of the specified hook, and
+ * returns the result.
+ *
+ * @return mixed
+ *
+ * @throws \LogicException if the target module doesn't implement the
+ * specified hook, or if the implementation contains logic.
+ *
+ * @deprecated
+ */
+ protected function executeHook(TargetInterface $target, $hook) {
+ $indexer = $target->getIndexer('function');
+
+ if ($indexer->has($hook)) {
+ // Configure the ContainsLogicFilter so that certain "safe" functions
+ // will pass it.
+ $has_logic = new ContainsLogicFilter();
+ $has_logic->whitelist('t');
+ $has_logic->whitelist('drupal_get_path');
+
+ $function = $indexer->get($hook);
+ if ($function->is($has_logic)) {
+ throw new \LogicException('{target}_{hook} cannot be executed because it contains logic.');
+ }
+ else {
+ $function_name = $function->getName()->getText();
+ if (! function_exists($function_name)) {
+ eval($function->getText());
+ }
+ return call_user_func($function_name);
+ }
+ }
+ else {
+ throw new \LogicException('{target} does not implement hook_{hook}.');
+ }
+ }
+
+ /**
+ * Creates an empty implementation of a hook.
+ *
+ * @param TargetInterface $target
+ * The target module.
+ * @param string $hook
+ * The hook to implement, without the hook_ prefix.
+ *
+ * @return \Pharborist\Functions\FunctionDeclarationNode
+ * The hook implementation, appended to the main module file.
+ */
+ protected function implement(TargetInterface $target, $hook) {
+ $function = FunctionDeclarationNode::create($target->id() . '_' . $hook);
+ $function->setDocComment(DocCommentNode::create('Implements hook_' . $hook . '().'));
+
+ $module_file = $target->getPath('.module');
+ $target->open($module_file)->append($function);
+
+ WhitespaceNode::create("\n")->insertBefore($function);
+ WhitespaceNode::create("\n")->insertAfter($function);
+
+ return $function;
+ }
+
+ /**
+ * Writes a file to the target module's directory.
+ *
+ * @param TargetInterface $target
+ * The target module.
+ * @param string $path
+ * The path of the file to write, relative to the module root.
+ * @param string $data
+ * The file contents.
+ *
+ * @return string
+ * The path of the file, including the target's base path.
+ */
+ public function write(TargetInterface $target, $path, $data) {
+ static $fs;
+ if (empty($fs)) {
+ $fs = new Filesystem();
+ }
+
+ $destination_path = $target->getPath($path);
+ $fs->dumpFile($destination_path, (string) $data);
+
+ return $destination_path;
+ }
+
+ /**
+ * Writes a class to the target module's PSR-4 root.
+ *
+ * @param TargetInterface $target
+ * The target module.
+ * @param ClassNode $class
+ * The class to write. The path will be determined from the class'
+ * fully qualified name.
+ *
+ * @return string
+ * The generated path to the class.
+ */
+ public function writeClass(TargetInterface $target, ClassNode $class) {
+ $class_path = ltrim($class->getName()->getAbsolutePath(), '\\');
+ $path = str_replace([ 'Drupal\\' . $target->id(), '\\', ], [ 'src', '/' ], $class_path) . '.php';
+
+ return $this->write($target, $path, $class->parents()->get(0));
+ }
+
+ /**
+ * Writes out arbitrary data in YAML format.
+ *
+ * @param TargetInterface $target
+ * The target module.
+ * @param string $group
+ * The name of the YAML file. It will be prefixed with the module's machine
+ * name and suffixed with .yml. For example, a group value of 'routing'
+ * will write MODULE.routing.yml.
+ * @param array $data
+ * The data to write.
+ *
+ * @todo This should be writeYAML, not writeInfo.
+ */
+ protected function writeInfo(TargetInterface $target, $group, array $data) {
+ $destination = $target->getPath('.' . $group . '.yml');
+ file_put_contents($destination, Yaml::encode($data));
+ }
+
+ /**
+ * Writes a service definition to the target module's services.yml file.
+ *
+ * @param TargetInterface $target
+ * The target module.
+ * @param string $service_id
+ * The service ID. If an existing one with the same ID already exists,
+ * it will be overwritten.
+ * @param array $service_definition
+ */
+ protected function writeService(TargetInterface $target, $service_id, array $service_definition) {
+ $services = $target->getServices();
+ $services->set($service_id, $service_definition);
+ $this->writeInfo($target, 'services', [ 'services' => $services->toArray() ]);
+ }
+
+ /**
+ * Parses a generated class into a syntax tree.
+ *
+ * @param string|array $class
+ * The class to parse, either as a string of PHP code or a renderable array.
+ *
+ * @return \Pharborist\Objects\ClassNode
+ */
+ protected function parse($class) {
+ if (is_array($class)) {
+ $class = \Drupal::service('renderer')->renderPlain($class);
+ }
+ return Parser::parseSnippet($class)->find(Filter::isInstanceOf('Pharborist\Objects\ClassNode'))[0];
+ }
+
+ /**
+ * Builds a FIXME notice using either the text in the plugin definition,
+ * or passed-in text.
+ *
+ * @param string|NULL $text
+ * The FIXME notice's text, with variable placeholders and no translation.
+ * @param array $variables
+ * Optional variables to use in translation. If empty, the FIXME will not
+ * be translated.
+ * @param string|NULL $style
+ * The comment style. Returns a LineCommentBlockNode if this is set to
+ * self::LINE_COMMENT, a DocCommentNode if self::DOC_COMMENT, or the FIXME
+ * as a string if set to anything else.
+ *
+ * @return mixed
+ */
+ protected function buildFixMe($text = NULL, array $variables = [], $style = self::LINE_COMMENT) {
+ $fixMe = "@FIXME\n" . ($text ?: $this->pluginDefinition['fixme']);
+
+ if (isset($this->pluginDefinition['documentation'])) {
+ $fixMe .= "\n";
+ foreach ($this->pluginDefinition['documentation'] as $doc) {
+ $fixMe .= "\n@see ";
+ $fixMe .= (isset($doc['url']) ? $doc['url'] : (string) $doc);
+ }
+ }
+
+ if ($variables) {
+ $fixMe = $this->t($fixMe, $variables);
+ }
+
+ switch ($style) {
+ case self::LINE_COMMENT:
+ return LineCommentBlockNode::create($fixMe);
+
+ case self::DOC_COMMENT:
+ return DocCommentNode::create($fixMe);
+
+ default:
+ return $fixMe;
+ }
+ }
+
+ /**
+ * Parametrically rewrites a function.
+ *
+ * @param \Drupal\drupalmoduleupgrader\RewriterInterface $rewriter
+ * A fully configured parametric rewriter.
+ * @param \Pharborist\Functions\ParameterNode $parameter
+ * The parameter upon which to base the rewrite.
+ * @param TargetInterface $target
+ * The target module.
+ * @param boolean $recursive
+ * If TRUE, rewriting will recurse into called functions which are passed
+ * the rewritten parameter as an argument.
+ */
+ protected function rewriteFunction(RewriterInterface $rewriter, ParameterNode $parameter, TargetInterface $target, $recursive = TRUE) {
+ $rewriter->rewrite($parameter);
+ $target->save($parameter);
+
+ // Find function calls within the rewritten function which are called
+ // with the rewritten parameter.
+ $indexer = $target->getIndexer('function');
+ $next = $parameter
+ ->getFunction()
+ ->find(new FunctionCallArgumentFilter($parameter->getName()))
+ ->filter(function(FunctionCallNode $call) use ($indexer) {
+ return $indexer->has($call->getName()->getText());
+ });
+
+ /** @var \Pharborist\Functions\FunctionCallNode $call */
+ foreach ($next as $call) {
+ /** @var \Pharborist\Functions\FunctionDeclarationNode $function */
+ $function = $indexer->get($call->getName()->getText());
+
+ foreach ($call->getArguments() as $index => $argument) {
+ if ($argument instanceof VariableNode && $argument->getName() == $parameter->getName()) {
+ $this->rewriteFunction($rewriter, $function->getParameterAtIndex($index), $target, $recursive);
+ break;
+ }
+ }
+ }
+ }
+
+}
projects / yaffs-website / blobdiff