private static async Task CodeAllFieldExample(GitHubClient client)
{
int fromNumber = 100;
int toNumber = 1000;
string extension = ".cs";
string fileName = "IssueCommentPayload";
string organization = "octokit";
string path = "Octokit/Models/Response/ActivityPayloads";
string repository = "octokit/octokit.net";
string term = "issue";
string user = "******";
var request = new SearchCodeRequest(term)
{
Extension = extension,
FileName = fileName,
Forks = false,
In = new CodeInQualifier[] { CodeInQualifier.Path },
Language = Language.CSharp,
Order = SortDirection.Descending,
Organization = organization,
Path = path,
Repos = new RepositoryCollection {
repository
},
Size = new Range(fromNumber, toNumber),
SortField = CodeSearchSort.Indexed,
User = user
};
SearchCodeResult result = await client.Search.SearchCode(request);
Console.WriteLine($"Search.SearchCode (All Fields): TotalCount={result.TotalCount}");
}
public async Task<SearchCodeResult> Search(SearchCodeRequest searchRequest)
{
if (searchRequest == null)
{
throw new ArgumentNullException(nameof(searchRequest));
}
var totalCount = 0;
var repositoryFileNames = new List<string>();
foreach (var repo in searchRequest.Repos)
{
repositoryFileNames.AddRange(await _client.GetGitRepositoryFileNames(repo.Owner, repo.Name));
}
var searchStrings = searchRequest.Term
.Replace("\"", string.Empty)
.Split(new[] { "OR" }, StringSplitOptions.None);
foreach (var searchString in searchStrings)
{
totalCount += repositoryFileNames.FindAll(x => x.EndsWith(searchString.Trim(), StringComparison.InvariantCultureIgnoreCase)).Count;
}
return new SearchCodeResult(totalCount);
}
public static IGitHubClient CreateClient <T>(
SearchCodeRequest expectedRequest,
Dictionary <string, T> pathsToRecords,
long expectedRepositoryId,
string expectedRepositoryName,
string expectedOwner
)
{
var client = new Mock <IGitHubClient>();
client
.Setup(mockClient => mockClient.Repository)
.Returns(
CreateRepositoriesClient(
pathsToRecords,
expectedRepositoryId,
expectedOwner,
expectedRepositoryName
)
);
client
.Setup(mockClient => mockClient.Search)
.Returns(CreateSearchClient(expectedRequest, pathsToRecords.Keys.ToList()));
return(client.Object);
}
private SearchCodeRequest getSearchCodeRequest(Model.SearchCodeRequestParameters parameters)
{
SearchCodeRequest codeRequest;
try
{
codeRequest = new SearchCodeRequest(parameters.Term);
}
catch (Exception)
{
codeRequest = new SearchCodeRequest();
}
Language language = (Language)Enum.Parse(typeof(Language), parameters.Language);
codeRequest.Language = language;
codeRequest.Path = parameters.Path;
codeRequest.User = parameters.Owner;
codeRequest.FileName = parameters.FileName;
codeRequest.Extension = parameters.Extension;
codeRequest.Forks = getBoolParameter(parameters.ForksIncluded);
codeRequest.Size = pickRange(parameters.SizeChoice, parameters.Size);
codeRequest.In = getPathIncludedParameter(parameters.PathIncluded, parameters.Term);
return(codeRequest);
}
public static GitHubConfig Create <T>(
SearchCodeRequest expectedRequest,
Dictionary <string, T> pathsToRecords,
long expectedRepositoryId,
string repoName,
string repoOwner)
{
var config = new Mock <MockableGitHubConfig>();
config
.Setup(mockConfig => mockConfig.RepositoryName)
.Returns(repoName);
config
.Setup(mockConfig => mockConfig.RepositoryOwner)
.Returns(repoOwner);
config
.Setup(mockConfig => mockConfig.Client)
.Returns(
CreateClient(
expectedRequest,
pathsToRecords,
expectedRepositoryId,
repoName,
repoOwner
)
);
config
.Setup(mockConfig => mockConfig.Repository)
.Returns(CreateRepository(expectedRepositoryId));
return(config.Object);
}
async Task <IEnumerable <string> > ListContentsOctokit(string searchTerm, string repoOwner, string repoName, string url)
{
var client = new GitHubClient(new ProductHeaderValue("Cohee-Creative"));
EditorCoroutines.EditorCoroutine currentCoroutine = this.StartCoroutine(CheckTimeOut());
if (!string.IsNullOrEmpty(m_UserName))
{
var basicAuth = new Credentials(m_UserName, m_Password);
client.Credentials = basicAuth;
}
var request = new SearchCodeRequest(searchTerm, repoOwner, repoName)
{
// we can restrict search to the file, path or search both
In = new[] { CodeInQualifier.Path },
// how about we find a file based on a certain language
Language = Language.CSharp,
// we may want to restrict the file based on file extension
Extension = "cs",
};
var task = await client.Search.SearchCode(request);
this.StopCoroutine("CheckTimeOut");
return(task.Items.Select(content => content.HtmlUrl));
}
public async Task <bool> ContainsDotNetProjects(RepositorySettings repository)
{
const string dotNetCodeFiles = "\"packages.config\" OR \".csproj\" OR \".fsproj\" OR \".vbproj\"";
var repos = new List <SearchRepo>
{
new SearchRepo(repository.RepositoryOwner, repository.RepositoryName)
};
var searchCodeRequest = new SearchCodeRequest(dotNetCodeFiles, repos)
{
PerPage = 1
};
try
{
var result = await _collaborationFactory.CollaborationPlatform.Search(searchCodeRequest);
if (result.TotalCount <= 0)
{
_logger.Detailed(
$"Repository {repository.RepositoryOwner}/{repository.RepositoryName} contains no .NET code on the default branch, skipping.");
return(false);
}
return(true);
}
catch (Exception ex)
{
_logger.Error("Repository search failed.", ex);
}
return(true);
}
public async Task <bool> ContainsDotNetProjects(RepositorySettings repository)
{
var request = new SearchCodeRequest("\"packages.config\" OR \".csproj\" OR \".fsproj\" OR \".vbproj\"")
{
Repos = new RepositoryCollection {
{ repository.RepositoryOwner, repository.RepositoryName }
},
In = new [] { CodeInQualifier.Path },
PerPage = 1
};
try
{
var result = await _gitHubClient.Search(request);
if (result.TotalCount <= 0)
{
_logger.Detailed(
$"Repository {repository.RepositoryOwner}/{repository.RepositoryName} contains no .NET code on the default branch, skipping.");
return(false);
}
}
catch (Exception ex)
{
_logger.Error("GitHub Repository search failed.", ex);
}
return(true);
}
static async System.Threading.Tasks.Task Breachfinder(string user) //Also works for the original octokit experience
{
var client = new GitHubClient(new ProductHeaderValue("GHBreachFinder"));
var basicAuth = new Credentials("Christopgr", "////////"); // NOTE: not real credentials
client.Credentials = basicAuth;
var user1 = await client.User.Get(user);
Console.WriteLine(user1.Followers + " folks love Chris!");
Console.WriteLine("{0} has {1} public repositories - go check out their profile at {2}",
user1.Name,
user1.PublicRepos,
user1.Url);
var request = new SearchCodeRequest("password")
{
User = user
};
var result = await client.Search.SearchCode(request);
Console.WriteLine("{0} Breaches were found",
result.Items.Count);
for (int i = 0; i < result.Items.Count; i++)
{
Console.WriteLine("{0}",
result.Items[i].Path);
}
}
public async Task <IEnumerable <Article> > GetArticles()
{
string repo = "oakcool/oakideas.blogs";
string branch = "master";
List <Article> articles = new List <Article>();
var client = new GitHubClient(new ProductHeaderValue("oakideas-simplex"));
RepositoryCollection repos = new RepositoryCollection
{
repo
};
var request = new SearchCodeRequest()
{
Repos = repos,
// we may want to restrict the file based on file extension
Extensions = new[] { "info" }
};
var result = await client.Search.SearchCode(request);
HttpClient httpClient = new HttpClient();
foreach (var item in result.Items)
{
var data = await httpClient.GetStringAsync($"https://raw.githubusercontent.com/{repo}/{branch}/{item.Path}");
var article = JsonConvert.DeserializeObject <Article>(data);
article.URL = item.HtmlUrl;
articles.Add(article);
}
return(articles);
}
public void SortNotSpecifiedByDefault()
{
var request = new SearchCodeRequest("test");
Assert.True(String.IsNullOrWhiteSpace(request.Sort));
Assert.False(request.Parameters.ContainsKey("sort"));
}
private static async Task CodePagingExample(GitHubClient client)
{
const int MaximumSearchItems = 1000;
var request = new SearchCodeRequest
{
Language = Language.CSharp,
Repos = new RepositoryCollection {
"octokit/octokit.net"
}
};
int maximumPage = MaximumSearchItems / request.PerPage;
for (request.Page = 1; request.Page <= maximumPage; request.Page++)
{
SearchCodeResult result = await client.Search.SearchCode(request);
if (request.Page == 1)
{
Console.WriteLine($"Search.SearchCode (Paging): TotalCount={result.TotalCount}");
}
foreach (SearchCode code in result.Items)
{
Console.WriteLine($" {code.Path}");
}
if (result.IncompleteResults || result.Items.Count < request.PerPage)
{
break;
}
}
}
public async Task SearchForFunctionInCode()
{
var request = new SearchCodeRequest("addClass", "jquery", "jquery");
var repos = await _gitHubClient.Search.SearchCode(request);
Assert.NotEmpty(repos.Items);
}
public static ISearchClient CreateSearchClient(SearchCodeRequest expectedRequest, List <string> resultPaths)
{
var searchClient = new Mock <ISearchClient>();
searchClient
.Setup(client => client.SearchCode(It.IsAny <SearchCodeRequest>()))
.Returns(Task.FromResult(CreateSearchCodeResult(resultPaths)));
return(searchClient.Object);
}
public void ReturnsAReadOnlyDictionary()
{
var request = new SearchCodeRequest("test");
var result = request.MergedQualifiers();
// If I can cast this to a writeable collection, then that defeats the purpose of a read only.
AssertEx.IsReadOnlyCollection <string>(result);
}
public async Task ScanReposAsync(
ConcurrentDictionary <PackageReference, HashSet <RepoInfo> > graph,
IScanProgress scanProgress)
{
_solutions.Clear();
var scr = new SearchCodeRequest("PackageReference")
{
Organizations = new List <string> {
_organization
},
Extensions = new List <string> {
"csproj"
},
Repos = _repos,
};
var searchResult = await _client.Search.SearchCode(scr);
var totalProjectsCount = searchResult.TotalCount;
for (int i = 0; i < totalProjectsCount; i += 100)
{
var pageNumber = i / 100;
scr.Page = pageNumber;
searchResult = await _client.Search.SearchCode(scr);
Console.WriteLine($"Page {pageNumber} received {searchResult.Items.Count}");
foreach (var item in searchResult.Items)
{
try
{
bool wasAdded = _solutions.Add(item.Repository.Name);
if (wasAdded)
{
scanProgress.UpdateRepoProgress();
}
await IndexProjectAsync(item, graph, scanProgress);
// rate limit - 5000 per hour
await Task.Delay(500);
}
catch (Exception ex)
{
Console.WriteLine();
Console.WriteLine($"Error: {ex.Message}");
}
}
}
}
public async Task Handle(SearchGitHub message, IMessageHandlerContext context)
{
log.Info($"Received search request for \"{message.SearchFor}\" on {message.RepositoryOwner}/{message.Repository}...");
SearchCodeRequest request = new SearchCodeRequest(
message.SearchFor,
message.RepositoryOwner,
message.Repository);
SearchCodeResult result = await GitHubClient.Search.SearchCode(request);
log.Info($"Found {result.TotalCount} results for {message.SearchFor}.");
}
public async Task SearchForFileNameInCode()
{
var request = new SearchCodeRequest("GitHub")
{
FileName = "readme.md",
Repos = new RepositoryCollection {
"octokit/octokit.net"
}
};
var repos = await _gitHubClient.Search.SearchCode(request);
Assert.NotEmpty(repos.Items);
}
public async Task SearchForFileNameInCodeWithoutTerm()
{
var request = new SearchCodeRequest()
{
FileName = "readme.md",
Repos = new RepositoryCollection {
"Sniper/Sniper"
}
};
var repos = await _gitHubClient.Search.SearchCode(request);
Assert.NotEmpty(repos.Items);
}
public async Task SearchForFileNameInCodeWithoutTermWithUnderscore()
{
var request = new SearchCodeRequest()
{
FileName = "readme.md",
Repos = new RepositoryCollection {
"Cultural-Rogue/_51Wp.XinFengSDK.Demo"
}
};
var repos = await _gitHubClient.Search.SearchCode(request);
Assert.Empty(repos.Items);
}
public async Task SearchForFilesInOrganization()
{
var request = new SearchCodeRequest()
{
Organization = "octokit",
FileName = "readme.md"
};
var searchResults = await _gitHubClient.Search.SearchCode(request);
foreach (var searchResult in searchResults.Items)
{
Assert.Equal("octokit", searchResult.Repository.Owner.Login);
}
}
public async Task SearchForFileNameInCodeWithoutTerm2()
{
var request = new SearchCodeRequest()
{
FileName = "project.json",
Repos = new RepositoryCollection {
"adamcaudill/Psychson"
}
};
var repos = await _gitHubClient.Search.SearchCode(request);
Assert.Empty(repos.Items);
}
public async Task <IEnumerable <string> > SearchAsync(string url, string extension)
{
if (string.IsNullOrEmpty(url))
{
throw new ArgumentNullException(nameof(url));
}
if (string.IsNullOrEmpty(extension))
{
throw new ArgumentNullException(nameof(extension));
}
string branchName = url.ExtractBranchName();
url = url.StripBranchName(branchName);
if (!extension.StartsWith('.'))
{
extension = $".{extension}";
}
var values = GitHubUrlExtractor.ExtractFromUrl(url);
string username = values.Item1;
string reponame = values.Item2;
string search = $"extension:{extension}";
var req = new SearchCodeRequest(search, username, reponame);
if (string.IsNullOrEmpty(branchName))
{
var results = await _client.Search.SearchCode(req);
// Github is searching the contents of the files too
// Github seems generous with the match, so do a secondary filter
var filteredResults = results.Items.Select(i => i.Path);
return(filteredResults);
}
else
{
// Search in a specific branch
var tree = await _client.Git.Tree.GetRecursive(username, reponame, branchName);
var filePaths = tree.Tree.Select(item => item.Path).Where(path => Path.GetExtension(path) == extension);
return(filePaths);
}
}
/// <summary>
/// Searches code
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public static async Task <ObservableCollection <SearchCode> > SearchCode(string query)
{
try
{
var client = await UserUtility.GetAuthenticatedClient();
var request = new SearchCodeRequest(query);
var result = await client.Search.SearchCode(request);
return(new ObservableCollection <SearchCode>(new List <SearchCode>(result.Items)));
}
catch
{
return(null);
}
}
public async Task SearchForFilesInOrganization()
{
var orgs = new[] { "octokit", "github" };
var request = new SearchCodeRequest()
{
Organizations = orgs,
FileName = "readme.md"
};
var searchResults = await _gitHubClient.Search.SearchCode(request);
foreach (var searchResult in searchResults.Items)
{
Assert.Contains(searchResult.Repository.Owner.Login, orgs);
}
}
public async Task <bool> ContainsDotNetProjects(RepositorySettings repository)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
IEnumerable <string> dotNetCodeExtensions = new ReadOnlyCollection <string>(new List <string>()
{
".sln", ".csproj", ".fsproj", ".vbproj"
});
const string dotNetCodeTerms = "\"packages.config\" OR \".csproj\" OR \".fsproj\" OR \".vbproj\"";
var repos = new List <SearchRepo>
{
new SearchRepo(repository.RepositoryOwner, repository.RepositoryName)
};
var searchCodeRequest = new SearchCodeRequest(repos, dotNetCodeTerms, dotNetCodeExtensions)
{
PerPage = 1
};
try
{
var result = await _collaborationFactory.CollaborationPlatform.Search(searchCodeRequest);
if (result.TotalCount <= 0)
{
_logger.Detailed(
$"Repository {repository.RepositoryOwner}/{repository.RepositoryName} contains no .NET code on the default branch, skipping.");
return(false);
}
return(true);
}
#pragma warning disable CA1031
catch (Exception ex)
#pragma warning restore CA1031
{
_logger.Error("Repository search failed.", ex);
}
return(true);
}
static SearchCodeResult GetSampleFileList(string org)
{
try
{
//string searchText = "{FileName = \"sample.yml\",User = \"officedev\",Extension = \"yml\"}";
SearchCodeRequest sr = new SearchCodeRequest("YamlMime:Sample");
// sr.FileName = "sample.yml";
sr.Extension = "yml";
sr.Organization = "officedev";
sr.User = org;
return(GitHubManager.instance.client.Search.SearchCode(sr).Result);
}
catch (Exception e)
{
throw new Exception("Error searching GitHub: " + e.Message);
}
}
public async Task SearchForLanguageInCode()
{
var request = new SearchCodeRequest("AnonymousAuthenticator")
{
Language = Language.CSharp
};
request.Repos.Add("octokit/octokit.net");
var searchResults = await _gitHubClient.Search.SearchCode(request);
Assert.NotEmpty(searchResults.Items);
foreach (var code in searchResults.Items)
{
Assert.True(code.Name.EndsWith(".cs"));
}
}
/// <summary>
/// Searches code
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public static async Task <ObservableCollection <SearchCode> > SearchCode(string query, Language?language = null)
{
try
{
var request = new SearchCodeRequest(query);
if (language != null)
{
request.Language = language;
}
var result = await GlobalHelper.GithubClient.Search.SearchCode(request);
return(new ObservableCollection <SearchCode>(result.Items));
}
catch
{
return(null);
}
}
public void Handle(SearchGitHub message)
{
log.Info($"Received search request for '{message.SearchFor}' on {message.RepositoryOwner}/{message.Repository}...");
var request = new SearchCodeRequest(
message.SearchFor,
message.RepositoryOwner,
message.Repository);
var result = GitHubClient.Search.SearchCode(request).GetAwaiter().GetResult();
log.Info($"Found {result.TotalCount} results for {message.SearchFor}. Replying.");
var response = new SearchResponse
{
SearchedFor = message.SearchFor,
TotalCount = result.TotalCount
};
bus.Reply(response);
}
public void TestingTheSizeQualifier_Range()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchCodeRequest("something");
request.Size = new Range(10, 100);
client.SearchCode(request);
connection.Received().Get<SearchCodeResult>(
Arg.Is<Uri>(u => u.ToString() == "search/code"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "something+size:10..100"));
}
public async Task ErrorOccursWhenSpecifyingInvalidFormatForRepos()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchCodeRequest("windows");
request.Repos = new RepositoryCollection {
"haha-business"
};
request.Order = SortDirection.Descending;
await Assert.ThrowsAsync<RepositoryFormatException>(
async () => await client.SearchCode(request));
}
/// <summary>
/// search code
/// http://developer.github.com/v3/search/#search-code
/// </summary>
/// <param name="search"></param>
/// <returns>List of files</returns>
public IObservable<SearchCodeResult> SearchCode(SearchCodeRequest search)
{
Ensure.ArgumentNotNull(search, "search");
return _client.SearchCode(search).ToObservable();
}
/// <summary>
/// search code
/// http://developer.github.com/v3/search/#search-code
/// </summary>
/// <param name="request"></param>
/// <returns>List of files</returns>
public IObservable<SearchCode> SearchCode(SearchCodeRequest request)
{
Ensure.ArgumentNotNull(request, "request");
return _connection.GetAndFlattenAllPages<SearchCode>(ApiUrls.SearchCode(), request.ToParametersDictionary());
}
public void TestingTheSizeQualifier_LessThanOrEqual()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchCodeRequest("something");
request.Size = Range.LessThanOrEquals(10);
client.SearchCode(request);
connection.Received().GetAll<SearchCode>(
Arg.Is<Uri>(u => u.ToString() == "search/code"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "something+size:<=10"));
}
public void TestingTheRepoAndPathAndExtensionQualifiers()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchCodeRequest("something");
request.Repo = "octokit.net";
request.Path = "tools/FAKE.core";
request.Extension = "fs";
client.SearchCode(request);
connection.Received().Get<SearchCodeResult>(
Arg.Is<Uri>(u => u.ToString() == "search/code"),
Arg.Is<Dictionary<string, string>>(d =>
d["q"] == "something+path:tools/FAKE.core+extension:fs+repo:octokit.net"));
}
public void TestingTheSortParameter()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchCodeRequest("something");
request.SortField = CodeSearchSort.Indexed;
client.SearchCode(request);
connection.Received().GetAll<SearchCode>(
Arg.Is<Uri>(u => u.ToString() == "search/code"),
Arg.Is<Dictionary<string, string>>(d => d["sort"] == "indexed"));
}
public void TestingTheLanguageQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchCodeRequest("something");
request.Language = Language.CSharp;
client.SearchCode(request);
connection.Received().Get<SearchCodeResult>(
Arg.Is<Uri>(u => u.ToString() == "search/code"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "something+language:C#"));
}
public void TestingTheInQualifier_Multiple()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchCodeRequest("something");
request.In = new[] { CodeInQualifier.File, CodeInQualifier.Path };
client.SearchCode(request);
connection.Received().Get<SearchCodeResult>(
Arg.Is<Uri>(u => u.ToString() == "search/code"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "something+in:file,path"));
}
public void TestingTheDefaultOrderParameter()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchCodeRequest("something");
client.SearchCode(request);
connection.Received().Get<SearchCodeResult>(
Arg.Is<Uri>(u => u.ToString() == "search/code"),
Arg.Is<Dictionary<string, string>>(d => d["order"] == "desc"));
}
public void TestingTheOrderParameter()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchCodeRequest("something");
request.SortField = CodeSearchSort.Indexed;
request.Order = SortDirection.Ascending;
client.SearchCode(request);
connection.Received().Get<SearchCodeResult>(
Arg.Is<Uri>(u => u.ToString() == "search/code"),
Arg.Is<Dictionary<string, string>>(d =>
d["sort"] == "indexed" &&
d["order"] == "asc"));
}
public void TestingTheRepoQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchCodeRequest("something");
request.Repo = "octokit.net";
client.SearchCode(request);
connection.Received().Get<SearchCodeResult>(
Arg.Is<Uri>(u => u.ToString() == "search/code"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "something+repo:octokit.net"));
}
public void TestingTheUserQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchCodeRequest("something");
request.User = "******";
client.SearchCode(request);
connection.Received().GetAll<SearchCode>(
Arg.Is<Uri>(u => u.ToString() == "search/code"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "something+user:alfhenrik"));
}
public void TestingTheFileNameQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchCodeRequest("something");
request.FileName = "packages.config";
client.SearchCode(request);
connection.Received().Get<SearchCodeResult>(
Arg.Is<Uri>(u => u.ToString() == "search/code"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "something+filename:packages.config"));
}
/// <summary>
/// search code
/// http://developer.github.com/v3/search/#search-code
/// </summary>
/// <param name="search"></param>
/// <returns>List of files</returns>
public IObservable<SearchCode> SearchCode(SearchCodeRequest search)
{
Ensure.ArgumentNotNull(search, "search");
return _connection.GetAndFlattenAllPages<SearchCode>(ApiUrls.SearchCode(), search.Parameters);
}
