kiita 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=d

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3-p194@kiita --create

data/.simplecov

@@ -0,0 +1,3 @@
+SimpleCov.start do
+  add_filter "spec/"
+end

data/.travis.yml

@@ -0,0 +1,5 @@
+script: "bundle exec rspec spec/"
+
+rvm:
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kiita.gemspec
+gemspec
+
+gem 'pry'
+gem 'simplecov'

data/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Yuki Nishijima
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+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.

data/README.md

@@ -0,0 +1,129 @@
+# Kiita
+
+Yet Another Qiita API Wrapper.
+
+[![Build Status](https://secure.travis-ci.org/yuki24/kiita.png)](http://travis-ci.org/yuki24/kiita) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/yuki24/kiita)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kiita'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install kiita
+```
+
+# Usage
+
+## Public APIs
+
+### See rate_limit
+
+```ruby
+rate = Kiita::API.rate_limit
+
+rate["remaning"] # => 148
+rate["limit"]    # => 150
+```
+
+### Get an authentication token
+
+```ruby
+auth = Kiita::API.authenticate("user", "password")
+
+auth["url_name"] # => "user"
+auth["token"]    # => "a875scr65rc86a5s��"
+```
+
+### Get a user's information
+
+```ruby
+user = Kiita::API.user("yuki24")
+
+user.class       # => Kiita:;User
+user.name        # => "Yuki Nishijima"
+user.location    # => "Tokyo, Japan"
+user.description # => "I'm a guy."
+```
+
+### Get a user's posts
+
+```ruby
+posts = Kiita::API.user("yuki24").posts
+post = posts.first
+
+post.class # => Kiita::Post
+post.title # => "I'm a title!"
+post.body  # => "I'm a body!"
+```
+
+## APIs that require authentication
+
+First create an object with the token like this:
+
+```ruby
+user = Kiita::API.new(token: "a875scr65rc86a5s")
+```
+
+then you can do the followings.
+
+### Get my information
+
+```ruby
+user.me # => your information
+```
+
+### Get your stocks
+
+```ruby
+user.stocks # collection of the posts that you stocked before.
+```
+
+### Stock a post
+
+```ruby
+user.stock!("e6654a3b258b7c6b7d1") # => true if success
+```
+
+### Unstock a post
+
+```ruby
+user.unstock!("e6654a3b258b7c6b7d1") # => true if success
+```
+
+## Configuration
+
+Kiita currently doesn't allow to configure anything. But in the near future, it will support some confgurations like timeout and keep alive.
+
+## Support
+
+* Ruby 1.9.2, 1.9.3
+
+Note that *Ruby 1.8.7 is NOT supported*.
+
+## TODO
+
+1. Implementation of the APIs that use POST, PUT or DELETE
+2. Writing up rdoc as well as this README
+
+## 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
+
+## Copyright
+Copyright (c) 2012 Yuki Nishijima. See LICENSE.md for further details.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/kiita.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kiita/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "kiita"
+  gem.version       = Kiita::VERSION
+  gem.authors       = ["Yuki Nishijima"]
+  gem.email         = ["mail@yukinishijima.net"]
+  gem.description   = %q{Kiita is yet another Qiita API wrapper.}
+  gem.summary       = %q{Yet Another Qiita API Wrapper}
+  gem.homepage      = "https://github.com/yuki24/kiita"
+
+  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"]
+
+  gem.add_dependency 'httpclient'
+  gem.add_dependency 'oj'
+  gem.add_dependency 'activesupport', '>= 3.0.0'
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'vcr'
+  gem.add_development_dependency 'webmock'
+end

data/lib/kiita.rb

@@ -0,0 +1,26 @@
+require 'active_support/all'
+require 'httpclient'
+require 'oj'
+
+require 'kiita/errors'
+require 'kiita/api'
+require 'kiita/version'
+
+module Kiita
+
+  # Default API endpoint
+  mattr_accessor :api_endpoint
+  @@api_endpoint = "https://qiita.com/api/v1"
+
+  # Connect timeout in sec.
+  mattr_accessor :timeout
+  @@timeout = 30
+
+  # Reuse the same connection within this timeout in sec. from last used.
+  mattr_accessor :keep_alive
+  @@keep_alive = 0
+
+  def self.connection
+    @connection ||= HTTPClient.new
+  end
+end

data/lib/kiita/api.rb

@@ -0,0 +1,118 @@
+require 'kiita/model'
+require 'kiita/user'
+require 'kiita/tag'
+require 'kiita/post'
+
+module Kiita
+  class API
+    extend Kiita::Errors::HandlerMethods
+    attr_reader :token
+
+    def initialize(options = {})
+      @token = options[:token]
+    end
+
+    def me
+      Kiita::User.new(get("/user"))
+    end
+
+    def search(keyword, options = {})
+      get("/search", options.merge!(q: keyword)).map{|post| Kiita::Post.new(post) }
+    end
+
+    def stocks(options = {})
+      get("/stocks", options).map{|post| Kiita::Post.new(post) }
+    end
+
+    def stock!(uuid)
+      (response = put("/items/#{uuid}/stock")).nil? ? true : response
+    end
+
+    def unstock!(uuid)
+      (response = delete("/items/#{uuid}/stock")).nil? ? true : response
+    end
+
+    def self.rate_limit
+      get("/rate_limit")
+    end
+
+    def self.authenticate(url_name, password)
+      post("/auth", url_name: url_name, password: password)
+    end
+
+    def self.user(url_name)
+      Kiita::User.lazy_load(url_name)
+    end
+
+    def self.item(uuid)
+      Kiita::Post.lazy_load(uuid)
+    end
+
+    def self.items(options = {})
+      Kiita::Post.all(options)
+    end
+
+    def self.search(keyword, options = {})
+      Kiita::Post.search(keyword, options)
+    end
+
+    def self.tag(url_name)
+      Kiita::Tag.new(url_name)
+    end
+
+    def self.tags(options = {})
+      Kiita::Tag.all(options)
+    end
+
+    def get(path, options = {})
+      self.class.get(path_with_credentials(path), options.merge!(token: token))
+    end
+
+    def post(path, options = {})
+      self.class.post(path_with_credentials(path), options)
+    end
+
+    def put(path, options = {})
+      self.class.put(path_with_credentials(path), options)
+    end
+
+    def delete(path, options = {})
+      self.class.delete(path_with_credentials(path), options)
+    end
+
+    def self.get(path, options = {})
+      handle_response(connection.get(qiita_url(path), options))
+    end
+
+    def self.post(path, options = {})
+      handle_response(connection.post(qiita_url(path), options))
+    end
+
+    def self.put(path, options = {})
+      handle_response(connection.put(qiita_url(path), options))
+    end
+
+    def self.delete(path, options = {})
+      handle_response(connection.delete(qiita_url(path), options))
+    end
+
+    private
+
+    def path_with_credentials(path)
+      token ? (path + "?token=#{token}") : path
+    end
+
+    def self.connection
+      Kiita.connection
+    end
+
+    def self.qiita_url(path)
+      Kiita.api_endpoint + path
+    end
+
+    def self.handle_response(response)
+      on_complete(response)
+      Oj.load(response.body.empty? ? "null" : response.body)
+    end
+  end
+end

data/lib/kiita/errors.rb

@@ -0,0 +1,43 @@
+module Kiita
+  class Error < StandardError; end
+  class BadRequest < Error; end          # 400
+  class Unauthorized < Error; end        # 401
+  class Forbidden < Error; end           # 403
+  class NotFound < Error; end            # 404
+  class InternalServerError < Error; end # 500
+
+  module Errors
+    module HandlerMethods
+      def on_complete(response)
+        case response.status
+        when 400
+          raise Kiita::BadRequest, error_message(response)
+        when 401
+          raise Kiita::Unauthorized, error_message(response)
+        when 403
+          raise Kiita::Forbidden, error_message(response)
+        when 404
+          raise Kiita::NotFound, error_message(response)
+        # when 406
+        #   raise Kiita::NotAcceptable, error_message(response)
+        # when 422
+        #   raise Kiita::UnprocessableEntity, error_message(response)
+        when 500
+          raise Kiita::InternalServerError, error_message(response)
+        # when 503
+        #   raise Kiita::ServiceUnavailable, error_message(response)
+        end
+      end
+      private :on_complete
+
+      def error_message(response)
+        if response.body.empty?
+          "#{response.http_header.request_method} #{response.http_header.request_uri.to_s}: #{response.status}"
+        else
+          Oj.load(response.body)["error"]
+        end
+      end
+      private :error_message
+    end
+  end
+end

data/lib/kiita/model.rb

@@ -0,0 +1,33 @@
+module Kiita::Model
+  extend ActiveSupport::Concern
+
+  def initialize(options = {})
+    set_raw_attributes(options.slice(*attributes)) if options.slice(*attributes).present?
+  end
+
+  def raw_attributes
+    @raw_attributes ||= set_raw_attributes(raw_data)
+  end
+
+  protected
+
+  def set_raw_attributes(attrs)
+    @raw_attributes = attrs.tap do |raw_data|
+      raw_data.each{|key, value| instance_eval("@#{key}= value") }
+    end
+  end
+
+  module ClassMethods
+    def define_attributes(attrs, getter_method)
+      attrs.each do |attribute_name|
+        class_eval <<-RUBY
+          def #{attribute_name}
+            @#{attribute_name} ||= raw_attributes["#{attribute_name}"]
+          end
+        RUBY
+      end
+
+      define_method(:raw_data, &getter_method)
+    end
+  end
+end