Prints the version bump plan.
 @param [Bump::BumpInfo] bump_info The bump info
503440
def print_bump_plan(bump_info)
      level = bump_level
      print_bump_plan_level level, bump_info unless level.nil?

      preid = @options[:preid]
      print_bump_plan_preid preid, bump_info unless preid.nil?

      print_bump_plan_release bump_info if @options[:release]

      log
    end
481814
public int bump(CmsUUID id) {

        CmsDetailPageInfo info = m_infoById.get(id);
        if (info == null) {
            throw new IllegalArgumentException();
        }
        String type = info.getType();
        List<CmsDetailPageInfo> infos = m_map.get(type);
        int oldPos = infos.indexOf(info);
        infos.remove(oldPos);
        infos.add(0, info);
        return oldPos;
    }
794516
def bump_version(project, source, force_init):  # type: (str, str, bool, bool) ->int
    
    file_opener = FileOpener()
    # logger.debug("Starting version jiggler...")
    jiggler = JiggleVersion(project, source, file_opener, force_init)

    logger.debug(
        "Current, next : {0} -> {1} : {2}".format(
            jiggler.current_version, jiggler.version, jiggler.schema
        )
    )
    if not jiggler.version_finder.validate_current_versions():

        logger.debug(unicode(jiggler.version_finder.all_current_versions()))
        logger.error("Versions not in sync, won't continue")
        die(-1, "Versions not in sync, won't continue")
    changed = jiggler.jiggle_all()
    logger.debug("Changed {0} files".format(changed))
    return changed
995486
def update(details)
      details.each do |k, v|
        send("#{k}=", v)
      end
      self.class.update(version_key, details)
    end
558221
def versions(self):
        
        print '%s<<< Workbench CLI Version %s >>>%s' % (color.LightBlue, self.version, color.Normal)
        print self.workbench.help('version')
1338070
def update(self, *args):
        

        # remove widgets that don't represent anything anymore
        Logger.debug("Board: updating")
        self.remove_absent_pawns()
        self.remove_absent_spots()
        self.remove_absent_arrows()
        # add widgets to represent new stuff
        self.add_new_spots()
        if self.arrow_cls:
            self.add_new_arrows()
        self.add_new_pawns()
        self.spotlayout.finalize_all()
        Logger.debug("Board: updated")
604510
function bump($user_id = 0)
	{
		global $db, $user;

		$current_time = time();
		if ($user_id == 0)
			$user_id = $user->data['user_id'];

		$db->sql_transaction('begin');

		$sql = 'UPDATE ' . POSTS_TABLE . "
		SET post_time = $current_time
		WHERE post_id = {$this->topic_last_post_id}
		AND topic_id = {$this->topic_id}";
		$db->sql_query($sql);

		$this->topic_bumped = 1;
		$this->topic_bumper = $user_id;
		$this->topic_last_post_time = $current_time;
		$sql = 'UPDATE ' . TOPICS_TABLE . "
		SET topic_last_post_time = $current_time,
		topic_bumped = 1,
		topic_bumper = $user_id
		WHERE topic_id = $topic_id";
		$db->sql_query($sql);

		update_post_information('forum', $this->forum_id);

		$sql = 'UPDATE ' . USERS_TABLE . "
		SET user_lastpost_time = $current_time
		WHERE user_id = $user_id";
		$db->sql_query($sql);

		$db->sql_transaction('commit');

		markread('post', $this->forum_id, $this->topic_id, $current_time, $user_id);

		add_log('mod', $this->forum_id, $this->topic_id, 'LOG_BUMP_TOPIC', $this->topic_title);
	}
256781
public static String versionInfoString(Detail detail) {
        StringBuilder sb = new StringBuilder();
        for(VersionInfo grp : getVersionInfos()){
            sb.append(grp.getGroupId()).append(" : ").append(grp.getArtifactId()).append(" : ").append(grp.getBuildVersion());
            switch (detail){
                case FULL:
                case GAVC:
                    sb.append(" - ").append(grp.getCommitIdAbbrev());
                    if(detail != Detail.FULL) break;

                    sb.append("buildTime=").append(grp.getBuildTime()).append("branch=").append(grp.getBranch())
                            .append("commitMsg=").append(grp.getCommitMessageShort());
            }
            sb.append("\n");
        }
        return sb.toString();
    }
1156511
def update(
        ctx,
        archive_name,
        bumpversion='patch',
        prerelease=None,
        dependency=None,
        message=None,
        string=False,
        file=None):
    '''
    
    '''

    _generate_api(ctx)

    args, kwargs = _parse_args_and_kwargs(ctx.args)
    assert len(args) == 0, 'Unrecognized arguments: "{}"'.format(args)

    dependencies_dict = _parse_dependencies(dependency)

    var = ctx.obj.api.get_archive(archive_name)
    latest_version = var.get_latest_version()

    if string:

        with var.open(
                'w+',
                bumpversion=bumpversion,
                prerelease=prerelease,
                dependencies=dependencies_dict,
                metadata=kwargs,
                message=message) as f:

            if file is None:
                for line in sys.stdin:
                    f.write(u(line))
            else:
                f.write(u(file))

    else:
        if file is None:
            file = click.prompt('enter filepath')

        var.update(
            file,
            bumpversion=bumpversion,
            prerelease=prerelease,
            dependencies=dependencies_dict,
            metadata=kwargs,
            message=message)

    new_version = var.get_latest_version()

    if latest_version is None and new_version is not None:
        bumpmsg = ' new version {} created.'.format(
            new_version)

    elif new_version != latest_version:
        bumpmsg = ' version bumped {} --> {}.'.format(
            latest_version, new_version)

    elif var.versioned:
        bumpmsg = ' version remains {}.'.format(latest_version)
    else:
        bumpmsg = ''

    click.echo('uploaded data to {}.{}'.format(var, bumpmsg))
