qiita 0.0.3 → 1.0.0

data/lib/qiita/response.rb

@@ -0,0 +1,92 @@
+# ## Qiita::Response
+# A class for response data returned from API.
+#
+module Qiita
+  class Response
+    def initialize(faraday_response)
+      @raw_body = faraday_response.body
+      @raw_headers = faraday_response.headers
+      @raw_status = faraday_response.status
+    end
+
+    # ### Qiita::Response#body
+    # Returns response body returned from API as a `Hash` or an `Array` of `Hash`.
+    #
+    # ```rb
+    # response.body #=> { ... }
+    # ```
+    #
+    def body
+      @raw_body
+    end
+
+    # ### Qiita::Response#first_page_url
+    # Returns first page URL or nil.
+    #
+    def first_page_url
+      links_table["first"]
+    end
+
+    # ### Qiita::Response#last_page_url
+    # Returns last page URL or nil.
+    #
+    def last_page_url
+      links_table["last"]
+    end
+
+    # ### Qiita::Response#next_page_url
+    # Returns next page URL or nil.
+    #
+    def next_page_url
+      links_table["next"]
+    end
+
+    # ### Qiita::Response#previous_page_url
+    # Returns previous page URL or nil.
+    #
+    def previous_page_url
+      links_table["previous"]
+    end
+
+    # ### Qiita::Response#headers
+    # Returns response headers returned from API as a `Hash`.
+    #
+    # ```rb
+    # response.headers #=> { "Content-Type" => "application/json" }
+    # ```
+    #
+    def headers
+      @headers ||= @raw_headers.inject({}) do |result, (key, value)|
+        result.merge(key.split("-").map(&:capitalize).join("-") => value)
+      end
+    end
+
+    # ### Qiita::Response#status
+    # Returns response status code returned from API as a `Fixnum`.
+    #
+    # ```rb
+    # response.status #=> 200
+    # ```
+    #
+    def status
+      @raw_status
+    end
+
+    def to_s
+      @to_s ||= ResponseRenderer.new(self, show_body: true, show_header: true).to_s
+    end
+
+    def status_message
+      Rack::Utils::HTTP_STATUS_CODES[status]
+    end
+
+    private
+
+    def links_table
+      @links_table ||= (headers["Link"] || "").split(", ").inject({}) do |table, section|
+        url, rel = section.match(/\A<(.+)>; rel="(.+)"\z/)[1..2]
+        table.merge(rel => url)
+      end
+    end
+  end
+end

data/lib/qiita/response_renderer.rb

@@ -0,0 +1,79 @@
+module Qiita
+  class ResponseRenderer
+    def initialize(response, color: nil, show_header: nil, show_body: nil)
+      @response = response
+      @color = color
+      @show_body = show_body
+      @show_header = show_header
+    end
+
+    def to_s
+      template % {
+        status: status,
+        headers: headers,
+        body: body,
+      }
+    end
+
+    private
+
+    def template
+      str = ""
+      str << <<-EOS.strip_heredoc if @show_header
+        HTTP/1.1 %{status}
+        %{headers}
+      EOS
+      if has_body? && @show_body
+        str << "\n" if @show_header
+        str << "%{body}"
+      end
+      str
+    end
+
+    def headers
+      @response.headers.sort_by do |key, value|
+        key
+      end.map do |key, value|
+        "%{key}: %{value}" % {
+          key: Rainbow(key.split("-").map(&:camelize).join("-")).underline,
+          value: Rainbow(value).green,
+        }
+      end.join("\n")
+    end
+
+    def status
+      Rainbow("#{@response.status} #{@response.status_message}").bright
+    end
+
+    def body
+      if @color
+        Rouge::Formatters::Terminal256.format(
+          Rouge::Lexers::Ruby.new.lex(plain_body),
+          theme: "github"
+        )
+      else
+        plain_body
+      end
+    end
+
+    def plain_body
+      if has_body?
+        JSON.pretty_generate(@response.body) + "\n"
+      else
+        ""
+      end
+    end
+
+    def Rainbow(str)
+      if @color
+        super
+      else
+        Rainbow::NullPresenter.new(str.to_s)
+      end
+    end
+
+    def has_body?
+      @response.headers['Content-Length'].to_i > 0
+    end
+  end
+end

data/lib/qiita/version.rb

@@ -1,3 +1,3 @@
 module Qiita
-  VERSION = "0.0.3"
+  VERSION = "1.0.0"
 end

data/qiita.gemspec

@@ -1,29 +1,31 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'qiita/version'
+require "qiita/version"
 
-Gem::Specification.new do |gem|
-  gem.name          = "qiita"
-  gem.version       = Qiita::VERSION
-  gem.authors       = ["Hiroshige Umino"]
-  gem.email         = ["yaotti@qiita.com"]
-  gem.description   = <<desc
-  Gets some tag's or user's items at qiita.com.
-  Creates, updates, deletes and stocks items at Qiita.
-desc
-  gem.summary       = "Ruby wrapper for Qiita API v1."
-  gem.homepage      = "http://github.com/yaotti/qiita-rb"
+Gem::Specification.new do |spec|
+  spec.name          = "qiita"
+  spec.version       = Qiita::VERSION
+  spec.authors       = ["Ryo Nakamura"]
+  spec.email         = ["r7kamura@gmail.com"]
+  spec.summary       = "A client library for Qiita API v2 written in Ruby."
+  spec.homepage      = "https://github.com/increments/qiita-rb"
 
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
 
