qiita 0.0.3 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d7aad5b6c927032cc2fd56a07a2fb1a6d288451e
+  data.tar.gz: cea7adcd772f8c7ee2dce7fd288a3406d775434b
+SHA512:
+  metadata.gz: 9aa059a756fb31e4b11fd02d93f568ee760a912be25c9662ee280dcce42aba26f1fb1501683d9860b82209b892fb8a043c556f99f91d5a4f915c38d3ff66bf83
+  data.tar.gz: eade564c0a5a16a20420438dc0a4d5e4641c873a434b7f07537b510a10c0e897320a1086aa5c541e6810847799df9c2467c47e01c41d1ed929ea96643ec969c1

data/.gitignore

@@ -7,7 +7,6 @@ Gemfile.lock
 InstalledFiles
 _yardoc
 coverage
-doc/
 lib/bundler/man
 pkg
 rdoc

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## 1.0.0
+* Support Qiita API v2.

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Hiroshige Umino
+Copyright (c) 2014 Ryo Nakamura
 
 MIT License
 
@@ -19,4 +19,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Makefile

@@ -0,0 +1,18 @@
+all: test doc
+
+doc:
+	git grep -h "^\s\+# \?" lib/qiita/response.rb               | sed -E 's; +# ?;;' > doc/response.md
+	git grep -h "^\s\+# \?" lib/qiita/client.rb                 | sed -E 's; +# ?;;' > doc/client.md
+	git grep -h "^\s\+# \?" lib/qiita/resource_based_methods.rb | sed -E 's; +# ?;;' >> doc/client.md
+
+release:
+	bundle exec rake release
+
+setup:
+	gem install bundler
+	bundle install
+
+test:
+	bundle exec rspec
+
+.PHONY: doc release setup test

data/README.md

@@ -1,70 +1,79 @@
 # Qiita
+Qiita API v2 client library and CLI tool, written in Ruby.
 
-Ruby wrapper for Qiita API v1.
+### Install
+Note: requires Ruby 2.0.0 or higher.
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'qiita'
-
-And then execute:
+```sh
+gem install qiita
+```
 
-    $ bundle
+## Library
+See [/doc](/doc) for more details.
 
-Or install it yourself as:
+```rb
+require "qiita"
 
-    $ gem install qiita
+client = Qiita::Client.new(access_token: "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcd")
+client.list_items
+client.list_users
+client.get_user_items("r7kamura")
+client.get_user("r7kamura")
+client.get_user("r7kamura").status
+client.get_user("r7kamura").headers
+client.get_user("r7kamura").body
+```
 
-## Usage
+## CLI
+`qiita` executable calls `Qiita::Client`'s methods.
 
-### Get user's items
-```ruby
-Qiita.user_items 'yaotti'
 ```
-
-### Get tag's items
-```ruby
-Qiita.tag_items 'ruby'
+$ qiita <method> <arguments> [headers|params] [options]
+           |          |          |      |         |
+           |          |          |      |         `-- -H, --host
+           |          |          |      |             -a, --access-token
+           |          |          |      |             -c, --color
+           |          |          |      |             -h, --help
+           |          |          |      |                 --header
+           |          |          |      |                 --no-body
+           |          |          |      |             -t, --team
+           |          |          |      |
+           |          |          |      `------------ key=value or key:=value
+           |          |          |
+           |          |          `------------------- Key:value
+           |          |
+           |          `------------------------------ required arguments for the method
+           |
+           `----------------------------------------- method name
+
+$ qiita list_users
+$ qiita get_user r7kamura
+$ qiita list_user_items r7kamura
 ```
 
-### Get a specified item with comments and raw markdown content
-```ruby
-item_uuid = '1234567890abcdefg'
-Qiita.item item_uuid
-```
+### Method and Arguments
+Pass [Qiita::Client's method name](doc/client.md) and required arguments.
 
+### Access token
+Accepts access token via `-a, --access-token` or `QIITA_ACCESS_TOKEN` environment variable.
 
-## Authenticated requests
+### Headers
+To set custom request headers, use `Key:value` syntax.
 
-### Login with "username & password" or "token"
-```
-qiita = Qiita.new url_name: 'yaotti', password: 'mysecret' # => contains token
-# or
-qiita = Qiita.new token: 'myauthtoken'
 ```
-
-### Get my items
-```ruby
-qiita.user_items
+$ qiita list_items "Authorization:Bearer 1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcd"
 ```
 
-### Post/Update/Delete an item
-```ruby
-# post
-item = qiita.post_item title: 'Hello', body: 'markdown text', tags: [{ name: 'ruby', versions: %w[1.9.2 1.9.3] }], private: false
+### Params
+Params are used for query string in GET method, or for request body in other methods.
+You can set params by `key=value` or `key:=value` syntax.
+`key=value` is parsed into String value,
+while `key:=value` is parsed into JSON value (e.g. key:=17 will be `{"key":17}`).
+`qiita` also accepts params via STDIN.
 