476769
def info(file=nil)
      wc_path = self.svn_repo_working_copy
      wc_path = file if file and file.class == String

      r_info = Hash.new
      type_info = %w(
                     last_changed_author last_changed_rev
                     last_changed_date conflict_old
                     repos_root_url repos_root_URL
                     copyfrom_rev copyfrom_url conflict_wrk 
                     conflict_new has_wc_info repos_UUID
                     checksum prop_time text_time prejfile
                     schedule taguri lock rev dup url URL
                    ) # changelist depth size tree_conflict working_size

      begin
        @ctx.info(wc_path) do |path, type|
          type_info.each do |t_info|
            r_info[:"#{t_info}"] = type.method(:"#{t_info}").call
          end
        end
      #rescue Svn::Error::WcNotDirectory => e
      #       #Svn::Error::RaIllegalUrl,
      #       #Svn::Error::EntryNotFound,
      #       #Svn::Error::RaIllegalUrl,
      #       #Svn::Error::WC_NOT_DIRECTORY
      #       #Svn::Error::WcNotDirectory => e
      rescue Exception => e
        raise RepoAccessError, "cant get info: #{e.message}"
      end
      r_info
     
    end
1276289
private static void printVersion() {
        System.out.println("JNRPE version " + VERSION);
        System.out.println("Copyright (c) 2011 Massimiliano Ziccardi");
        System.out.println("Licensed under the Apache License, Version 2.0");
        System.out.println();
    }
807587
def update_version_records(self):
        
        from .__init__ import __version__ as version
        with self.connection(commit=True) as connection:
            for vrec in self.get_version_records():
                if (vrec.rash_version == version and
                    vrec.schema_version == schema_version):
                    return  # no need to insert the new one!
            connection.execute(
                'INSERT INTO rash_info (rash_version, schema_version) '
                'VALUES (?, ?)',
                [version, schema_version])
650814
function bump(type) {
    if (type === void 0) { type = 'patch'; }
    var _pkg = pkg();
    if (!_pkg || !_pkg.version)
        logger_1.log.error('failed to load package.json, are you sure this is a valid project?');
    var origVer = _pkg.version;
    var newVer = semver_1.inc(origVer, type);
    if (newVer === null)
        logger_1.log.error('Whoops tried to bump version but got null.');
    _pkg.version = newVer;
    pkg(_pkg);
    return { name: _pkg.name, version: _pkg.version, previous: origVer, current: _pkg.version };
}
1254400
def print_version(options)
      log.log "#{HamlLint::APP_NAME} #{HamlLint::VERSION}"

      if options[:verbose_version]
        log.log "haml #{Gem.loaded_specs['haml'].version}"
        log.log "rubocop #{Gem.loaded_specs['rubocop'].version}"
        log.log RUBY_DESCRIPTION
      end
    end
91725
public function printApplicationDetails()
    {
        $this->output->writeln($this->console->getName());

        if (!is_null($this->console->getVersion())) {
            $this->output->writeln('version '.$this->console->getVersion());
        }

        // New line padding
        $this->output->writeln('');
    }
938636
def com_google_fonts_check_version_bump(ttFont,
                                        api_gfonts_ttFont,
                                        github_gfonts_ttFont):
  """"""
  v_number = ttFont["head"].fontRevision
  api_gfonts_v_number = api_gfonts_ttFont["head"].fontRevision
  github_gfonts_v_number = github_gfonts_ttFont["head"].fontRevision
  failed = False

  if v_number == api_gfonts_v_number:
    failed = True
    yield FAIL, ("Version number {} is equal to"
                 " version on Google Fonts.").format(v_number)

  if v_number < api_gfonts_v_number:
    failed = True
    yield FAIL, ("Version number {} is less than"
                 " version on Google Fonts ({})."
                 "").format(v_number,
                            api_gfonts_v_number)

  if v_number == github_gfonts_v_number:
    failed = True
    yield FAIL, ("Version number {} is equal to"
                 " version on Google Fonts GitHub repo."
                 "").format(v_number)

  if v_number < github_gfonts_v_number:
    failed = True
    yield FAIL, ("Version number {} is less than"
                 " version on Google Fonts GitHub repo ({})."
                 "").format(v_number,
                            github_gfonts_v_number)

  if not failed:
    yield PASS, ("Version number {} is greater than"
                 " version on Google Fonts GitHub ({})"
                 " and production servers ({})."
                 "").format(v_number,
                            github_gfonts_v_number,
                            api_gfonts_v_number)
1233706
def print_version_of_tools():
    
    logger.info("Using these tools:")
    for tool in get_version_of_tools():
        logger.info("%s-%s at %s", tool["name"], tool["version"], tool["path"])