-  gem.add_dependency 'faraday', '~> 0.8'
-  gem.add_dependency 'faraday_middleware', '~> 0.8'
-  gem.add_dependency 'json', '~> 1.7'
-  gem.add_dependency 'hashie', '~> 1.2'
-
-  gem.add_development_dependency 'rspec'
+  spec.add_dependency "activesupport"
+  spec.add_dependency "faraday", "~> 0.9"
+  spec.add_dependency "faraday_middleware"
+  spec.add_dependency "rack"
+  spec.add_dependency "rainbow"
+  spec.add_dependency "rouge"
+  spec.add_dependency "slop"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "json_schema"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "2.14.1"
+  spec.add_development_dependency "webmock"
 end

data/script/generate

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# # script/generate
+# Generates source code text of Qiita::ResourceBasedMethods from given JSON Schema.
+#
+# ## Usage
+# Run this script with a path to JSON Schema of Qiita API v2, available only for staff.
+#
+# ```sh
+# bundle exec ./script/generate /path/to/json/schema > lib/qiita/resource_based_methods.rb
+# ```
+#
+require "active_support/core_ext/object/try"
+require "active_support/core_ext/string/indent"
+require "active_support/core_ext/string/strip"
+require "json_schema"
+require "ostruct"
+require "yaml"
+
+# View object class to generate String representation of each method.
+method_class = Class.new(OpenStruct) do
+  def to_s
+    <<-EOS.strip_heredoc
+      # ### Qiita::Client##{method_name}(#{arguments})
+      # #{description}
+      #
+      def #{method_name}(#{arguments})
+        #{request_method}(#{path}, params, headers)
+      end
+    EOS
+  end
+
+  private
+
+  def arguments
+    [required_argument_names + optional_arguments].join(", ")
+  end
+
+  def optional_arguments
+    ["params = nil", "headers = nil"]
+  end
+
+  def path
+    ?" + href.gsub(%r<{\(.*/([^/]+)\)}>, '#{\1}') + ?"
+  end
+end
+
+path_to_json_schema = ARGV[0]
+hash = YAML.load_file(path_to_json_schema)
+schema = JsonSchema.parse!(hash).tap(&:expand_references!)
+links = schema.properties.values.map(&:links).flatten
+methods = links.map do |link|
+  method_class.new(
+    available_parameters: (link.schema.try(:properties) || {}).map do |name, property|
+      {
+        description: property.description,
+        name: name,
+        type: property.type,
+      }
+    end,
+    description: link.description,
+    href: link.href,
+    method_name: link.title,
+    request_method: link.method.downcase,
+    required_argument_names: link.href.scan(%r<{\(.*/([^/]+)\)}>).flatten,
+  )
+end
+
+puts <<-EOS
+module Qiita
+  module ResourceBasedMethods
+    #{methods.join("\n").indent(4).strip}
+  end
+end
+EOS

data/spec/qiita/client_spec.rb