-# update
-qiita.update_item item.uuid, title: 'modified'
-
-# delete
-qiita.delete_item item.uuid
+```
+$ qiita list_items page=2 per_page=10
+$ qiita create_item < params.json
 ```
 
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+![](images/cli.png)

data/bin/qiita

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "qiita"
+
+builder = Qiita::CommandBuilder.new(ARGV)
+command = builder.call
+command.call

data/doc/client.md

@@ -0,0 +1,171 @@
+### Qiita::Client.new(options = {})
+Creates a new instance of `Qiita::Client` class.
+`options` can have following key-values:
+
+* `access_token` - (String) Access token issued to authenticate and authorize user.
+* `host` - (String) Hostname where this client accesses to.
+
+```rb
+Qiita::Client.new
+Qiita::Client.new(access_token: "...")
+Qiita::Client.new(host: "my-team-name.qiita.com")
+```
+
+### Qiita::Client#get(path, params = nil, headers = nil)
+Sends GET request with given parameters, then returns a `Qiita::Response`.
+`params` are url-encoded and used as URI query string.
+
+```rb
+client.get("/api/v2/items", page: 2)
+```
+
+### Qiita::Client#post(path, params = nil, headers = nil)
+Sends POST request with given parameters, then returns a Qiita::Response.
+`params` are JSON-encoded and used as request body.
+
+```rb
+client.post("/api/v2/items", title: "...", body: "...")
+```
+
+### Qiita::Client#patch(path, params = nil, headers = nil)
+Sends PATCH request with given parameters, then returns a Qiita::Response.
+`params` are JSON-encoded and used as request body.
+
+```rb
+client.patch("/api/v2/items/543efd13001e30837319", title: "...", body: "...")
+```
+
+### Qiita::Client#put(path, params = nil, headers = nil)
+Sends PUT request, then returns a Qiita::Response.
+`params` are JSON-encoded and used as request body.
+
+```rb
+client.put("/api/v2/items/543efd13001e30837319/stock")
+```
+
+### Qiita::Client#delete(path, params = nil, headers = nil)
+Sends DELETE request, then returns a Qiita::Response.
+`params` are url-encoded and used as URI query string.
+
+```rb
+client.delete("/api/v2/items/543efd13001e30837319/stock")
+```
+
+### Qiita::Client#connection
+Returns a Faraday::Connection to customize by your favorite middlewares.
+
+```rb
+client.connection.response :logger
+```
+
+### Qiita::Client#create_access_token(params = nil, headers = nil)
+与えられた認証情報をもとに新しいアクセストークンを発行します。
+
+### Qiita::Client#delete_access_token(token, params = nil, headers = nil)
+与えられたアクセストークンを失効させ、それ以降利用されないようにします。
+
+### Qiita::Client#delete_comment(id, params = nil, headers = nil)
+特定のコメントを削除します。
+
+### Qiita::Client#update_comment(id, params = nil, headers = nil)
+特定のコメントを更新します。
+
+### Qiita::Client#list_item_comments(item_id, params = nil, headers = nil)
+特定の投稿に寄せられたコメント一覧を返します。
+
+### Qiita::Client#create_item_comment(item_id, params = nil, headers = nil)
+特定の投稿にコメントを付けます。
+
+### Qiita::Client#thank_comment(comment_id, params = nil, headers = nil)
+特定のコメントにThankを付けます。
+
+### Qiita::Client#unthank_comment(comment_id, params = nil, headers = nil)
+特定のコメントからThankを外します。
+
+### Qiita::Client#list_items(params = nil, headers = nil)
+新着順に全ての投稿一覧を返します。
+
+### Qiita::Client#create_item(params = nil, headers = nil)
+新たに投稿を作成します。
+
+### Qiita::Client#get_item(id, params = nil, headers = nil)
+特定の投稿を返します。
+
+### Qiita::Client#update_item(id, params = nil, headers = nil)
+特定の投稿を編集します。
+
+### Qiita::Client#delete_item(id, params = nil, headers = nil)
+特定の投稿を削除します。
+
+### Qiita::Client#list_tag_items(id, params = nil, headers = nil)
+特定のタグが付けられた投稿一覧を返します。
+
+### Qiita::Client#list_user_items(user_id, params = nil, headers = nil)
+特定のユーザの投稿一覧を返します。
+
+### Qiita::Client#list_user_stocks(user_id, params = nil, headers = nil)
+特定のユーザがストックした投稿一覧を返します。
+
+### Qiita::Client#stock_item(item_id, params = nil, headers = nil)
+特定の投稿をストックします。
+
+### Qiita::Client#unstock_item(item_id, params = nil, headers = nil)
+特定の投稿をストックから取り除きます。
+
+### Qiita::Client#lgtm_item(item_id, params = nil, headers = nil)
+特定の投稿に「いいね！」を付けます。
+
+### Qiita::Client#unlgtm_item(item_id, params = nil, headers = nil)
+特定の投稿への「いいね！」を取り消します。
+
+### Qiita::Client#list_projects(params = nil, headers = nil)
+チーム内に存在するプロジェクト一覧を返します。
+
+### Qiita::Client#get_project(id, params = nil, headers = nil)
+特定のプロジェクトを返します。
+
+### Qiita::Client#create_project(params = nil, headers = nil)
+プロジェクトを新たに作成します。
+
+### Qiita::Client#delete_project(id, params = nil, headers = nil)
+特定のプロジェクトを削除します。
+
+### Qiita::Client#update_project(id, params = nil, headers = nil)
+特定のプロジェクトを編集します。
+
+### Qiita::Client#list_tags(params = nil, headers = nil)
+全てのタグ一覧を返します。
+
+### Qiita::Client#get_tag(id, params = nil, headers = nil)
+特定のタグを返します。
+
+### Qiita::Client#list_user_following_tags(user_id, params = nil, headers = nil)
+特定のユーザがフォローしているタグ一覧を返します。
+
+### Qiita::Client#list_templates(params = nil, headers = nil)
+全てのテンプレート一覧を返します。
+
+### Qiita::Client#delete_template(id, params = nil, headers = nil)
+特定のテンプレートを削除します。
+
+### Qiita::Client#create_template(params = nil, headers = nil)
+新しくテンプレートを作成します。
+
+### Qiita::Client#update_template(id, params = nil, headers = nil)
+特定のテンプレートを編集します。
+
+### Qiita::Client#list_users(params = nil, headers = nil)
+全てのユーザの一覧を返します。
+
+### Qiita::Client#get_user(id, params = nil, headers = nil)
+特定のユーザを返します。
+
+### Qiita::Client#get_authenticated_user(params = nil, headers = nil)
+アクセストークンに紐付いたユーザを返します。
+
+### Qiita::Client#list_user_followees(user_id, params = nil, headers = nil)
+特定のユーザがフォローしているユーザ一覧を返します。
+
+### Qiita::Client#list_user_followers(user_id, params = nil, headers = nil)
+特定のユーザをフォローしているユーザ一覧を返します。
+

