Create a new retrospective with a name.

@param name    The name of the retrospective.
@param project The project this retrospective belongs to.
@return A newly minted Retrospective that exists in the VersionOne
system.
163895
public Retrospective retrospective(String name, Project project) {
        return retrospective(name, project, null);
    }
1006646
static Project convert(
            String name, com.linecorp.centraldogma.server.storage.project.Project project) {
        return new Project(name);
    }
1040230
public synchronized Project purgeProject(final Project project, final User deleter)
      throws ProjectManagerException {
    this.projectLoader.cleanOlderProjectVersion(project.getId(),
        project.getVersion() + 1, Collections.emptyList());
    this.projectLoader
        .postEvent(project, EventType.PURGE, deleter.getUserId(), String
            .format("Purged versions before %d", project.getVersion() + 1));
    return project;
  }
1280716
public Project projectByName(String name) throws SDKException {
        IAssetType projectAssetType = instance.getMetaModel().getAssetType(
                "Scope");
        IAttributeDefinition nameDef = projectAssetType
                .getAttributeDefinition("Name");
        Query query = new Query(projectAssetType);
        FilterTerm nameTerm = new FilterTerm(nameDef);

        nameTerm.equal(name);
        query.setFilter(nameTerm);
        query.getOrderBy().majorSort(nameDef, OrderBy.Order.Ascending);

        QueryResult result;
        try {
            result = instance.getServices().retrieve(query);
        } catch (V1Exception e) {
            throw new SDKException(e);
        }

        if (result.getAssets().length == 0) {
            return null;
        }
        Asset asset = result.getAssets()[0];
        return new Project(new AssetID(asset.getOid().getToken()), instance);
    }
467800
@SuppressWarnings("static-method")
	protected Job createJobForMavenProject(IProject project) {
		return new Job(Messages.EnableSarlMavenNatureAction_0) {

			@Override
			protected IStatus run(IProgressMonitor monitor) {
				final SubMonitor mon = SubMonitor.convert(monitor, 3);
				try {
					// The project should be a Maven project.
					final IPath descriptionFilename = project.getFile(new Path(IProjectDescription.DESCRIPTION_FILE_NAME)).getLocation();
					final File projectDescriptionFile = descriptionFilename.toFile();
					final IPath classpathFilename = project.getFile(new Path(FILENAME_CLASSPATH)).getLocation();
					final File classpathFile = classpathFilename.toFile();
					// Project was open by the super class. Close it because Maven fails when a project already exists.
					project.close(mon.newChild(1));
					// Delete the Eclipse project and classpath definitions because Maven fails when a project already exists.
					project.delete(false, true, mon.newChild(1));
					if (projectDescriptionFile.exists()) {
						projectDescriptionFile.delete();
					}
					if (classpathFile.exists()) {
						classpathFile.delete();
					}
					// Import
					MavenImportUtils.importMavenProject(
							project.getWorkspace().getRoot(),
							project.getName(),
							true,
							mon.newChild(1));
				} catch (CoreException exception) {
					SARLMavenEclipsePlugin.getDefault().log(exception);
				}
				return Status.OK_STATUS;
			}
		};
	}
1159078
def create_new_project(project_name)
      # Check project existence
      (error(_('wizard.project.name_exist')); return false) if project_exists?(Dir.pwd, project_name)
      # Setup the bebox boxes directory
      bebox_boxes_setup
      # Asks to choose an existing box
      current_box = choose_box(get_existing_boxes)
      vagrant_box_base = "#{BEBOX_BOXES_PATH}/#{get_valid_box_uri(current_box)}"
      # Asks user to choose vagrant box provider
      vagrant_box_provider = choose_option(%w{virtualbox vmware}, _('wizard.project.choose_box_provider'))
      # Set default environments
      default_environments = %w{vagrant staging production}
      # Project creation
      project = Bebox::Project.new(project_name, vagrant_box_base, Dir.pwd, vagrant_box_provider, default_environments)
      output = project.create
      ok _('wizard.project.creation_success')%{project_name: project_name}
      return output
    end
1156221
@CheckForNull
    public static GitHubRepositoryName create(GithubProjectProperty projectProperty) {
        if (projectProperty == null) {
            return null;
        }

        return GitHubRepositoryName.create(projectProperty.getProjectUrlStr());
    }
333476
public Project.Calendars.Calendar.Exceptions.Exception.TimePeriod createProjectCalendarsCalendarExceptionsExceptionTimePeriod()
   {
      return new Project.Calendars.Calendar.Exceptions.Exception.TimePeriod();
   }
1172327
public CollectionRequest<ProjectStatus> findByProject(String project) {

        String path = String.format("/projects/%s/project_statuses", project);
        return new CollectionRequest<ProjectStatus>(this, ProjectStatus.class, path, "GET");
    }
103986
@Post("/metadata/{projectName}/members")
    public CompletableFuture<Revision> addMember(@Param("projectName") String projectName,
                                                 IdentifierWithRole request,
                                                 Author author) {
        final ProjectRole role = toProjectRole(request.role());
        final User member = new User(loginNameNormalizer.apply(request.id()));
        return mds.addMember(author, projectName, member, role);
    }
1223602
public boolean projectExists(String name) throws IllegalArgumentException {
        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("Project name cannot be empty");
        }
        return listProjects().stream()
            .map(p -> p.getMetadata().getName())
            .anyMatch(Predicate.isEqual(name));
    }
1046606
def create_version(self, project_id_or_key, version_name, extra_request_params={}):
        
        request_params = extra_request_params
        request_params["name"] = version_name
        return self.do("POST", "projects/{project_id_or_key}/versions",
                       url_params={"project_id_or_key": project_id_or_key},
                       request_params=request_params,
                       )
77945
public static void configureNodeContextThreadLocalsForProject(final Project project) {
        final InheritableThreadLocal<String> localNodeName = new InheritableThreadLocal<>();
        final InheritableThreadLocal<String> localUserName = new InheritableThreadLocal<>();
        if (null == project.getReference(NODE_NAME_LOCAL_REF_ID)) {
            project.addReference(NODE_NAME_LOCAL_REF_ID, localNodeName);
        }
        if (null == project.getReference(NODE_USER_LOCAL_REF_ID)) {
            project.addReference(NODE_USER_LOCAL_REF_ID, localUserName);
        }
    }
1326487
public CompletableFuture<Revision> addRepo(Author author, String projectName, String repoName) {
        return addRepo(author, projectName, repoName, PerRolePermissions.DEFAULT);
    }
1373979
public Request request(String name, Project project) {
        return request(name, project, null);
    }
209140
private String getProjectName() {
    String pName = Strings.emptyToNull(projectName);
    if (pName == null) { 
      pName = Strings.emptyToNull(junit4.getProject().getName());
    }
    if (pName == null) {
      pName = "(unnamed project)";      
    }
    return pName;
  }
113067
def add(self, name, path=None, **kwargs):
        
        path = path or kwargs.pop('default_path', None)

        if not self._path_is_valid(path):
            return

        if not self._is_unique(name, path):
            p = Project.select().where(
                (Project.name == name) |
                (Project.path == path)
            )[0]
            self._print(self._ERROR_PROJECT_EXISTS.format(name, p.path), 'red')
            return

        Project.create(name=name, path=path)
        self._print(self._SUCCESS_PROJECT_ADDED.format(name), 'green')