@@ -0,0 +1,335 @@
+require "spec_helper"
+
+describe Qiita::Client do
+  def stub_api_request
+    stub_request(request_method, requested_url).with(
+      body: request_body,
+      headers: requested_headers,
+    ).to_return(
+      body: response_body,
+      headers: response_headers,
+      status: status_code,
+    )
+  end
+
+  let(:status_code) do
+    200
+  end
+
+  let(:response_body) do
+    response_hash.to_json
+  end
+
+  let(:response_hash) do
+    { "dummy" => "dummy" }
+  end
+
+  let(:response_headers) do
+    { "Content-Type" => "application/json" }
+  end
+
+  let(:requested_headers) do
+    Qiita::Client::DEFAULT_HEADERS.clone
+  end
+
+  let(:request_body) do
+    params.nil? || [:get, :delete].include?(request_method) ? nil : params
+  end
+
+  let(:requested_url) do
+    "https://#{requested_host}#{path}"
+  end
+
+  let(:requested_host) do
+    Qiita::Client::DEFAULT_HOST
+  end
+
+  let(:host) do
+    Qiita::Client::DEFAULT_HOST
+  end
+
+  let(:client) do
+    described_class.new(options)
+  end
+
+  let(:options) do
+    {}
+  end
+
+  let(:arguments) do
+    [path, params, headers]
+  end
+
+  let(:path) do
+    "/api/v2/dummy"
+  end
+
+  let(:params) do
+  end
+
+  let(:headers) do
+    {}
+  end
+
+  shared_examples_for "returns a Qiita::Response" do
+    it "returns a Qiita::Response" do
+      should be_a Qiita::Response
+      subject.body.should eq response_hash
+      subject.headers.should eq response_headers
+      subject.status.should eq status_code
+    end
+  end
+
+  shared_examples_for "valid condition" do
+    context "with valid condition" do
+      include_examples "returns a Qiita::Response"
+    end
+  end
+
+  shared_examples_for "sends request with JSON-encoded body" do
+    context "with params" do
+      let(:params) do
+        { key1: "value1", key2: "value2" }
+      end
+
+      it "sends request with JSON-encoded body" do
+        should be_a Qiita::Response
+      end
+    end
+  end
+
+  shared_examples_for "sends request with URL query" do
+    context "with params" do
+      let(:params) do
+        { key1: "value1", key2: "value2" }
+      end
+
+      let(:requested_url) do
+        super() + "?key1=value1&key2=value2"
+      end
+
+      it "sends request with URL query" do
+        should be_a Qiita::Response
+      end
+    end
+  end
+
+  describe ".new" do
+    subject do
+      described_class.new(*arguments)
+    end
+
+    let(:arguments) do
+      [options]
+    end
+
+    let(:options) do
+      {}
+    end
+
+    shared_examples_for "returns a Qiita::Client" do
+      it "returns a Qiita::Client" do
+        should be_a described_class
+      end
+    end
+
+    context "without any arguments" do
+      let(:arguments) do
+        []
+      end
+      include_examples "returns a Qiita::Client"
+    end
+
+    context "with :access_token option" do
+      let(:options) do
+        { access_token: "dummy" }
+      end
+      include_examples "returns a Qiita::Client"
+    end
+
+    context "with :host option" do
+      let(:options) do
+        { host: "dummy" }
+      end
+      include_examples "returns a Qiita::Client"
+    end
+  end
+
+  describe "#get" do
+    before do
+      stub_api_request
+    end
+
+    subject do
+      client.get(*arguments)
+    end
+
+    let(:request_method) do
+      :get
+    end
+
+    include_examples "valid condition"
+    include_examples "sends request with URL query"
+
+    context "without headers" do
+      let(:arguments) do
+        [path, params]
+      end
+      include_examples "returns a Qiita::Response"
+    end
+
+    context "without params nor headers" do
+      let(:arguments) do
+        [path]
+      end
+      include_examples "returns a Qiita::Response"
+    end
+
+    context "with a Qiita::Client created with :host option" do
+      before do
+        options[:host] = host
+      end
+
+      let(:host) do
+        "example.com"
+      end
+
+      let(:requested_host) do
+        host
+      end
+
+      it "sends request to configured host" do
+        should be_a Qiita::Response
+      end
+    end
+
+    context "with a Qiita::Client created with :access_token option" do
+      before do
+        options[:access_token] = access_token
+      end
+
+      let(:access_token) do
+        "dummy-access-token"
+      end
+
+      let(:requested_headers) do
+        super().merge("Authorization" => "Bearer #{access_token}")
+      end
+
+      it "sends request with configured access token" do
+        should be_a Qiita::Response
+      end
+    end
+
+    context "with headers" do
+      let(:headers) do
+        {
+          "KEY1" => "value1",
+          "KEY2" => "value2",
+        }
+      end
+
+      let(:requested_headers) do
+        super().merge(headers)
+      end
+
+      it "sends request with given headers" do
+        should be_a Qiita::Response
+      end
+    end
+
+    context "with params" do
+      let(:params) do
+        { key1: "value1", key2: "value2" }
+      end
+
+      let(:requested_url) do
+        super() + "?key1=value1&key2=value2"
+      end
+
+      it "sends request with URL query, encoded from given params" do
+        should be_a Qiita::Response
+      end
+    end
+  end
+
+  describe "#post" do
+    before do
+      stub_api_request
+    end
+
+    subject do
+      client.post(*arguments)
+    end
+
+    let(:request_method) do
+      :post
+    end
+
+    let(:status_code) do
+      201
+    end
+
+    include_examples "valid condition"
+    include_examples "sends request with JSON-encoded body"
+  end
+
+  describe "#patch" do
+    before do
+      stub_api_request
+    end
+
+    subject do
+      client.patch(*arguments)
+    end
+
+    let(:request_method) do
+      :patch
+    end
+
+    include_examples "valid condition"
+    include_examples "sends request with JSON-encoded body"
+  end
+
+  describe "#put" do
+    before do
+      stub_api_request
+    end
+
+    subject do
+      client.put(*arguments)
+    end
+
+    let(:request_method) do
+      :put
+    end
+
+    let(:status_code) do
+      204
+    end
+
+    include_examples "valid condition"
+    include_examples "sends request with JSON-encoded body"
+  end
+
+  describe "#delete" do
+    before do
+      stub_api_request
+    end
+
+    subject do
+      client.delete(*arguments)
+    end
+
+    let(:request_method) do
+      :delete
+    end
+
+    let(:status_code) do
+      204
+    end
+
+    include_examples "valid condition"
+    include_examples "sends request with URL query"
+  end
+end