Java ChangeLogSet.Entry方法代码示例

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
/**
 * Parse a Jira ticket number, ie SSD-101, out of the given ChangeLogSet.Entry.
 *
 * Ticket number is assumed to be the first word of the commit message
 *
 * @param change - the change entry to
 * @return
 */
@Override
public List<JiraCommit> getJiraIssuesFromChangeSet(final ChangeLogSet.Entry change)
{
    String msg = change.getMsg();
    String firstWordOfTicket;
    firstWordOfTicket = msg.substring(0, (msg.contains(" ") ? StringUtils.indexOf(msg, " ") : msg.length()));

    for (String validJiraPrefix : Config.getGlobalConfig().getJiraTickets())
    {
        if (firstWordOfTicket.endsWith(":"))
        {
            firstWordOfTicket = firstWordOfTicket.substring(0, firstWordOfTicket.length() - 1);
        }
        if (firstWordOfTicket.startsWith(validJiraPrefix))
        {
            return Arrays.asList(new JiraCommit(firstWordOfTicket, change));
        }
    }

    return null;
}
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
@Test
public void testSimpleCase()
        throws Exception
{
    List<ChangeLogSet.Entry> validChanges = Arrays.asList(
            MockChangeLogUtil.mockChangeLogSetEntry("Hello World [FOO-101]"),
            MockChangeLogUtil.mockChangeLogSetEntry("FOO-101 ticket at start"),
            MockChangeLogUtil.mockChangeLogSetEntry("In the middle FOO-101 of the message"),
            MockChangeLogUtil.mockChangeLogSetEntry("Weird characters FOO-101: next to it"));
    for (ChangeLogSet.Entry change : validChanges)
    {
        assertThat(strategy.getJiraIssuesFromChangeSet(change).size(), equalTo(1));
        assertThat(strategy.getJiraIssuesFromChangeSet(change).get(0).getJiraTicket(), equalTo("FOO-101"));
    }

}
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
private void setContent() {
  if (build.getChangeSet().getItems().length == 0) {
    message.setContent(this.getResultString());
  } else {
    StringBuilder changes = new StringBuilder();

    for (Iterator<? extends ChangeLogSet.Entry> i = build.getChangeSet().iterator(); i.hasNext(); ) {
      ChangeLogSet.Entry change = i.next();
      changes.append("\n");
      changes.append(change.getMsg());
      changes.append(" - ");
      changes.append(change.getAuthor());
    }

    message.setContent(String.format("%s%n%s", this.getResultString(), changes.toString()));
  }
}
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
public static List<Change> getChanges(AbstractBuild<?, ?> build) {
    RepositoryBrowser repositoryBrowser = build.getProject().getScm().getBrowser();
    List<Change> result = new ArrayList<>();
    for (ChangeLogSet.Entry entry : build.getChangeSet()) {
        UserInfo user = UserInfo.getUser(entry.getAuthor());
        String changeLink = null;
        if (repositoryBrowser != null) {
            try {
                @SuppressWarnings("unchecked")
                URL link = repositoryBrowser.getChangeSetLink(entry);
                if (link != null) {
                    changeLink = link.toExternalForm();
                }
            } catch (IOException e) {
                LOG.log(Level.WARNING, "Could not get changeset link for: "
                        + build.getProject().getFullDisplayName() + " " + build.getDisplayName(), e);
            }
        }
        result.add(new Change(user, entry.getMsgAnnotated(), entry.getCommitId(), changeLink));
    }
    return result;
}
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
public Iterable<VcsModification> getChanges() {

    	List<VcsModification> supportedChanges = new LinkedList<VcsModification>();
        ChangeLogSet<ChangeLogSet.Entry> changeSet = build.getChangeSet();

        for(ChangeLogSet.Entry entry : changeSet) {
            if(VcsModificationWrapperFactory.getInstance().isSupported(entry)) {
            	logger.println("VersionOne: Using " + entry.getClass() + " which is supported");            	
                VcsModification wrapper = VcsModificationWrapperFactory.getInstance().createWrapper(entry);
                supportedChanges.add(wrapper);
            }
            else
            	logger.println("VersionOne: Tried to use " + entry.getClass() + " which is NOT supported");
        }

        return supportedChanges;
    }
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
public VcsModification createWrapper(ChangeLogSet.Entry modification) {
    Class modificationType = modification.getClass();

    if(mappings.containsKey(modificationType)) {
        Class wrapperType = mappings.get(modificationType);

        try {
            Constructor constructor = wrapperType.getConstructor(modificationType);
            return (VcsModification) constructor.newInstance(modification);
        } catch(Exception ex) {
            throw new UnsupportedOperationException("Provided changeset type is not supported: " + modificationType);
        }
    }

    throw new UnsupportedOperationException("Provided changeset type is not supported: " + modificationType);
}
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
private String generatedMessage(AbstractBuild<?, ?> build) {
    
    final StringBuilder userBuilder = new StringBuilder();
    for(User user: build.getCulprits()) {
        userBuilder.append(user.getFullName() + " ");
    }
    
    final StringBuilder changeSetBuilder = new StringBuilder();
    for(ChangeLogSet.Entry entry: build.getChangeSet()) {
        changeSetBuilder.append(entry.getAuthor() + " : " + entry.getMsg() + "\n");
    }
    
    String replacedMessage = message.replace("${user}", userBuilder.toString());
    replacedMessage = replacedMessage.replace("${result}", build.getResult().toString());
    replacedMessage = replacedMessage.replace("${project}", build.getProject().getName());
    replacedMessage = replacedMessage.replace("${number}", String.valueOf(build.number));
    replacedMessage = replacedMessage.replace("${url}", JenkinsLocationConfiguration.get().getUrl() + build.getUrl());
    replacedMessage = replacedMessage.replace("${changeSet}", changeSetBuilder.toString());

    return replacedMessage;
}
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
/**
 * Function to return a link to the changeset
 */
