iknow 0.1.0 → 0.1.1

data/ChangeLog

@@ -9,4 +9,13 @@
 == 0.0.4
 
 * add new API calls
-* add new attributes
+* add new attributes
+
+== 0.1.0
+
+* add Iknow::Auth (supports basic_auth and oauth)
+* add List#create, List#delete, List#add_item, List#delete_item
+
+== 0.1.1
+
+* remove Mechanize

data/Rakefile

@@ -62,7 +62,6 @@ spec = Gem::Specification.new do |s|
 
 	s.add_dependency('rails', '>=2.1.0')
 	s.add_dependency('json')
-	s.add_dependency('mechanize')
 	s.add_dependency('oauth', '>=0.2.7')
 	s.required_ruby_version = '>= 1.8.6'
 
@@ -114,6 +113,7 @@ task :rubyforge => [:rdoc, :package] do
 	Rake::RubyForgePublisher.new(RUBYFORGE_PROJECT, 'nov').upload
 end
 
+# rake release VERSION=x.y.z
 desc 'Package and upload the release to rubyforge.'
 task :release => [:clean, :package] do |t|
 	v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"

data/examples/pure_ruby.rb

@@ -70,8 +70,8 @@ end
 ########################
 
 iknow_auth = case
-  when OAUTH_ACCESS_TOKEN != ''
-    if Iknow::Config.oauth_consumer_key == '' or Iknow::Config.oauth_consumer_secret == ''
+  when !OAUTH_ACCESS_TOKEN.empty?
+    if Iknow::Config.oauth_consumer_key.empty? or Iknow::Config.oauth_consumer_secret.empty?
       raise ArgumentError.new("oauth_consumer_key and oauth_consumer_secret are required")
     end
     Iknow::Auth.new(:token => OAUTH_ACCESS_TOKEN, :secret => OAUTH_ACCESS_TOKEN_SECRET)
@@ -83,6 +83,8 @@ iknow_auth = case
 unless iknow_auth
   puts "Skip calls which require authentication"
   exit
+else
+  puts "Authenticate Mode :: #{iknow_auth.mode}"
 end
 
 ## List API

data/lib/iknow/core/auth.rb

@@ -1,14 +1,21 @@
 require 'oauth/consumer'
-require 'mechanize'
 
 class Iknow::Auth
   attr_accessor :mode, :auth_token
 
+  class Basic
+    attr_reader :username, :password
+
+    def initialize(username, password)
+      @username = username
+      @password = password
+    end
+  end
+
   def initialize(options = {})
     if options[:username] && options[:password]
       @mode = :basic_auth
-      @auth_token = WWW::Mechanize.new
-      @auth_token.auth(options[:username], options[:password])
+      @auth_token = Basic.new(options[:username], options[:password])
     elsif options[:token] && options[:secret]
       @mode = :oauth
       @auth_token = OAuth::AccessToken.new(Iknow::Auth.consumer, options[:token], options[:secret])
@@ -21,9 +28,12 @@ class Iknow::Auth
     @@consumer ||= OAuth::Consumer.new(
       Iknow::Config.oauth_consumer_key,
       Iknow::Config.oauth_consumer_secret,
+      :http_method   => :get,
+      :schema        => :query_string,
       :site          => Iknow::Config.iknow_api_base_url,
       :authorize_url => "#{Iknow::Config.iknow_base_url}/oauth/authorize"
     )
   end
 
+  alias_method :account, :auth_token
 end

data/lib/iknow/core/config.rb

@@ -2,7 +2,7 @@ require 'singleton'
 
 class Iknow::Config
   include Singleton
-  attr_accessor :protocol, :host, :port, :api_protocol, :api_host, :api_port,
+  attr_accessor :protocol, :host, :port, :api_protocol, :api_host, :api_port, :timeout,
                 :api_key, :oauth_consumer_key, :oauth_consumer_secret,
                 :user_agent, :application_name, :application_version, :application_url, :source
 
