githubscraper

README

Github Scraper

Github API is annoying to work with for a basic task like repo search you wont need to request a tokens.

This library allows you to save time, and quickly start. No tokens needed. No restrictions. Extremely fast.

Installation

go get -u github.com/DipandaAser/github-scraper

Usage

Let's start with a trivial example

package main

import (
	"fmt"
	githubscraper "github.com/DipandaAser/github-scraper"
)

func main() {
	s := githubscraper.New()
	for repo := range s.SearchRepositories(githubscraper.DefaultSortOption, "go", 20) {
		fmt.Println(repo.Name)
	}
}

Available Methods

* githubscraper.SearchRepositories()

SortOptions:

• githubscraper.DefaultSortOption
• githubscraper.RepositoryMostStars
• githubscraper.RepositoryFewestStars
• githubscraper.RepositoryMostForks
• githubscraper.RepositoryFewestForks
• githubscraper.RepositoryRecentlyUpdated

* githubscraper.SearchUsers()

SortOptions:

• githubscraper.DefaultSortOption
• githubscraper.UserMostFollowers
• githubscraper.UserFewestFollowers
• githubscraper.UserMostRecentlyJoined
• githubscraper.UserLeastRecentlyJoined
• githubscraper.UserMostRepositories
• githubscraper.UserFewestRepositories

* githubscraper.SearchCommits()

SortOptions:

• githubscraper.DefaultSortOption
• githubscraper.CommitRecentlyCommitted
• githubscraper.CommitLeastRecentlyCommitted
• githubscraper.CommitRecentlyAuthored
• githubscraper.CommitLeastRecentlyAuthored

* githubscraper.SearchIssues()

SortOptions:

• githubscraper.DefaultSortOption
• githubscraper.IssuesMostCommented
• githubscraper.IssuesNewest
• githubscraper.IssuesOldest
• githubscraper.IssuesRecentlyUpdated
• githubscraper.IssuesLeastRecentlyUpdated

Default Scraper (Ad hoc)

In simple cases, you can use the default scraper without creating an object instance

package main

import (
	"fmt"
	githubscraper "github.com/DipandaAser/github-scraper"
)

func main() {
	for repo := range githubscraper.SearchRepositories(githubscraper.DefaultSortOption, "go", 20) {
		fmt.Println(repo.Name)
	}
}

Documentation

Index

• Variables
• func SearchCommits(opt sortOptions, query string, maxResult int) <-chan *Commit
• func SearchIssues(opt sortOptions, query string, maxResult int) <-chan *Issue
• func SearchRepositories(opt sortOptions, query string, maxResult int) <-chan *Repository
• func SearchUsers(opt sortOptions, query string, maxResult int) <-chan *User
• type Commit
• type Issue
• type Repository
• type Scraper
  • func New() *Scraper
  • func (s *Scraper) SearchCommits(opt sortOptions, query string, maxResult int) <-chan *Commit
  • func (s *Scraper) SearchIssues(opt sortOptions, query string, maxResult int) <-chan *Issue
  • func (s *Scraper) SearchRepositories(opt sortOptions, query string, maxResult int) <-chan *Repository
  • func (s *Scraper) SearchUsers(opt sortOptions, query string, maxResult int) <-chan *User
• type User

Variables