@Override
public URL getChangeSetLink(ChangeLogSet.Entry changeSet) throws IOException
{
    //Determines the link to the give changeset
    return null;
}
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
public void getChangeLog(Run<?, ?> run) {
	this.affectedPaths = new StringBuilder();

	this.messages = new StringBuilder();

	this.culprits = new StringBuilder();

	AbstractBuild<?,?> abstractBuild = (AbstractBuild<?,?>) run;
	ChangeLogSet<? extends ChangeLogSet.Entry> changeset = abstractBuild.getChangeSet();
	Iterator<? extends ChangeLogSet.Entry> itrChangeSet = changeset.iterator();
	while (itrChangeSet.hasNext()) {
		ChangeLogSet.Entry str = itrChangeSet.next();
		Collection<? extends ChangeLogSet.AffectedFile> affectedFiles = str.getAffectedFiles();
		Iterator<? extends ChangeLogSet.AffectedFile> affectedFilesItr = affectedFiles.iterator();
		while (affectedFilesItr.hasNext()) {
			this.affectedPaths.append(affectedFilesItr.next().getPath());
			this.affectedPaths.append(", ");
		}
		this.messages.append(str.getMsg());
		this.messages.append(", ");
		
		this.culprits.append(str.getAuthor().getFullName());
		this.culprits.append(", ");
		
		this.commitCount += 1;
	}
       
}
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
@Override
public void perform(List<JiraCommit> jiraCommitList,
                    AbstractBuild build, Launcher launcher, BuildListener listener)
{

    for (JiraCommit jiraCommit : filterJiraCommitList(jiraCommitList))
    {
        try
        {
            listener.getLogger().println("Updating ticket: " + jiraCommit.getJiraTicket());
            String comment;
            if (jiraCommit.getChangeSet().isPresent())
            {
                ChangeLogSet.Entry entry = jiraCommit.getChangeSet().get();
                listener.getLogger().println("\tchange.msg()\t" + entry.getMsgAnnotated());
                listener.getLogger().println("\tchange.getCommitId()\t" + entry.getCommitId());
                listener.getLogger().println("\tchange.getAuthor()\t" + entry.getAuthor());
            }
            getJiraClientSvc().addCommentToTicket(jiraCommit.getJiraTicket(),
                    buildComment(jiraCommit.getChangeSet(), build.getEnvironment(listener)));
        }
        catch (Throwable t)
        {
            listener.getLogger().println("ERROR Updating jira notifications");
            t.printStackTrace(listener.getLogger());
        }
    }
}
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
private String buildComment(Optional<ChangeLogSet.Entry> change,
                            EnvVars environment)
{
    String finalComment = commentText;
    finalComment = environment.expand(finalComment);

    if (!change.isPresent())
    {
        return finalComment;
    }

    String message = "";
    ChangeLogSet.Entry entry = change.get();
    if (entry instanceof GitChangeSet)
    {
        message = ((GitChangeSet) entry).getComment();
    }
    else
    {
        message = entry.getMsg();
    }

    finalComment = StringUtils.replace(finalComment, "$AUTHOR", (entry.getAuthor() == null ? "null" : entry.getAuthor().getDisplayName()));
    finalComment = StringUtils.replace(finalComment, "$COMMIT_ID", entry.getCommitId());
    finalComment = StringUtils.replace(finalComment, "$COMMIT_DATE",
            DATE_FORMAT.format(new Date(entry.getTimestamp())));
    finalComment = StringUtils.replace(finalComment, "$COMMIT_MESSAGE", message);
    return finalComment;
}
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
public JiraCommit(String jiraTicket, ChangeLogSet.Entry changeSet)
{
    this.jiraTicket = jiraTicket;
    if (changeSet == null)
    {
        this.changeSet = Optional.absent();
    }
    else
    {
        this.changeSet = Optional.of(changeSet);
    }
}
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
@Test
public void testNotFound()
        throws Exception
{
    ChangeLogSet.Entry entry = MockChangeLogUtil.mockChangeLogSetEntry("SSD-101 test");
    assertThat(strategy.getJiraIssuesFromChangeSet(entry).size(), equalTo(0));
}
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
@Test
public void testMultipleTicketNames()
{
    ChangeLogSet.Entry entry = MockChangeLogUtil.mockChangeLogSetEntry("FOO-101 and\n BAR-101 are both in the message");
    assertThat(strategy.getJiraIssuesFromChangeSet(entry).size(), equalTo(2));
    assertThat(strategy.getJiraIssuesFromChangeSet(entry),
            hasItem(Matchers.<JiraCommit>hasProperty("jiraTicket", equalTo("FOO-101"))));
    assertThat(strategy.getJiraIssuesFromChangeSet(entry),
            hasItem(Matchers.<JiraCommit>hasProperty("jiraTicket", equalTo("BAR-101"))));
}
 

import hudson.scm.ChangeLogSet; //导入方法依赖的package包/类
@Test
public void testTicketRepeatsItself()
{
    ChangeLogSet.Entry entry = MockChangeLogUtil.mockChangeLogSetEntry("FOO-101 is in the message twice FOO-101");
    assertThat(strategy.getJiraIssuesFromChangeSet(entry).size(), equalTo(1));
    assertThat(strategy.getJiraIssuesFromChangeSet(entry),
            hasItem(Matchers.<JiraCommit>hasProperty("jiraTicket", equalTo("FOO-101"))));
}