run seeds from all files in seeds directory

@param type $name
490662
public function seed($name, $paths = null)
    {
        $directories = is_null($paths) ? $this->getPaths($name, 'seeds') : $paths;
        $files       = $this->app->make('files');


        foreach ($directories as $path) {


            if ($files->isDirectory($path)) {
                $allFiles = $files->allFiles($path);


                foreach ($allFiles as $file) {

                    $class = $this->prepareSeedClass($file);
                    if (!is_null($class)) {
                        $this->seeder->call($this->prepareSeedClass($file));
                    }
                }
            }
        }
    }
945714
public function runHooks($name, AbstractContext $context, $reverse = false)
    {
        $parent = $this->getParent();
        $hooks = $this->hooks[$name];

        if ($reverse) { 
            foreach (array_reverse($hooks) as $hook) {
                $hook->run($context); 
            }
            if ($parent) {
                $parent->runHooks($name, $context, $reverse);
            }
        } else {
            if ($parent) {
                $parent->runHooks($name, $context, $reverse);
            }
            foreach ($hooks as $hook) {
                $hook->run($context); 
            }
        } 
    }
216714
public function move($dir, $name = null)
    {
        if ($this->isValid()) {

            if ($this->test) {
                return parent::move($dir, $name);
            }

            if (is_uploaded_file($this->getPathname())) {

                $target = $this->getTargetFile($dir, $name);

                move_uploaded_file($this->getPathname(), $target);

                chmod($target, 0666 & ~umask());

                return $target;
            }
        }

        throw new \RuntimeException("The file {$this->getPathname()} has not been uploaded via Http");
    }
1200760
public function create($name = '')
    {

        $names = explode(",", $name);

        foreach ($names as $name) {

            $content = $this->migrate(RESOURCE . 'migrations/migration.php.dist', ['name' => $name]);

            $fileName = FacadeMigration::createName($name);
            if (!$this->file->exists($fileName)) {
                $this->file->create($fileName);
                $this->write(MIGRATION, $fileName, $content);
                $this->info(sprintf('%s migration created with successfully', $name));
            } else {
                $this->error(sprintf('%s file already exists in %s', $name, $fileName));
            }
        }

    }
658117
public function extension(string $name): bool
    {
        $files = $this->app->make('files');

        list($basePath, $sourcePath) = $this->getPathFromExtensionName($name);

        $paths = [
            "{$basePath}/resources/database/migrations/",
            "{$basePath}/resources/migrations/",
            "{$basePath}/database/migrations/",
        ];

        // We don't execute the same migration twice, this little code
        // compare both folder before appending the paths.
        if ($basePath !== $sourcePath && ! empty($sourcePath)) {
            $paths = array_merge($paths, [
                "{$sourcePath}/resources/database/migrations/",
                "{$sourcePath}/resources/migrations/",
                "{$sourcePath}/database/migrations/",
            ]);
        }

        foreach ($paths as $path) {
            if ($files->isDirectory($path)) {
                $this->run($path);
            }
        }

        return true;
    }
676024
public function runMacro($name, $args)
    {
        if (isset($this->macros[$name])) {
            if (is_callable($this->macros[$name])) {
                return call_user_func_array($this->macros[$name], array_merge([$this], $args));
            }
        }
    }
1282737
public function execUp(string $name): void{
        DB::connection('default')->table('migrations')->insert(['name' => $name]);
        $this->up();
    }
234303
private function _saveSd ($path, $name, $file)
		{
			$this->_save($path . DIRECTORY_SEPARATOR . self::F_SD . DIRECTORY_SEPARATOR . $name, $file, self::F_SD);
		}
697925
public function run()
    {
        Model::unguard();
        try {
            foreach ($this->seederClasses as $seederClass) {
                $this->parentSeeder->call($seederClass);
            }
        } finally {
            Model::reguard();
        }
    }
503557
public static function runApplication($name, ClassLoader $classLoader = null)
    {
        $class = sprintf('Ftven\\Build\\Cli\\Application\\%sApplication', ucfirst($name));

        /** @var CliApplication $application */
        $application = new $class;

        if (null !== $classLoader) {
            if (method_exists($application, 'setClassLoader')) {
                $application->setClassLoader($classLoader);
            }
        }

        return $application->run();
    }
726884
private function loadHelper(string $name): void
    {
        $class = static::class;

        // Somebody forgot to call `addHelperPath`
        if (!isset(static::$helpersPath[$class])) {
            throw new CommonException("Helper path not found for class `$class`");
        }

        // Try to find helper file
        foreach (static::$helpersPath[$class] as $path) {
            if ($helperPath = realpath($path . '/' . ucfirst($name) . '.php')) {
                $this->addHelper($name, $helperPath);
                return;
            }
        }

        throw new CommonException("Helper `$name` not found for class `$class`");
    }
1295798
public function run($name, OutputInterface $output = null)
    {
        if (!$this->has($name)) {
            throw new InvalidArgumentException("No runner service registered for provided name.");
        }
        /* @var $runner WorkerRunnerInterface */
        $runner = $this->runners[$name]['runner'];
        $runner->run($this->runners[$name]['options'], $output);
    }
506053
public static function run($name, array $config = array())
    {
        $generator = self::create($name, $config);

        if (!$generator->validate()) {
            $generator->renderErrors();
        }

        return $generator->generate();
    }
408306
protected function setPluginRootFile(string $name)
    {
        $this->info('Set plugin root file...');
        $this->files->move($this->path($name.'/plugin-name.php'), $this->path($name.'/'.$name.'.php'));
    }
980093
public function startBlock($name)
    {
        if (in_array($name, $this->openBlocks)) {
            throw new InvalidArgumentException(sprintf('A block "%s" is already started.', $name));
        }

        $this->openBlocks[] = $name;

        if (!isset($this->blocks[$name])) {
            $this->blocks[$name] = null;
        }

        ob_start();
        ob_implicit_flush(0);
    }
1311003
public function load($name = '')
    {
        $load = BackupLoader::get($name);
        foreach ($load as $key => $return) {
            if (true === $return) {
                $this->info(sprintf('Your %s backup file loaded with successfully', $key));
            }
        }
    }
452456
protected function dbseed($name)
    {
        $params = [
            '--class' => $this->option('class') ?: $this->getSeederName($name),
        ];

        if ($option = $this->option('database')) {
            $params['--database'] = $option;
        }

        $this->call('db:seed', $params);
    }