publish the wiki where it should go
516879
function (next) {
            // silence terminal output to prevent leaking sensitive information
            config.silent = true;

            pushd(WIKI_GIT_PATH);
            exec('git add --all');
            exec('git commit -m "[auto] ' + WIKI_VERSION + '"');
            exec('git push origin master', function (code) {
                popd();
                next(code);
            });
        }
937099
def edit_wiki_page(self, subreddit, page, content, reason=''):
        
        data = {'content': content,
                'page': page,
                'r': six.text_type(subreddit),
                'reason': reason}
        evict = self.config['wiki_page'].format(
            subreddit=six.text_type(subreddit), page=page.lower())
        self.evict(evict)
        return self.request_json(self.config['wiki_edit'], data=data)
1329325
def write(self):
        
        if not hasattr(self, 'space'):
            raise AttributeError("A WikiPage must have a 'space' attribute before you can write it to Assembla.")

        self.api = self.space.api

        if self.get('id'):  # We are modifying an existing wiki page
            return self.api._put_json(
                self,
                space=self.space,
                rel_path=self.space._build_rel_path('wiki_pages'),
                id_field='id'
            )
        else:  # Creating a new wiki page
            return self.api._post_json(
                self,
                space=self.space,
                rel_path=self.space._build_rel_path('wiki_pages'),
            )
464182
def create_wiki(post_data):
        '''
        
        '''
        logger.info('Call create wiki')

        title = post_data['title'].strip()
        if len(title) < 2:
            logger.info(' ' * 4 + 'The title is too short.')
            return False

        the_wiki = MWiki.get_by_wiki(title)
        if the_wiki:
            logger.info(' ' * 4 + 'The title already exists.')
            MWiki.update(the_wiki.uid, post_data)
            return

        uid = '_' + tools.get_uu8d()

        return MWiki.__create_rec(uid, '1', post_data=post_data)
701389
def publish(self):
        """"""
        while not self.ws.closed:
            # Sleep to prevent *constant* context-switches.
            gevent.sleep(self.lag_tolerance_secs)
            message = self.ws.receive()
            if message is not None:
                channel_name, data = message.split(":", 1)
                redis_conn.publish(channel_name, data)
184640
function publish() {
			if (!options.distBranch) {
				rbot.log.info('Skipping publishing from "' + pubSrcDir + '" to ' + pubDistDir + ' (no distBranch)');
				return;
			} else if (!commit.releaseId) {
				rbot.log.info('Skipping publishing from "' + pubSrcDir + '" to "' + pubDistDir + '" in branch "'
						+ options.distBranch + '" (no releaseId/tag)');
				return;
			}
			rbot.log.info('Publishing to branch "' + options.distBranch + '"');
			rbot.log.info('Copying publication directories/files from "' + pubSrcDir + '" to "' + pubDistDir + '"');
			// copy all directories/files over that need to be published
			// so that they are not removed by the following steps
			rbot.log.info(utils.copyRecursiveSync(pubSrcDir, pubDistDir, options.distExcludeDirRegExp,
					options.distExcludeFileRegExp).toString());
			// cmd('cp -r ' + path.join(pubSrcDir, '*') + ' ' + pubDistDir);
			chkoutRun(null, publishRun);
			function publishRun() {
				try {
					cmd('git fetch ' + options.repoName + ' ' + options.distBranch);
					pubHash = cmd('git rev-parse HEAD');
				} catch (e) {
					if (util.isRegExp(options.distBranchCreateRegExp) && options.distBranchCreateRegExp.test(e.message)) {
						cmd('git checkout -q --orphan ' + options.distBranch);
					} else {
						throw e;
					}
				}
				if (pubHash) {
					cmd('git checkout -q --track ' + options.repoName + '/' + options.distBranch);
				}
				cmd('git rm -rfq .');
				cmd('git clean -dfq .');
				rbot.log.info('Copying publication directories/files from "' + pubDistDir + '" to "' + commit.buildDir
						+ '"');
				rbot.log.info(utils.copyRecursiveSync(pubDistDir, commit.buildDir).toString());
				// cmd('cp -r ' + path.join(pubDistDir, '*') + '
				// .');

				// give taskateers a chance to update branch file
				// contents
				utils.updateFiles(options.distBranchUpdateFiles, options.distBranchUpdateFunction, commit.buildDir,
						rollCall.error);

				cmd('git add -A');
				cmd('git commit -q -m "' + tmpltData.distBranchPubMsg + '"');
				cmd('git push -f ' + options.repoName + ' ' + options.distBranch);

				rollCall.addRollback(rollbackPublish);
				rollCall.then(pack.publish);
			}
		}