@@ -14,14 +14,14 @@ class Iknow::Config
       :api_protocol          => 'http',
       :api_host              => 'api.iknow.co.jp',
       :api_port              => 80,
+      :timeout               => 5,
       :api_key               => '',
       :oauth_consumer_key    => '',
       :oauth_consumer_secret => '',
       :user_agent            => 'default',
-      :application_name      => 'A rubygem for iKnow! API',
+      :application_name      => 'iKnow! Gem',
       :application_version   => Iknow::Version.to_version,
-      :application_url       => 'http://github.com/nov/iknow',
-      :source                => 'iknow'
+      :application_url       => 'http://github.com/nov/iknow'
     }.each do |key, value| conf.send("#{key}=", value) end
     yield conf if block_given?
     conf

data/lib/iknow/core/version.rb

@@ -1,7 +1,7 @@
 module Iknow::Version
   MAJOR = 0
   MINOR = 1
-  REVISION = 0
+  REVISION = 1
   class << self
     def to_version
       "#{MAJOR}.#{MINOR}.#{REVISION}"

data/lib/iknow/model/base.rb

@@ -4,26 +4,23 @@ class Iknow::Base
 
   def attributes; self.class.attributes  end
 
-  def self.deserialize(response, params = {})
-    return nil if response.nil? or
-                 (response.is_a?(Hash) and
-                 !response['error'].nil? and
-                  response['error']['code'].to_i == 404)
+  def self.deserialize(hash, params = {})
+    return nil if hash.nil?
 
     klass = params[:as] ? params[:as] : self
