Add go files

Author: uetchy

Makefile

@@ -0,0 +1,14 @@
+ALFRED_WORKFLOW_PATH ?= ~/Library/Application Support/Alfred 2/Alfred.alfredpreferences/workflows
+BUNDLE_ID = "co.randompaper.alfred-qiita-workflow"
+PACKAGE_FILE = "info.plist"
+
+run:
+	go run *.go
+
+link:
+	TARGET := "$(ALFRED_WORKFLOW_PATH)/$(BUNDLE_ID)"
+	# mkdir -p "${TARGET}"
+	# ln -sf "`pwd`", "$(TARGET)"
+
+unlink:
+	rm "$ALFRED_WORKFLOW_PATH/$BUNDLE_ID"

main.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"github.com/codegangsta/cli"
+	"os"
+)
+
+const (
+	bundleId    = "co.randompaper.alfred-qiita-workflow"
+)
+
+func main() {
+	app := cli.NewApp()
+	app.Name = "qiita"
+	// app.Usage = "fight the loneliness!"
+	app.Commands = []cli.Command{
+		{
+			Name:   "search",
+			Action: cmdSearch,
+		},
+	}
+	app.Run(os.Args)
+}
+
+func cmdSetToken(c *cli.Context) {
+	token := c.Args().First()
+
+	configPath := "~/Library/Application Support/Alfred 2/Workflow Data/" + bundleId + "/token"
+
+	fout, err := os.Create(configPath)
+	if err != nil {
+		return
+	}
+	defer fout.Close()
+
+	fout.WriteString(token)
+}

qiita/items.go

@@ -0,0 +1,53 @@
+package qiita
+
+import (
+	// "fmt"
+	"net/http"
+	"time"
+)
+
+type ItemsService struct {
+	client *Client
+}
+
+type Item struct {
+	RenderedBody *string    `json:"rendered_body"`
+	Body         *string    `json:"body"`
+	Coediting    *bool      `json:"coediting"`
+	CreatedAt    *time.Time `json:"created_at"`
+	Id           *string    `json:"id"`
+	Private      *bool      `json:"private"`
+	Tags         []Tag      `json:"tags"`
+	Title        *string    `json:"title"`
+	UpdatedAt    *time.Time `json:"updated_at"`
+	URL          *string    `json:"url"`
+	// TODO: User
+}
+
+type Tag struct {
+	Name     *string  `json:"name"`
+	Versions []string `json:"versions"`
+}
+
+type ItemsListOptions struct {
+	Query string `url:"query,omitempty"`
+	ListOptions
+}
+
+func (s *ItemsService) List(opt *ItemsListOptions) ([]Item, *http.Response, error) {
+	u, err := addOptions("items", opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+	items := new([]Item)
+	resp, err := s.client.Do(req, items)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return *items, resp, err
+}

qiita/qiita.go

@@ -0,0 +1,126 @@
+package qiita
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	// "io/ioutil"
+	"fmt"
+	"github.com/google/go-querystring/query"
+	"net/http"
+	"net/url"
+	"reflect"
+)
+
+const (
+	defaultBaseURL = "https://qiita.com/api/v2/"
+	userAgent      = "go-qiita"
+)
+
+type ListOptions struct {
+	Page    int `url:"page,omitempty"`
+	PerPage int `url:"per_page,omitempty"`
+}
+
+type Response struct {
+	*http.Response
+
+	NextPage  int
+	PrevPage  int
+	FirstPage int
+	LastPage  int
+}
+
+type Client struct {
+	client    *http.Client
+	BaseURL   *url.URL
+	UserAgent string
+
+	Items *ItemsService
+}
+
+func addOptions(s string, opt interface{}) (string, error) {
+	v := reflect.ValueOf(opt)
+	if v.Kind() == reflect.Ptr && v.IsNil() {
+		return s, nil
+	}
+
+	u, err := url.Parse(s)
+	if err != nil {
+		return s, err
+	}
+
+	qs, err := query.Values(opt)
+	if err != nil {
+		return s, err
+	}
+
+	u.RawQuery = qs.Encode()
+	return u.String(), nil
+}
+
+func NewClient(httpClient *http.Client) *Client {
+	if httpClient == nil {
+		httpClient = http.DefaultClient
+	}
+	baseURL, _ := url.Parse(defaultBaseURL)
+	fmt.Println(baseURL)
+
+	c := &Client{client: httpClient, BaseURL: baseURL, UserAgent: userAgent}
+	c.Items = &ItemsService{client: c}
+	return c
+}
+
+func (c *Client) NewRequest(method, urlStr string, body interface{}) (*http.Request, error) {
+	rel, err := url.Parse(urlStr)
+	if err != nil {
+		return nil, err
+	}
+
+	u := c.BaseURL.ResolveReference(rel)
+
+	var buf io.ReadWriter
+	if body != nil {
+		buf = new(bytes.Buffer)
+		err := json.NewEncoder(buf).Encode(body)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	req, err := http.NewRequest(method, u.String(), buf)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Add("Accept", "application/json")
+	if c.UserAgent != "" {
+		req.Header.Add("User-Agent", c.UserAgent)
+	}
+	return req, nil
+}
+
+func (c *Client) Do(req *http.Request, v interface{}) (*http.Response, error) {
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	defer resp.Body.Close()
+
+	// err = CheckResponse(resp)
+	// if err != nil {
+	// 	// even though there was an error, we still return the response
+	// 	// in case the caller wants to inspect it further
+	// 	return resp, err
+	// }
+
+	if v != nil {
+		if w, ok := v.(io.Writer); ok {
+			io.Copy(w, resp.Body)
+		} else {
+			err = json.NewDecoder(resp.Body).Decode(v)
+		}
+	}
+	return resp, err
+}

search.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"github.com/pascalw/go-alfred"
+	"fmt"
+	"github.com/codegangsta/cli"
+	"github.com/uetchy/alfred-qiita-workflow/qiita"
+	"golang.org/x/oauth2"
+)
+
+func cmdSearch(c *cli.Context) {
+	query := c.Args().First()
+
+	ts := oauth2.StaticTokenSource(
+		&oauth2.Token{AccessToken: accessToken},
+	)
+	tc := oauth2.NewClient(oauth2.NoContext, ts)
+	client := qiita.NewClient(tc)
+
+	// Fetch items
+	items, _, _ := client.Items.List(&qiita.ItemsListOptions{Query: query})
+	fmt.Println(*items[0].Title)
+
+	// alfred.InitTerms(query)
+
+	response := alfred.NewResponse()
+
+	for _, item := range items {
+		// if !alfred.MatchesTerms(query, repo.Name) {
+		// 	continue
+		// }
+		response.AddItem(&alfred.AlfredResponseItem{
+			Valid: true,
+			Uid:   *item.Id,
+			Title: *item.Title,
+			Arg:   *item.URL,
+		})
+	}
+
+	response.Print()
+}