Registering all vendor items which needs to be published
518516
protected function registerPublishElements ()
    {
        $directory = $this->homeDirectory . '/../../database/migrations/';

        // Publish your migrations
        if (file_exists ($directory))
            $this->publishes ([
                $this->homeDirectory . '/../../database/migrations/' => database_path ('/migrations'),
            ], 'migrations');

        $directory = $this->homeDirectory . '/../public';

        // Publishing assets
        if (file_exists ($directory))
            $this->publishes ([
                $this->homeDirectory . '/../public' => public_path ('honeycomb'),
            ], 'public');

        $directory = $this->homeDirectory . '/../config';

        // Publishing assets
        if (file_exists ($directory))
            $this->publishes ([
                $this->homeDirectory . '/../config' => config_path('/'),
            ], 'config');
    }
886764
public static function register()
    {
        \Deployer\set('release_path_app', function () { return ReleaseConfig::getReleasePathAppDir(); });
        \Deployer\set('shared_path_app', function () { return ReleaseConfig::getSharedPathAppDir(); });

        \Deployer\set('release_name', function () { return GetReleasesNameService::execute(); });
        \Deployer\set('releases_list', function () { return GetReleasesListService::execute(); });
    }
805212
protected function registerAssetPublisher(): void
    {
        $this->app->singleton('asset.publisher', function (Application $app) {
            $publicPath = $app->publicPath();

            // The asset "publisher" is responsible for moving package's assets into the
            // web accessible public directory of an application so they can actually
            // be served to the browser. Otherwise, they would be locked in vendor.
            $publisher = new Asset($app->make('files'), $publicPath);

            $publisher->setPackagePath($app->basePath().'/vendor');

            return $publisher;
        });
    }
1221141
public function registerDirectories()
    {
        // Publish config files
        $this->publishes([
             __DIR__.'/../config' => config_path('decoy')
        ], 'config');

        // Publish decoy css and js to public directory
        $this->publishes([
            __DIR__.'/../dist' => public_path('assets/decoy')
        ], 'assets');

        // Publish lanaguage files
        $this->publishes([
            __DIR__.'/../lang' => resource_path('lang/vendor/decoy')
        ], 'lang');

        // Register views
        $this->loadViewsFrom(__DIR__.'/../views', 'decoy');

        // Load translations
        $this->loadTranslationsFrom(__DIR__.'/../lang', 'decoy');

        // Load migrations
        $this->loadMigrationsFrom(__DIR__.'/../migrations/');
    }
640774
def register(self):
        """"""
        # connect to tracker
        result = requests.post(urljoin(self.tracker, 'models'), data=json.dumps(self.metadata))
        logger.debug("registered at server %s: %s", self.tracker, result)
        self.metadata["tracker"] = result.json()
1372992
private function publishAllVendors()
    {
        //Spatie Permission
        $this->call('vendor:publish', [
            '--provider' => 'Spatie\\Permission\\PermissionServiceProvider',
            '--tag' => 'migrations'
        ]);
        $this->call('vendor:publish', [
            '--provider' => 'Spatie\\Permission\\PermissionServiceProvider',
            '--tag' => 'config'
        ]);

        //Spatie Backup
        $this->call('vendor:publish', [
            '--provider' => "Spatie\\Backup\\BackupServiceProvider",
        ]);

        //Media
        $this->call('vendor:publish', [
            '--provider' => 'Spatie\\MediaLibrary\\MediaLibraryServiceProvider',
            '--tag' => 'migrations'
        ]);
        $this->call('vendor:publish', [
            '--provider' => "Brackets\\Media\\MediaServiceProvider",
        ]);

        //Advanced logger
        $this->call('vendor:publish', [
            '--provider' => "Brackets\\AdvancedLogger\\AdvancedLoggerServiceProvider",
        ]);

        //Craftable
        $this->call('vendor:publish', [
            '--provider' => "Brackets\\Craftable\\CraftableServiceProvider",
        ]);
    }
102192
public function registerViewComposerData()
    {
        View::composer('avored-ecommerce::layouts.left-nav', AdminNavComposer::class);
        View::composer('avored-ecommerce::site-currency._fields', SiteCurrencyFieldsComposer::class);
        View::composer(['avored-ecommerce::category._fields'], CategoryFieldsComposer::class);
        View::composer(['avored-ecommerce::admin-user._fields'], AdminUserFieldsComposer::class);
        View::composer(['avored-ecommerce::product.create',
                        'avored-ecommerce::product.edit',
                        ], ProductFieldsComposer::class);
    }