data/doc/response.md

@@ -0,0 +1,33 @@
+### Qiita::Response#body
+Returns response body returned from API as a `Hash` or an `Array` of `Hash`.
+
+```rb
+response.body #=> { ... }
+```
+
+### Qiita::Response#first_page_url
+Returns first page URL or nil.
+
+### Qiita::Response#last_page_url
+Returns last page URL or nil.
+
+### Qiita::Response#next_page_url
+Returns next page URL or nil.
+
+### Qiita::Response#previous_page_url
+Returns previous page URL or nil.
+
+### Qiita::Response#headers
+Returns response headers returned from API as a `Hash`.
+
+```rb
+response.headers #=> { "Content-Type" => "application/json" }
+```
+
+### Qiita::Response#status
+Returns response status code returned from API as a `Fixnum`.
+
+```rb
+response.status #=> 200
+```
+

data/lib/qiita.rb

@@ -1,16 +1,21 @@
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/string/strip"
+require "faraday"
+require "faraday_middleware"
+require "json"
+require "rack/utils"
+require "rainbow"
+require "rouge"
+require "slop"
+
+require "qiita/arguments"
 require "qiita/client"
+require "qiita/command_builder"
+require "qiita/commands/base"
+require "qiita/commands/error"
+require "qiita/commands/request"
+require "qiita/resource_based_methods"
+require "qiita/response"
+require "qiita/response_renderer"
 require "qiita/version"
