See Api#search_for
13829
def search_for( spec )
     found = []
      specs_list.each do |name, version, platform|
        up_spec = Stickler::SpecLite.new( name, version, platform )
        found << up_spec if spec =~ up_spec
      end
      return found
    end
208109
def search(cls, query, search_opts=None):
        

        if search_opts is None:
            search_opts = {}

        xmlrpc = XMLRPCConnection()
        try:
            search_result = xmlrpc.connection.search_vrf(
                {
                    'query': query,
                    'search_options': search_opts,
                    'auth': AuthOptions().options
                })
        except xmlrpclib.Fault as xml_fault:
            raise _fault_to_exception(xml_fault)
        result = dict()
        result['result'] = []
        result['search_options'] = search_result['search_options']
        for v in search_result['result']:
            result['result'].append(VRF.from_dict(v))

        return result
166735
def find(term, limit = nil, offset = nil, page = nil)
      raise ArgumentError.new("Missing search term") unless term

      search = OAuth::Helper.escape(term)
      search += "?limit_to_public_domain=#{NounProjectApi.configuration.public_domain ? 1 : 0}"

      args = {
        "limit" => limit,
        "offset" => offset,
        "page" => page
      }.reject { |_, v| v.nil? }
      args.each { |k, v| search += "&#{k}=#{v}" } if args.size > 0

      result = access_token.get("#{API_BASE}#{API_PATH}#{search}")
      raise ServiceError.new(result.code, result.body) unless %w(200 404).include? result.code

      if result.code == "200"
        JSON.parse(result.body)["icons"].map { |icon| Icon.new(icon) }
      else
        []
      end
    end
1271291
def search(self, filterstr, attrlist):
        """"""
        return self._paged_search_ext_s(self.settings.BASE, ldap.SCOPE_SUBTREE, filterstr=filterstr,
                                        attrlist=attrlist, page_size=self.settings.PAGE_SIZE)
309517
def do_search(generic_opts={}, explicit_body=nil)
      query_opts = {}
      body = nil
      if explicit_body
        query_opts = generic_opts
        body = explicit_body
      else
        body = generic_opts
      end

      response = request(:get, "_search", query_opts, nil, {}, :mashify => false) do |req|
        req.body = body
      end
      SearchResults.new(response)
    end
420512
def search(self, q):
        
        results = self._api.search(q=q)

        return results
1145020
def search( ypath_str )
            matches = match_path( ypath_str )

            if matches
                matches.collect { |m|
                    path = []
                    m.each_index { |i|
                        path.push m[i] if ( i % 2 ).zero?
                    }
                    "/" + path.compact.join( "/" )
                }
            end
        end
323788
def add_query(self, key_val={}):
        

        q = Q("match", **key_val)
        self.search = self.search.query(q)
        return self
1201629
def search query
      rake_yard(store)
      found = []
      code_object_paths.each do |k|
        if found.empty? || (query.include?('.') || query.include?('#')) || !(k.include?('.') || k.include?('#'))
          found.push k if k.downcase.include?(query.downcase)
        end
      end
      found
    end
650821
def check_searching_param(searching_param, allowed)
      🔞 = searching_param.keys.map(&:to_sym) - allowed.map(&:to_sym)
      raise InvalidSearchException, "Attributes #{🔞.map(&:to_s).to_sentence} doesn't exists or aren't searchables. Available searchs are: #{allowed.to_sentence}" if 🔞.any?
    end
1091094
def search name, opts = {} 
      filter name, { exact: false, ignore_case: true, strip_blank: true }.merge(opts)
    end
131387
def all(self, query, **kwargs):
        
        self.url = 'https://slack.com/api/search.all'
        return super(Search, self).search_from_url(query, **kwargs)
36663
def search(search_params)
      url = Base + 'search'
      url += add_querystring(search_params)
      response = @fs_communicator.get(url)
      familytree = Org::Familysearch::Ws::Familytree::V2::Schema::FamilyTree.from_json JSON.parse(response.body)
      # require 'pp'
      # pp familytree
      familytree.searches[0]
    end
395731
def search(self, *args, **kwargs):
        
        return self._query_zendesk(self.endpoint.search, 'request', *args, **kwargs)
1248488
def search(self, query, relation=None, index=0, limit=25, **kwargs):
        
        return self.get_object(
            "search", relation=relation, q=query, index=index, limit=limit, **kwargs
        )
1301066
def search(self, term):
        
        r = requests.get(self.apiurl + "/users", params={"filter[name]": term}, headers=self.header)

        if r.status_code != 200:
            raise ServerError

        jsd = r.json()

        if jsd['meta']['count']:
            return SearchWrapper(jsd['data'], jsd['links']['next'] if 'next' in jsd['links'] else None, self.header)
        else:
            return None
729924
def search(*args)
      url = search_url(*args)
      results = JSON.load(Net::HTTP.get_response(url).body)
      p ['results for: ', url.to_s, results] if self.debug
      Punchfork::Search.new(results)
    rescue Exception => e
      p url
      p results
      p e
      raise e
    end