Gets the list of all branches, for all projects, which are properly configured for SVN.
7981
protected Stream<Branch> getSVNConfiguredBranches() {
        return structureService.getProjectList()
                .stream()
                // ...which have a SVN configuration
                .filter(project -> propertyService.hasProperty(project, SVNProjectConfigurationPropertyType.class))
                // ...gets all their branches
                .flatMap(project -> structureService.getBranchesForProject(project.getId()).stream())
                // ...which have a SVN configuration
                .filter(branch -> propertyService.hasProperty(branch, SVNBranchConfigurationPropertyType.class));
    }
826663
def get_projects_list(self):
        
        try:
            result = self._request('/getprojectslist/')
            return [TildaProject(**p) for p in result]
        except NetworkError:
            return []
1350807
def find_branches(self):
        
        listing = self.context.capture('hg', 'branches')
        for line in listing.splitlines():
            tokens = line.split()
            if len(tokens) >= 2 and ':' in tokens[1]:
                revision_number, revision_id = tokens[1].split(':')
                yield Revision(
                    branch=tokens[0],
                    repository=self,
                    revision_id=revision_id,
                    revision_number=int(revision_number),
                )
186468
public LinkedList<Project> getProjects() {
	    if(projects != null) return projects;
	    try
	    {
	        projects = new LinkedList<Project>(getService().getAllProjects());
	        projectName = projectName == null ?  projects.iterator().next().getName() : projectName;
	        
	        return projects;
	    }
	    catch (GreenPepperServerException e)
	    {
	        addActionError(e.getId());
	    }
	    
	    return projects;
	}
1278494
def branches(self):
        
        # We need to read the _cte_node_children attribute, so ensure it exists.
        self._ensure_parameters()
        return self.filter(
            **{"%s__id__in" % self.model._cte_node_children: self.all()}
        ).distinct()
253718
def get_branches(aliases):
    """"""

    ignore = ['pow', 'log10', 'sqrt', 'max']
    branches = []
    for k, v in aliases.items():

        tokens = re.sub('[\(\)\+\*\/\,\=\<\>\&\!\-\|]', ' ', v).split()

        for t in tokens:

            if bool(re.search(r'^\d', t)) or len(t) <= 3:
                continue

            if bool(re.search(r'[a-zA-Z]', t)) and t not in ignore:
                branches += [t]

    return list(set(branches))
1134565
def index_branches(self, branches=None, start=0):
        
        ln = self.online_branches if branches is None else branches
        for i, l in enumerate(ln):
            l._i = start + i
100157
public List<GitlabCommit> getAllCommits(Serializable projectId) throws IOException {
        return getAllCommits(projectId, null, null);
    }
1351700
def release_branches(self):
        """"""
        self.ensure_release_scheme('branches')
        return dict((r.revision.branch, r) for r in self.releases.values())
140022
def branches(self):
        """"""
        result = self.git(self.default + ['branch', '-a', '--no-color'])
        return [l.strip(' *\n') for l in result.split('\n') if l.strip(' *\n')]
1196700
def all_branch_orders(h):
    
    #Iterate over all sections, find roots
    roots = []
    for section in h.allsec():
        sref = h.SectionRef(sec=section)
        # has_parent returns a float... cast to bool
        if sref.has_parent() < 0.9:
            roots.append(section)

    # Build list of all sections
    order_list = []
    for r in roots:
        add_pre(h,[],r,order_list,0)
    return order_list
1334622
public List<Long> getAllVersions() throws IOException {
        List<Long> ret = new ArrayList<>();
        for (String s : listDir(_root)) {
            if (s.endsWith(FINISHED_VERSION_SUFFIX)) {
                ret.add(validateAndGetVersion(s));
            }
        }
        Collections.sort(ret);
        Collections.reverse(ret);
        return ret;
    }
1069242
public List<GitlabProject> getProjects() {
        String tailUrl = GitlabProject.URL + PARAM_MAX_ITEMS_PER_PAGE;
        return retrieve().getAll(tailUrl, GitlabProject[].class);
    }
316055
public function branches()
    {
        $result = $this->execute('list', array('--xml' => true, $this->getUrl() . '/' . $this->basePaths['branches']));

        $logTrunk = $this->log('/', null, 1);
        $logTrunk = reset($logTrunk);

        $branches = array();
        $branches[] = new Reference('trunk', Reference::BRANCH, $logTrunk->getRevision());

        foreach ($result as $fileinfo) {
            $branches[] = new Reference($fileinfo->getFilename(), Reference::BRANCH, $fileinfo->getCommit()->getRevision());
        }

        return $branches;
    }
794291
public List<AbstractProject> getTiedJobs() {
        Node node = getNode();
        return (node != null) ? node.getSelfLabel().getTiedJobs() : Collections.EMPTY_LIST;
    }
136727
@Override
    public synchronized List<ExtPluginConfiguration> listNodeEnhancerConfigurations() {
        return listPluginConfigurations(
                projectConfig.getProjectProperties(),
                NODE_ENHANCER_PROP_PREFIX,
                ServiceNameConstants.NodeEnhancer
        );
    }
983113
def repo_tools(self, branch):
        
        tools = []
        m_helper = Tools()
        repo = self.parentApp.repo_value['repo']
        version = self.parentApp.repo_value['versions'][branch]
        status = m_helper.repo_tools(repo, branch, version)
        if status[0]:
            r_tools = status[1]
            for tool in r_tools:
                tools.append(tool[0])
        return tools