-
-module Qiita
-  class << self
-    def new options={}
-      Qiita::Client.new options
-    end
-
-    # Delegate to Qiita::Client.new
-    def method_missing(method, *args, &block)
-      return super unless new.respond_to?(method)
-      new.send(method, *args, &block)
-    end
-  end
-end

data/lib/qiita/arguments.rb

@@ -0,0 +1,138 @@
+module Qiita
+  class Arguments
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def access_token
+      slop_options["access-token"] || ENV["QIITA_ACCESS_TOKEN"]
+    end
+
+    def arguments
+      parsed_argv_data[:arguments]
+    end
+
+    def color
+      slop_options["color"]
+    end
+
+    def error_message
+      slop_options.to_s
+    end
+
+    def headers
+      parsed_argv_data[:headers]
+    end
+
+    def host
+      slop_options["host"]
+    end
+
+    def method_name
+      ARGV[0]
+    end
+
+    def params
+      params_from_stdin.merge(parsed_argv_data[:params])
+    end
+
+    def show_body
+      !slop_options["no-body"]
+    end
+
+    def show_header
+      slop_options["header"]
+    end
+
+    def team
+      slop_options["team"]
+    end
+
+    def valid?
+      has_valid_slop_options? && has_valid_method_name? && has_valid_arguments? && !has_invalid_json_input?
+    end
+
+    private
+
+    def has_input_from_stdin?
+      has_pipe_input? || has_redirect_input?
+    end
+
+    def has_invalid_json_input?
+      params_from_stdin
+      false
+    rescue JSON::ParserError
+      true
+    end
+
+    def has_pipe_input?
+      File.pipe?(STDIN)
+    end
+
+    def has_redirect_input?
+      File.select([STDIN], [], [], 0) != nil
+    end
+
+    def has_valid_arguments?
+      -(Client.instance_method(method_name).arity) - 1 == arguments.length
+    end
+
+    def has_valid_method_name?
+      !method_name.nil? && Client.instance_methods.include?(method_name.to_sym)
+    end
+
+    def has_valid_slop_options?
+      !slop_options["help"]
+    rescue
+      false
+    end
+
+    def params_from_stdin
+      @params_from_stdin ||= begin
+        if has_input_from_stdin?
+          JSON.parse(STDIN.read)
+        else
+          {}
+        end
+      end
+    end
+
+    def parsed_argv_data
+      @parsed_argv_data ||= begin
+        params = {}
+        headers = {}
+        arguments = []
+        ARGV[1..-1].each do |section|
+          case
+          when /(?<key>.+):(?<value>[^=]+)/ =~ section
+            headers[key] = value
+          when /(?<key>.+):=(?<value>.+)/ =~ section
+            params[key] = JSON.parse(%<{"key":#{value}}>)["key"]
+          when /(?<key>.+)=(?<value>.+)/ =~ section
+            params[key] = value
+          else
+            arguments << section
+          end
+        end
+        {
+          arguments: arguments,
+          headers: headers,
+          params: params,
+        }
+      end
+    end
+
+    def slop_options
+      @slop_options ||= Slop.parse!(@argv) do
+        banner "Usage: qiita <method> [arguments] [headers|params] [options]"
+        on "H", "host=", "Change API server's host"
+        on "a", "access-token=", "Access token"
+        on "c", "color", "Color output"
+        on "h", "help", "Display help message"
+        on "header", "Show response header"
+        on "no-body", "Hide response body"
+        on "t", "team=", "Team name to be used as subdomain"
+      end
+    end
+  end
+end