1151038
def publish(self, key, data):
        '''
        
        '''
        publish_data = {key: data}
        self.handler.send(salt.utils.json.dumps(publish_data), False)
1248692
def publish(self, artifact):
        
        self.env.add_artifact(artifact)
        self._log(logging.DEBUG, "Published {} to domain.".format(artifact))
1058894
private function publishConfig()
    {
        if (!file_exists(getcwd().'/config/crudmaker.php')) {
            $this->copyDirectory(__DIR__.'/../../config', getcwd().'/config');
            $this->info("\n\nLumen config file have been published");
        } else {
            $this->error('Lumen config files has already been published');
        }
    }
286069
def publish(build_entry: dict):
    """"""
    for tag in build_entry['tags']:
        print('[PUSHING]:', tag)
        os.system('docker push {}'.format(tag))
1360488
def publish
      @options['date'] ||= read_post_yaml('date') || Time.now.iso8601
      @options['title'] = read_post_yaml('title')

      post_options = {
        'title'     => @options['title'],
        'date'      => @options['date'],
        'slug'      => path_slug(@options['path']),
        'extension' => File.extname(@options['path']).sub(/^\./, ''),
        'content'   => read_post_content,
        'dir'       => @options['dir'],
        'type'      => "post from draft",
        'write_message' => "Published: #{relative_path(path)} →",
        'force'     => @options['force']
      }

      # Create a new post file
      #
      Post.new(site, post_options).write
      
      # Remove the old draft file
      #
      FileUtils.rm @options['path']

    end
927069
public function publish($dest = null)
    {
        $this->yell('Publishing Peridot docs');
        if (!$dest) {
            $dest = __DIR__ . '/../peridot-php.github.io';
        }
        $cwd = getcwd();
        chdir($dest);
        $this->taskGitStack()
            ->add('-A')
            ->commit('auto-update')
            ->pull()
            ->push()
            ->run();
        chdir($cwd);
    }
1187146
def pub(self,con):
    ""
    k,v=self.kv()
    con.publish(k,v)
564755
def publish(self, func):
        """"""
        project = self.session.get_default_project()
        func_name = "projects/{}/locations/{}/functions/{}".format(
            project, self.region, func.name)
        func_info = self.get(func.name)
        source_url = None

        archive = func.get_archive()
        if not func_info or self._delta_source(archive, func_name):
            source_url = self._upload(archive, self.region)

        config = func.get_config()
        config['name'] = func_name
        if source_url:
            config['sourceUploadUrl'] = source_url

        # todo - we'll really need before() and after() for pre-provisioning of
        # resources (ie topic for function stream on create) and post provisioning (schedule
        # invocation of extant function).
        #
        # convergent event source creation
        for e in func.events:
            e.add(func)

        if func_info is None:
            log.info("creating function")
            response = self.client.execute_command(
                'create', {
                    'location': "projects/{}/locations/{}".format(
                        project, self.region),
                    'body': config})
        else:
            delta = delta_resource(func_info, config, ('httpsTrigger',))
            if not delta:
                response = None
            else:
                update_mask = ','.join(delta)
                log.info("updating function config %s", update_mask)
                response = self.client.execute_command(
                    'patch', {
                        'name': func_name,
                        'body': config,
                        'updateMask': update_mask})
        return response
1359970
def publish(branch, full_force=False):
    """"""
    checkout(branch)
    try:
        push('--force --set-upstream origin', branch)
    except ExistingReference:
        if full_force:
            push('origin --delete', branch)
            push('--force --set-upstream origin', branch)
699081
def publish_if_new(cls):
    """"""
    message = cls.make_message()
    if message != cls.last_message:
      super(DashboardPubSub, cls).publish(message)
      cls.last_message = message
182855
def publish_workflow_submission(self,
                                    user_id,
                                    workflow_id_or_name,
                                    parameters):
        """"""
        msg = {
            "user": user_id,
            "workflow_id_or_name": workflow_id_or_name,
            "parameters": parameters
        }
        self._publish(msg)