420135
protected function registerViewPublishCommand(): void
    {
        $this->app->singleton('command.view.publish', function (Application $app) {
            return new ViewPublishCommand($app->make('view.publisher'));
        });
    }
21266
private function publishVendorAssets()
	{
		$this->info('publishing config files...');
		$this->info( shell_exec( "php artisan vendor:publish --tag=config" ) );
		$this->info('pushing module assets to application...');
		$this->info( shell_exec( "php artisan vendor:publish --tag=forced --force" ) );
	}
1007815
private function publishModule()
    {
        $from = base_path('vendor/typicms/'.$this->module.'/src');
        $to = base_path('Modules/'.ucfirst($this->module));

        if ($this->files->isDirectory($from)) {
            $this->publishDirectory($from, $to);
        } else {
            $this->error("Can’t locate path: <{$from}>");
        }

        $this->info('Publishing complete for module ['.ucfirst($this->module).']!');
    }
1116773
public function registerpublisher()
    {
        $this->app['generate.publish-templates'] = $this->app->share(function($app)
        {
            return new publishtemplatescommand;
        });

        $this->commands('generate.publish-templates');
    }
859014
protected function triggerPublish()
    {
        $this->info('Starting publishing vendor assets.');
        $this->call('vendor:publish');
        $this->info('Publishing vendor assets finished.');

        // Reload config
        $this->laravel['Illuminate\Foundation\Bootstrap\LoadConfiguration']->bootstrap($this->laravel);
    }
998524
public function addVendor()
    {
        $oConfig = \OxidEsales\Eshop\Core\Registry::getConfig();

        $aAddArticle = $this->_getActionIds('oxarticles.oxid');
        $soxId = $oConfig->getRequestParameter('synchoxid');

        if ($oConfig->getRequestParameter('all')) {
            $sArtTable = $this->_getViewName('oxarticles');
            $aAddArticle = $this->_getAll($this->_addFilter("select $sArtTable.oxid " . $this->_getQuery()));
        }

        if ($soxId && $soxId != "-1" && is_array($aAddArticle)) {
            $oDb = \OxidEsales\Eshop\Core\DatabaseProvider::getDb();
            $sSelect = "update oxarticles set oxvendorid = " . $oDb->quote($soxId) . " where "
                . $this->onVendorActionArticleUpdateConditions($aAddArticle);

            $oDb->Execute($sSelect);
            $this->resetCounter("vendorArticle", $soxId);

            $this->onVendorAction($soxId);
        }
    }
975560
protected function registerAssetPublisher()
	{
		$this->registerAssetPublishCommand();

		$this->app->bindShared('asset.publisher', function($app)
		{
			$publicPath = $app['path.public'];

			// The asset "publisher" is responsible for moving package's assets into the
			// web accessible public directory of an application so they can actually
			// be served to the browser. Otherwise, they would be locked in vendor.
			$publisher = new AssetPublisher($app['files'], $publicPath);

			$publisher->setPackagePath($app['path.base'].'/vendor');

			return $publisher;
		});
	}
744165
protected function registerConfigPublisher()
	{
		$this->registerConfigPublishCommand();

		$this->app->bindShared('config.publisher', function($app)
		{
			$path = $app['path'].'/config';

			// Once we have created the configuration publisher, we will set the default
			// package path on the object so that it knows where to find the packages
			// that are installed for the application and can move them to the app.
			$publisher = new ConfigPublisher($app['files'], $path);

			$publisher->setPackagePath($app['path.base'].'/vendor');

			return $publisher;
		});
	}
304432
def registerResponse(self, node, vendorSpecific=None):
        
        mmp_dict = {'node': ('node.xml', node.toxml('utf-8'))}
        return self.POST('node', fields=mmp_dict, headers=vendorSpecific)
1101879
protected void doPublish(String tenantId, List<T> items, String subscriber,
            int retryCount, long delay) throws Exception {
        String data = mapper.writeValueAsString(items);

        TextMessage tm = session.createTextMessage(data);

        if (tenantId != null) {
            tm.setStringProperty("tenant", tenantId);
        }

        if (subscriber != null) {
            tm.setStringProperty("subscriber", subscriber);
        }

        tm.setIntProperty("retryCount", retryCount);

        if (delay > 0) {
            tm.setLongProperty("_AMQ_SCHED_DELIVERY", System.currentTimeMillis() + delay);
        }

        if (log.isLoggable(Level.FINEST)) {
            log.finest("Publish: " + tm);
        }

        producer.send(tm);
    }