Generate trivia lines.

@return static
549499
public function trivia()
    {
        $this->array = true;

        $this->count = 1;

        $this->items = (new TriviaService())->all();

        return $this;
    }
1188406
public function textMessages()
    {
        $result = [];
        foreach ($this->entries as $entry) {
            foreach ($entry->messages as $entryMessage) {
                if ($entryMessage->isMessage) {
                    if ($entryMessage->message->isText && !$entryMessage->message->isQuickReply) {
                        $result[] = $entryMessage;
                    }
                }
            }
        }
        return collect($result);
    }
1291961
protected function _line()
    {
        $lines = explode("\n", $this->_lyrics);
        return '♪ ♫ ♭♯ ~ ' . trim($lines[array_rand($lines)]) . ' ~ ♪ ♫ ♭♯';
    }
866496
public function generate()
    {
        $this->fill();
        $content = [];
        foreach ($this->_cells as $item) {
            $content[] = $item->generate();
        }
        //return implode('', $content);
        return Html::tag('div', implode('', $content), $this->htmlOptions);
    }
901245
public function getAddedLines()
    {
        return array_values(array_filter(
            $this->lines,
            function (Line $line) {
                return $line->getType() == Line::ADDED;
            }
        ));
    }
588176
public function toDictionary()
    {
        return $this->pairs()->reduce(function (Collection $pairs, LineInterface $line) {
            $pairs[ $line->key() ] = $line->value();

            return $pairs;
        }, new Collection);
    }
883391
public function generate()
    {
        $reference = [];

        $scanner = $this->getScanner();

        /** @var  $class ClassScanner */
        foreach ($scanner->getClasses() as $class) {
            $footprint = $this->getClassFootprint($class);
            $reference[$class->getName()] = $footprint->export();
        }
        $reference = json_encode($reference);

        return $reference;
    }
945831
public function generate(): string
    {
        $classCode = $this->generator->generate();

        return $classCode
            // Inject advices on call
            . '\\' . __CLASS__ . '::injectJoinPoints(' . $this->generator->getName() . '::class);';
    }
1024948
protected function createExampleSteps()
    {
        $steps = array();
        foreach ($this->outlineSteps as $outlineStep) {
            $keyword = $outlineStep->getKeyword();
            $keywordType = $outlineStep->getKeywordType();
            $text = $this->replaceTextTokens($outlineStep->getText());
            $args = $this->replaceArgumentsTokens($outlineStep->getArguments());
            $line = $outlineStep->getLine();

            $steps[] = new StepNode($keyword, $text, $args, $line, $keywordType);
        }

        return $steps;
    }
751823
protected function renderUsesLines()
    {
        $code = array();
        $indentation = $this->getIndentation();
        foreach ($this->uses as $use => $alias) {
            if ($alias === null) {
                $code[] = $indentation . 'use ' . $use . ';';
            } else {
                $code[] = $indentation . 'use ' . $use . ' as ' . $alias . ';';
            }
        }

        if (count($this->uses) > 0) {
            $code[] = null;
        }

        return $code;
    }
73105
private function getNewUseStatements(): string
    {
        $this->sortUseStatements();

        $file = $this->getFile()->getBaseFile();

        return implode(
            $file->eolChar,
            array_map(
                function (UseStatement $useStatement) use ($file): string {
                    $unqualifiedName = NamespaceHelper::getUnqualifiedNameFromFullyQualifiedName(
                        $useStatement->getFullyQualifiedTypeName()
                    );

                    $useTypeName = UseStatementHelper::getTypeName($file, $useStatement);
                    $useTypeFormatted = $useTypeName ? sprintf('%s ', $useTypeName) : '';

                    return ($unqualifiedName === $useStatement->getNameAsReferencedInFile())
                        ? sprintf(
                            'use %s%s;',
                            $useTypeFormatted,
                            $useStatement->getFullyQualifiedTypeName()
                        )
                        : sprintf(
                            'use %s%s as %s;',
                            $useTypeFormatted,
                            $useStatement->getFullyQualifiedTypeName(),
                            $useStatement->getNameAsReferencedInFile()
                        );
                },
                $this->useStatements
            )
        );
    }
1015122
public function generate()
    {
        $indentation = $this->getIndentation();

        $code = $indentation . 'use ' . $this->traitClass;
        if (count($this->conflictsResolutions) > 0) {
            $conflictIndentation = $indentation . $this->indentationString;
            $code .= ' {' . $this->lineFeed;
            foreach ($this->conflictsResolutions as $conflict) {
                $code .= $conflictIndentation . rtrim($conflict, ';') . ';' . $this->lineFeed;
            }
            $code .= $indentation . '}';
        } else {
            $code .= ';';
        }

        return $code;
    }
1229523
public function generate()
	{
		$title         = $this->getTitle();
		$description   = $this->getDescription();
		$keywords      = $this->getKeywords();
		$miscellaneous = $this->getMiscellaneous();
		$canonical     = $this->getCanonical();

		$html[] = '<title>'.$title.'</title>'.PHP_EOL;

		if (! is_null($description)) {
			$html[] = '<meta name="description" content="'.$description.'">';
		}

		if (! is_null($keywords)) {
			$html[] = '<meta name="keywords" content="'.$keywords.'">';
		}

		if (! is_null($miscellaneous)) {
			foreach ($miscellaneous as $name => $content) {
				$html[] = '<meta name="'.$name.'" content="'.$content.'">';
			}
		}

		if (! is_null($canonical)) {
			$currentUrl = $this->request->fullUrl();

			if ($canonical != $currentUrl) {
				$html[] = PHP_EOL.'<link rel="canonical" href="'.$canonical.'">';
			}
		}

		return implode(PHP_EOL, $html);
	}
628443
public function getAllInterpretations()
    {
        $hash = $this->_getInterpreterHash();

        if (!$this->allowCache || empty($this->_allInterpretations[$hash])) {
            $this->_allInterpretations[$hash] = $this->pushMissingInterpretations($this->getInterpretations());
        }

        return $this->_allInterpretations[$hash];
    }
802154
public function getBogusContent()
    {
        $generator = $this->documentGenerator->getInlineGenerator('textline');
        $generator->addRawContent($this->beginTag);
        foreach ($this->generator->getChildGenerators() as $child) {
            $generator->addContent($child);
        }
        return $generator;
    }
97918
public function deIndent()
    {
        $ltrim = $this->getIndent();
        if( $ltrim > 0 ) {
            foreach( $this->lines as &$line ) {
                $line = substr( $line, $ltrim );
            }
        }
        return $this;
    }
1276757
public function generate()
    {
        $this->loadWebMasterTags();

        $title       = $this->getTitle();
        $description = $this->getDescription();
        $keywords    = $this->getKeywords();
        $metatags    = $this->metatags;

        $html   = [];

        if($title):
            $html[] = "<title>$title</title>";
        endif;

        if(!empty($description)):
            $html[] = "<meta name=\"description\" content=\"{$description}\" />";
        endif;

        if (!empty($keywords)):
            $keywords = implode(',', $keywords);
            $html[]   = "<meta name=\"keywords\" content=\"{$keywords}\" />";
        endif;

        foreach ($metatags as $key => $value):
            $name    = $value[0];
            $content = $value[1];
            $html[]  = "<meta {$name}=\"{$key}\" content=\"{$content}\" />";
        endforeach;

        return implode(PHP_EOL, $html);
    }