-    if response.is_a?(Array)
-      response.inject([]) { |results, hash|
+    if hash.is_a?(Array)
+      hash.inject([]) { |results, hash|
         hash.symbolize_keys!
         results << klass.new(hash)
       }
     else
-      response.symbolize_keys!
-      klass.new(response)
+      hash.symbolize_keys!
+      klass.new(hash)
     end
   end
 
-  def deserialize(response, params = {})
-    self.class.deserialize(response, params)
+  def deserialize(hash, params = {})
+    self.class.deserialize(hash, params)
   end
 
 end

data/lib/iknow/model/item.rb

@@ -1,5 +1,5 @@
 class Iknow::Item < Iknow::Base
-  ATTRIBUTES = [:sentences, :response, :cue, :id]
+  ATTRIBUTES = [:sentences, :hash, :cue, :id]
   attr_reader *ATTRIBUTES
 
   class Response
@@ -28,32 +28,32 @@ class Iknow::Item < Iknow::Base
   end
 
   def self.recent(params = {})
-    response = Iknow::RestClient::Item.recent(params)
-    self.deserialize(response) || []
+    hash = Iknow::RestClient::Item.recent(params)
+    self.deserialize(hash) || []
   end
 
   def self.find(item_id, params = {})
     params[:id] = item_id
-    response = Iknow::RestClient::Item.find(params)
-    self.deserialize(response)
+    hash = Iknow::RestClient::Item.find(params)
+    self.deserialize(hash)
   end
 
   def self.matching(keyword, params = {})
     params[:keyword] = keyword
-    response = Iknow::RestClient::Item.matching(params)
-    self.deserialize(response) || []
+    hash = Iknow::RestClient::Item.matching(params)
+    self.deserialize(hash) || []
   end
 
   def self.extract(text, params = {})
     params[:text] = text
-    response = Iknow::RestClient::Item.extract(params)
-    self.deserialize(response) || []
+    hash = Iknow::RestClient::Item.extract(params)
+    self.deserialize(hash) || []
   end
 
   def initialize(params = {})
     @id        = params[:id].to_i
     @cue       = self.deserialize(params[:cue], :as => Iknow::Item::Cue)
-    @responses = self.deserialize(params[:responses], :as => Iknow::Item::Response)
+    @hashs = self.deserialize(params[:hashs], :as => Iknow::Item::Response)
     @sentences = self.deserialize(params[:sentences], :as => Iknow::Sentence)
   end
 

data/lib/iknow/model/list.rb

@@ -35,20 +35,20 @@ class Iknow::List < Iknow::Base
   end
 
   def self.recent(params = {})
-    response = Iknow::RestClient::List.recent(params)
-    self.deserialize(response) || []
+    hash = Iknow::RestClient::List.recent(params)
+    self.deserialize(hash) || []
   end
 
   def self.find(list_id, params = {})
     params[:id] = list_id
-    response = Iknow::RestClient::List.find(params)
-    self.deserialize(response)
+    hash = Iknow::RestClient::List.find(params)
+    self.deserialize(hash)
   end
 
   def self.matching(keyword, params = {})
     params[:keyword] = keyword
-    response = Iknow::RestClient::List.matching(params)
-    self.deserialize(response) || []
+    hash = Iknow::RestClient::List.matching(params)
+    self.deserialize(hash) || []
   end
 
   def self.create(iknow_auth, params = {})
@@ -88,26 +88,26 @@ class Iknow::List < Iknow::Base
   end
 
   def items(params = {})
-    response = Iknow::RestClient::List.items(params.merge(:id => self.id))
-    self.deserialize(response, :as => Iknow::Item) || []
+    hash = Iknow::RestClient::List.items(params.merge(:id => self.id))
+    self.deserialize(hash, :as => Iknow::Item) || []
   end
 
   def sentences(params = {})
-    response = Iknow::RestClient::List.sentences(params.merge(:id => self.id))
-    self.deserialize(response, :as => Iknow::Sentence) || []
+    hash = Iknow::RestClient::List.sentences(params.merge(:id => self.id))
+    self.deserialize(hash, :as => Iknow::Sentence) || []
   end
 
   def save(iknow_auth)
     begin
       list_id = Iknow::RestClient::List.create(iknow_auth, self.to_post_data)
-    rescue
-      return false
+    # rescue
+    #   return false
     end
     Iknow::List.find(list_id)
   end
 
   def delete(iknow_auth)
-    Iknow::RestClient::List.delete(iknow_auth, :id => self.id)
+    Iknow::RestClient::List.delete(iknow_auth, {:id => self.id})
   end
   alias_method :destroy, :delete
 

data/lib/iknow/model/sentence.rb

@@ -5,20 +5,20 @@ class Iknow::Sentence < Iknow::Base
   attr_reader *(ATTRIBUTES - WRITABLE_ATTRIBUTES)
 
   def self.recent(params = {})
-    response = Iknow::RestClient::Sentence.recent(params)
-    self.deserialize(response) || []
+    hash = Iknow::RestClient::Sentence.recent(params)
+    self.deserialize(hash) || []
   end
 
   def self.find(sentence_id, params = {})
     params[:id] = sentence_id
-    response = Iknow::RestClient::Sentence.find(params)
-    self.deserialize(response)
+    hash = Iknow::RestClient::Sentence.find(params)
+    self.deserialize(hash)
   end
 
   def self.matching(keyword, params = {})
     params[:keyword] = keyword
-    response = Iknow::RestClient::Sentence.matching(params)
-    self.deserialize(response) || []
+    hash = Iknow::RestClient::Sentence.matching(params)
+    self.deserialize(hash) || []
   end
 
   def initialize(params = {})

data/lib/iknow/model/user.rb

@@ -63,14 +63,14 @@ class Iknow::User < Iknow::Base
 
   def self.find(username, params = {})
     params[:username] = username
-    response = Iknow::RestClient::User.find(params)
-    self.deserialize(response)
+    hash = Iknow::RestClient::User.find(params)
+    self.deserialize(hash)
   end
 
   def self.matching(keyword, params = {})
     params[:keyword] = keyword
-    response = Iknow::RestClient::User.matching(params)
-    self.deserialize(response) || []
+    hash = Iknow::RestClient::User.matching(params)
+    self.deserialize(hash) || []
   end
 
   def initialize(params)
@@ -79,24 +79,24 @@ class Iknow::User < Iknow::Base
   end
 
   def items(params = {})
-    response = Iknow::RestClient::User.items(params.merge(:username => self.username))
-    self.deserialize(response, :as => Iknow::Item) || []
+    hash = Iknow::RestClient::User.items(params.merge(:username => self.username))
+    self.deserialize(hash, :as => Iknow::Item) || []
   end
 
   def lists(params = {})
-    response = Iknow::RestClient::User.lists(params.merge(:username => self.username))
-    self.deserialize(response, :as => Iknow::List) || []
+    hash = Iknow::RestClient::User.lists(params.merge(:username => self.username))
+    self.deserialize(hash, :as => Iknow::List) || []
   end
 
   def friends(params = {})
-    response = Iknow::RestClient::User.friends(params.merge(:username => self.username))
-    self.deserialize(response) || []
+    hash = Iknow::RestClient::User.friends(params.merge(:username => self.username))
+    self.deserialize(hash) || []
   end
 
   def study(params = {})
     params[:application] ||= 'iknow'
-    response = Iknow::RestClient::User.study_results(params.merge(:username => self.username))
-    self.deserialize(response, :as => Iknow::User::Study)
+    hash = Iknow::RestClient::User.study_results(params.merge(:username => self.username))
+    self.deserialize(hash, :as => Iknow::User::Study)
   end
 
 end

data/lib/iknow/rest_client/base.rb

@@ -1,3 +1,5 @@
+require 'timeout'
+
 class Iknow::RestClient::Base
 
   class RESTError < Exception
@@ -24,13 +26,13 @@ class Iknow::RestClient::Base
     case self.http_method(action)
     when :get
       path, params = path_with_params(self.path(action), args[0])
-      http_get_request(path, params)
+      http_get(path, params)
     when :post
       path, params = path_with_params(self.path(action), args[1])
-      http_post_request(iknow_auth(args[0]), path, params)
+      http_post(iknow_auth(args[0]), path, params)
     when :delete
       path, params = path_with_params(self.path(action), args[1])
-      http_delete_request(iknow_auth(args[0]), path, params)
+      http_delete(iknow_auth(args[0]), path, params)
     end
   end
 
@@ -54,19 +56,54 @@ class Iknow::RestClient::Base
     raise RESTError.new(:code => response.code, :message => response.message)
   end
 
-  def self.handle_rest_response(response)
+  def self.handle_rest_response(response, format)
     raise_rest_error(response) unless response.is_a?(Net::HTTPSuccess)
+    case format
+    when :json
+      handle_json_response(response.body)
+    when :nothing
+      # success => nothing / failure => json error
+      handle_json_response(response.body) rescue :success
+    else
+      response.body
+    end
+  end
+
+  def self.handle_json_response(json_response)
+    hash = JSON.parse(json_response)
+    unless (hash['error'].nil? rescue :success) # success response may be Array, not Hash.
+      if hash['error']['code'].to_i == 404
+        return nil
+      else
+        raise RESTError.new(:code => hash['error']['code'], :message => hash['error']['message'])
+      end
+    end
+    hash
   end
 
   def self.http_header
     @@http_header ||= {
-      'User-Agent'             => "iKnow! API v#{Iknow::Version.to_version} [#{self.config.user_agent}]",
-      'Accept'                 => 'text/x-json',
-      'X-iKnow-Client'         => self.config.application_name,
-      'X-iKnow-Client-Version' => self.config.application_version,
-      'X-iKnow-Client-URL'     => self.config.application_url,
+      'User-Agent' => "#{self.config.application_name} v#{Iknow::Version.to_version} [#{self.config.user_agent}]",
+      'Accept'     => 'text/x-json',
+      'X-iKnow-Gem-Client'         => self.config.application_name,
+      'X-iKnow-Gem-Client-Version' => self.config.application_version,
+      'X-iKnow-Gem-Client-URL'     => self.config.application_url,
     }
-    @@http_header
+  end
+
+  def self.http_connect
+    http = Net::HTTP.new(self.config.api_host, self.config.api_port)
+    http.start do |conn|
+      request, format = yield
+      begin
+        timeout(self.config.timeout) do
+          response = conn.request(request)
+          handle_rest_response(response, format)
+        end
+      rescue
+        raise RESTError.new(:code => 408, :message => "iKnow! Gem Timeout (#{self.config.timeout} [sec])")
+      end
+    end
   end
 
   def self.path_with_params(path, params = {})
@@ -82,50 +119,47 @@ class Iknow::RestClient::Base
     return path_with_params, params
   end
 
-  def self.http_get_request(path, params = {})
-    params.merge!(:api_key => self.config.api_key) unless self.config.api_key == ''
-    path = (params.size > 0) ? "#{path}?#{params.to_http_str}" : path
-    http = Net::HTTP.new(self.config.api_host, self.config.api_port)
-    response = http.get(path, http_header)
-    handle_rest_response(response)
-    JSON.parse(response.body)
+  def self.http_get(path, params = {})
+    http_connect do
+      params.merge!(:api_key => self.config.api_key) unless self.config.api_key == ''
+      path = (params.size > 0) ? "#{path}?#{params.to_http_str}" : path
+      get_req = Net::HTTP::Get.new(path, http_header)
+      [get_req, :json]
+    end
   end
 
-  def self.http_post_request(iknow_auth, path, params = {})
+  def self.http_post(iknow_auth, path, params = {})
     self.api_key_required
     params.merge!(:api_key => self.config.api_key)
     case iknow_auth.mode
-    when :oauth 
+    when :oauth
       response = iknow_auth.auth_token.post(path, params, http_header)
-      handle_rest_response(response)
-      response.body
+      handle_rest_response(response, :text)
     when :basic_auth
-      begin
-        response = iknow_auth.auth_token.post(self.config.iknow_api_base_url + path, params)
-        response.body
-      rescue WWW::Mechanize::ResponseCodeError => e
-        raise RESTError.new(:code => e.response_code, :message => e.to_s)
+      http_connect do
+        post_req = Net::HTTP::Post.new(path, http_header)
+        post_req.body = params.to_http_str
+        post_req.basic_auth(iknow_auth.account.username, iknow_auth.account.password)
+        [post_req, :text]
       end
     end
   end
 
-  def self.http_delete_request(iknow_auth, path, params = {})
+  def self.http_delete(iknow_auth, path, params = {})
     self.api_key_required
     params.merge!(:api_key => self.config.api_key)
     case iknow_auth.mode
     when :oauth
       response = iknow_auth.auth_token.delete(path, params.stringfy_keys!.stringfy_values!)
-      handle_rest_response(response)
+      handle_rest_response(response, :nothing)
     when :basic_auth
-      begin
-        iknow_auth.auth_token.delete(self.config.iknow_api_base_url + path, params.stringfy_keys!)
-      rescue WWW::Mechanize::ResponseCodeError => e
-        raise RESTError.new(:code => e.response_code, :message => e.to_s)
+      http_connect do
+        delete_req = Net::HTTP::Post.new(path, http_header)
+        delete_req.body = params.merge(:_method => 'DELETE').to_http_str
+        delete_req.basic_auth(iknow_auth.account.username, iknow_auth.account.password)
+        [delete_req, :nothing]
       end
     end
   end
 
-  private_class_method :raise_rest_error, :handle_rest_response, :http_header,
-                       :path_with_params, :http_get_request, :http_post_request, :http_delete_request
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: iknow
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - nov
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-19 00:00:00 +09:00
+date: 2008-12-20 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,16 +32,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-- !ruby/object:Gem::Dependency 
-  name: mechanize
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
 - !ruby/object:Gem::Dependency 
   name: oauth
   type: :runtime