Lists all integrations, or integrations with names containing the given
 search term.

 @param search [String, nil] an optional search term
501135
def list(search)
      @config.transaction do
        integrations = @config.integrations.dup
        unless search.nil?
          integrations.select! do |intg|
            intg.name.downcase.include? search.downcase
          end
        end
        puts 'No integrations found' if integrations.empty?
        integrations.each { |intg| show_integration intg }
      end
    end
1268760
def list_(ctx, search, backend):
    
    projects = ctx.obj['projects_db'].search(search, backend=backend)
    projects = sorted(projects, key=lambda project: project.name.lower())
    ctx.obj['view'].search_results(projects)
1288499
def search(term, category=Categories.ALL, pages=1, sort=None, order=None):
	""""""
	s = Search()
	s.search(term=term, category=category, pages=pages, sort=sort, order=order)
	return s
1032638
def search(options, &block)
      if options[:base].kind_of?(Hash)
        options = options.merge(:base => dn/options[:base])
      end
      namespace.search({:base => dn}.merge(options), &block)
    end
1099669
def names(filter = nil)
      inject([]) do |mem, spec|
        case filter
        when :visible
          mem << spec.name if spec.visible?
        end
        mem
      end.sort
    end
1281573
def search_normalize(self, results):
        
        for interface in results:
            interface[u'host_id'] = self.host.id  # pylint:disable=no-member
        return super(Interface, self).search_normalize(results)
1224743
public SearchResponse searchAll(String[] indices, String[] types) {
        return searchAll(indices, types, null, null);
    }
849484
def search(self):
        """"""

        matches = []
        for index, cell in enumerate(self.cells):
            for pattern in Config.patterns:
                if ismatch(cell, pattern):
                    matches.append(index)
                    break

        return matches
400050
def search(cache, search_data)
      puts '' # Force first entry to be displayed in mutt
      # Write out as EMAIL <TAB> NAME
      cache.search(search_data).each { |k, v| puts "#{k}\t#{v}" }
    end
548098
def do_list(lookup, term):
    """"""

    space = lookup.keys()
    matches = fnmatch.filter(space, term)

    return [(m, translate(lookup, m)) for m in matches]
545632
def get_params_to_search(context)
      if params[:saved_search].present?
        @saved_search = SavedSearch.find_by(id: params[:saved_search], context: context)
      end
      return params[:q] if params[:use_search_params].present?
      params[:q] = @saved_search.try(:search_params) || params[:q]
    end
943126
def sort(self, search):
        
        if self._sort:
            search = search.sort(*self._sort)
        return search
940280
def search(query, options={})
      params = { :query => query, :lang => @query_options[:lang], :limit => @query_options[:limit] }.merge(options)
      response = get(surl('search'), params, format: :json)
      response['result']
    end
179801
function addonsManager_getSearchResults() {
    var filterValue = this.getSearchFilterValue({
      filter: this.selectedSearchFilter
    });

    switch (filterValue) {
      case "local":
        return this.getAddons({attribute: "status", value: "installed"});
      case "remote":
        return this.getAddons({attribute: "remote", value: "true"});
      default:
        throw new Error(arguments.callee.name + ": Unknown search filter '" +
                        filterValue + "' selected");
    }
  }
369814
def show(ctx, search):
    
    matches = {'aliases': [], 'mappings': [], 'projects': []}
    projects_db = ctx.obj['projects_db']

    matches = get_alias_matches(search, matches)
    matches = get_mapping_matches(search, matches, projects_db)
    matches = get_project_matches(search, matches, projects_db)

    ctx.obj['view'].show_command_results(search, matches, projects_db)
533248
def _search(self, searchterm, pred, **args):
        
        # TODO: DRY with sparql_ontol_utils
        searchterm = searchterm.replace('%','.*')
        namedGraph = get_named_graph(self.handle)
        query = """
        prefix oboInOwl: <http://www.geneontology.org/formats/oboInOwl#>
        SELECT ?c WHERE {{
        GRAPH <{g}>  {{
        ?c {pred} ?l
        FILTER regex(?l,'{s}','i')
        }}
        }}
        """.format(pred=pred, s=searchterm, g=namedGraph)
        bindings = run_sparql(query)
        return [r['c']['value'] for r in bindings]
1329743
def search(cls, name, lookup=[]):
        
        if os.path.isfile(name): return name
        for spath in lookup:
            fname = os.path.join(spath, name)
            if os.path.isfile(fname):
                return fname
            for ext in cls.extensions:
                if os.path.isfile('%s.%s' % (fname, ext)):
                    return '%s.%s' % (fname, ext)