var (
	DefaultSortOption              = sortOptions{/* contains filtered or unexported fields */}
	RepositoryMostStars            = sortOptions{/* contains filtered or unexported fields */}
	RepositoryFewestStars          = sortOptions{/* contains filtered or unexported fields */}
	RepositoryMostForks            = sortOptions{/* contains filtered or unexported fields */}
	RepositoryFewestForks          = sortOptions{/* contains filtered or unexported fields */}
	RepositoryRecentlyUpdated      = sortOptions{/* contains filtered or unexported fields */}
	RepositoryLeastRecentlyUpdated = sortOptions{/* contains filtered or unexported fields */}
	CommitRecentlyCommitted        = sortOptions{/* contains filtered or unexported fields */}
	CommitLeastRecentlyCommitted   = sortOptions{/* contains filtered or unexported fields */}
	CommitRecentlyAuthored         = sortOptions{/* contains filtered or unexported fields */}
	CommitLeastRecentlyAuthored    = sortOptions{/* contains filtered or unexported fields */}
	IssuesMostCommented            = sortOptions{/* contains filtered or unexported fields */}
	IssuesNewest                   = sortOptions{/* contains filtered or unexported fields */}
	IssuesOldest                   = sortOptions{/* contains filtered or unexported fields */}
	IssuesRecentlyUpdated          = sortOptions{/* contains filtered or unexported fields */}
	IssuesLeastRecentlyUpdated     = sortOptions{/* contains filtered or unexported fields */}
	UserMostFollowers              = sortOptions{/* contains filtered or unexported fields */}
	UserFewestFollowers            = sortOptions{/* contains filtered or unexported fields */}
	UserMostRecentlyJoined         = sortOptions{/* contains filtered or unexported fields */}
	UserLeastRecentlyJoined        = sortOptions{/* contains filtered or unexported fields */}
	UserMostRepositories           = sortOptions{/* contains filtered or unexported fields */}
	UserFewestRepositories         = sortOptions{/* contains filtered or unexported fields */}
)

Functions

func SearchCommits

func SearchCommits(opt sortOptions, query string, maxResult int) <-chan *Commit

SearchCommits wrapper for default Scraper

func SearchIssues

func SearchIssues(opt sortOptions, query string, maxResult int) <-chan *Issue

SearchIssues wrapper for default Scraper

func SearchRepositories

func SearchRepositories(opt sortOptions, query string, maxResult int) <-chan *Repository

SearchRepositories wrapper for default Scraper

func SearchUsers

func SearchUsers(opt sortOptions, query string, maxResult int) <-chan *User

SearchUsers wrapper for default Scraper

Types

type Commit

type Commit struct {
	RepositoryName string `json:"repository_name"`
	RepositoryLink string `json:"repository_link"`
	CommitLink     string `json:"commit_link"`
	CommitMessage  string `json:"commit_message"`
	Author         string `json:"author"`
	CommitDate     string `json:"commit_date"`
	Error          error
}

type Issue

type Issue struct {
	RepositoryName string `json:"repository_name"`
	RepositoryLink string `json:"repository_link"`
	Link           string `json:"link"`
	Title          string `json:"title"`
	Description    string `json:"description"`
	Status         string `json:"status"`
	IsPullRequest  bool   `json:"is_pull_request"`
	Author         string `json:"author"`
	Date           string `json:"date"`
	Error          error
}

type Repository

type Repository struct {
	Name                string   `json:"name"`
	Url                 string   `json:"url"`
	Description         string   `json:"description"`
	Topics              []string `json:"topics"`
	Stars               string   `json:"stars"`
	Licence             string   `json:"licence"`
	ProgrammingLanguage string   `json:"programming_language"`
	UpdateTime          string   `json:"update_time"`
	Error               error
}

type Scraper

type Scraper struct {
	// contains filtered or unexported fields
}

func New

func New() *Scraper

New creates a Scraper object

func (*Scraper) SearchCommits

func (s *Scraper) SearchCommits(opt sortOptions, query string, maxResult int) <-chan *Commit

SearchCommits returns channel with Commit for a given search query

func (*Scraper) SearchIssues

func (s *Scraper) SearchIssues(opt sortOptions, query string, maxResult int) <-chan *Issue

SearchIssues returns channel with Issue for a given search query

func (*Scraper) SearchRepositories

func (s *Scraper) SearchRepositories(opt sortOptions, query string, maxResult int) <-chan *Repository

SearchRepositories returns channel with Repository for a given search query

func (*Scraper) SearchUsers

func (s *Scraper) SearchUsers(opt sortOptions, query string, maxResult int) <-chan *User

SearchUsers returns channel with User for a given search query

type User

type User struct {
	Name     string `json:"name"`
	Pseudo   string `json:"pseudo"`
	Bio      string `json:"bio"`
	Avatar   string `json:"avatar"`
	Link     string `json:"link"`
	Location string `json:"location"`
	Error    error
}