nov-iknow 0.0.1

data/ChangeLog

@@ -0,0 +1,4 @@
+== 0.0.1 / 2008-10-13
+
+* initial release
+

data/README

@@ -0,0 +1,56 @@
+
+= iknow
+
+A rubygem for iKnow! APIs
+by nov <nmatake@cerego.co.jp>
+
+== Description
+
+## Set API Key (in environment.rb etc.)
+Iknow::Config.init do |conf|
+  conf.api_key  = YOUR_API_KEY
+end
+
+## User API
+@user = Iknow::User.find('matake')
+@user.items
+@user.lists
+@user.study_results
+@matchied_users = Iknow::User.matching('matake')
+
+## List API
+@recent_lists = Iknow::List.recent
+@list  = @recent_lists.first
+@list.items
+@list.sentences
+
+## Item API
+@recent_items = Iknow::Item.recent
+@matchied_items = Iknow::Item.matching('record')
+
+## Sentence API
+@recent_sentences = Iknow::Sentence.recent
+@matchied_sentences = Iknow::Sentence.matching('record')
+
+== Installation
+
+=== Archive Installation
+
+	rake install
+
+=== Gem Installation
+
+	gem install iknow
+
+
+== Features/Problems
+
+
+== Synopsis
+
+
+== Copyright
+
+Author::    nov <nmatake@cerego.co.jp>
+Copyright:: Copyright (c) 2008 nov
+License::   MIT License

data/Rakefile

@@ -0,0 +1,146 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/contrib/sshpublisher'
+require 'fileutils'
+include FileUtils
+
+NAME              = "iknow"
+AUTHOR            = "nov"
+EMAIL             = "developer@iknow.co.jp"
+DESCRIPTION       = "A rubygem for iKnow! APIs"
+RUBYFORGE_PROJECT = "iknow"
+HOMEPATH          = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+BIN_FILES         = %w(  )
+
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/lib"
+require 'lib/iknow'
+VERS              = Iknow::Version.to_version
+REV = File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = [
+	'--title', "#{NAME} documentation",
+	"--charset", "utf-8",
+	"--opname", "index.html",
+	"--line-numbers",
+	"--main", "README",
+	"--inline-source",
+]
+
+task :default => [:test]
+task :package => [:clean]
+
+Rake::TestTask.new("test") do |t|
+	t.libs   << "test"
+	t.pattern = "test/**/*_test.rb"
+	t.verbose = true
+end
+
+spec = Gem::Specification.new do |s|
+	s.name              = NAME
+	s.version           = VERS
+	s.platform          = Gem::Platform::RUBY
+	s.has_rdoc          = true
+	s.extra_rdoc_files  = ["README", "ChangeLog"]
+	s.rdoc_options     += RDOC_OPTS + ['--exclude', '^(examples|extras)/']
+	s.summary           = DESCRIPTION
+	s.description       = DESCRIPTION
+	s.author            = AUTHOR
+	s.email             = EMAIL
+	s.homepage          = HOMEPATH
+	s.executables       = BIN_FILES
+	s.rubyforge_project = RUBYFORGE_PROJECT
+	s.bindir            = "bin"
+	s.require_path      = "lib"
+	#s.autorequire       = ""
+	s.test_files        = Dir["test/*_test.rb"]
+
+	#s.add_dependency('activesupport', '>=1.3.1')
+	s.add_dependency('json')
+	#s.required_ruby_version = '>= 1.8.2'
+
+	s.files = %w(README ChangeLog Rakefile) +
+		Dir.glob("{bin,doc,test,lib,templates,generator,extras,website,script}/**/*") + 
+		Dir.glob("ext/**/*.{h,c,rb}") +
+		Dir.glob("examples/**/*.rb") +
+		Dir.glob("tools/*.rb") +
+		Dir.glob("rails/*.rb")
+
+	s.extensions = FileList["ext/**/extconf.rb"].to_a
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+	p.need_tar = true
+	p.gem_spec = spec
+end
+
+task :install do
+	name = "#{NAME}-#{VERS}.gem"
+	sh %{rake package}
+	sh %{sudo gem install pkg/#{name}}
+end
+
+task :uninstall => [:clean] do
+	sh %{sudo gem uninstall #{NAME}}
+end
+
+
+Rake::RDocTask.new do |rdoc|
+	rdoc.rdoc_dir = 'html'
+	rdoc.options += RDOC_OPTS
+	rdoc.template = "resh"
+	#rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+	if ENV['DOC_FILES']
+		rdoc.rdoc_files.include(ENV['DOC_FILES'].split(/,\s*/))
+	else
+		rdoc.rdoc_files.include('README', 'ChangeLog')
+		rdoc.rdoc_files.include('lib/**/*.rb')
+		rdoc.rdoc_files.include('ext/**/*.c')
+	end
+end
+
+desc "Publish to RubyForge"
+task :rubyforge => [:rdoc, :package] do
+	require 'rubyforge'
+	Rake::RubyForgePublisher.new(RUBYFORGE_PROJECT, 'nov').upload
+end
+
+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"
+	abort "Versions don't match #{v} vs #{VERS}" unless v == VERS
+	pkg = "pkg/#{NAME}-#{VERS}"
+
+	require 'rubyforge'
+	rf = RubyForge.new.configure
+	puts "Logging in"
+	rf.login
+
+	c = rf.userconfig
+#	c["release_notes"] = description if description
+#	c["release_changes"] = changes if changes
+	c["preformatted"] = true
+
+	files = [
+		"#{pkg}.tgz",
+		"#{pkg}.gem"
+	].compact
+
+	puts "Releasing #{NAME} v. #{VERS}"
+	rf.add_release RUBYFORGE_PROJECT, NAME, VERS, *files
+end
+
+desc 'Show information about the gem.'
+task :debug_gem do
+	puts spec.to_ruby
+end
+
+desc 'Update gem spec'
+task :gemspec do
+  open("#{NAME}.gemspec", 'w').write spec.to_ruby
+end

data/examples/pure_ruby.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'iknow'
+
+Iknow::Config.init do |conf|
+  conf.api_key = "" # Set your iKnow! API key, here.
+  conf.host    = "api.iknow.co.jp"
+end
+
+please_get_api_key =<<EOS
+This example needs your own iKnow! API key.
+(for only Iknow::Item.extract example)
+
+You can get iKnow! API key at iKnow! Developers.
+iKnow! Developers (http://developer.iknow.co.jp/)
+
+Thanks!
+EOS
+
+raise ArgumentError.new(please_get_api_key) if Iknow::Config.instance.api_key == ''
+
+## User API
+@user = Iknow::User.find('matake')
+@user.items
+@user.lists
+@user.friends
+@user.study_results
+@matchied_users = Iknow::User.matching('matake')
+
+# ## List API
+@recent_lists = Iknow::List.recent
+@matchied_lists = Iknow::List.matching("遺伝的アルゴリズム")
+@ga_list.first.items
+@ga_list.first.sentences
+
+# ## Item API
+@recent_items = Iknow::Item.recent
+@matchied_items = Iknow::Item.matching('record')
+@items = Iknow::Item.extract("sometimes, often, electrical")
+@items.first.sentences
+
+## Sentence API
+@recent_sentences = Iknow::Sentence.recent
+@matchied_sentences = Iknow::Sentence.matching('record')

data/lib/ext/hash.rb

@@ -0,0 +1,10 @@
+class Hash
+  def to_http_str
+    result = ''
+    return result if self.empty?
+    self.each do |key, val|
+      result << "#{key}=#{URI.encode(val.to_s)}&"
+    end
+    result.chop
+  end
+end

data/lib/iknow/core/config.rb

@@ -0,0 +1,28 @@
+require 'singleton'
+
+class Iknow::Config
+  include Singleton
+  attr_accessor :protocol, :host, :port, :user_agent, :api_key, :application_name, :application_version, :application_url, :source
+
+  def self.init(&block)
+    conf = Iknow::Config.instance
+    { :protocol            => 'http',
+      :host                => 'api.iknow.co.jp',
+      :port                => 80,
+      :user_agent          => 'default',
+      :api_key             => '',
+      :application_name    => 'iKnow! API',
+      :application_version => Iknow::Version.to_version,
+      :application_url     => 'http://github.com/nov/iknow',
+      :source              => 'iknow'
+    }.each do |key, value| conf.send("#{key}=", value) end
+    yield conf if block_given?
+    conf
+  end
+
+  def iknow_base_url
+    port = self.port==80 ? nil : ":#{self.port}"
+    "#{self.protocol}://#{self.host}#{port}"
+  end
+
+end

data/lib/iknow/core/version.rb

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

data/lib/iknow/core.rb

@@ -0,0 +1,2 @@
+require 'iknow/core/version'
+require 'iknow/core/config'

data/lib/iknow/model/base.rb

@@ -0,0 +1,14 @@
+class Iknow::Base
+  # TODO: define self.attributes
+  def self.attributes; self::ATTRIBUTES end
+  def attributes; self.class.attributes  end
+
+  def self.deserialize(response, params = {})
+    klass = params[:as]   ? params[:as] : self
+    response.is_a?(Array) ? response.inject([]) { |results, params| results << klass.new(params) } : klass.new(response)
+  end
+  def deserialize(response, params = {})
+    self.class.deserialize(response, params)
+  end
+
+end

data/lib/iknow/model/item.rb

@@ -0,0 +1,54 @@
+class Iknow::Item < Iknow::Base
+  ATTRIBUTES = [:sentences, :response, :cue, :id]
+  attr_reader *ATTRIBUTES
+
+  class Response
+    ATTRIBUTES = [:text]
+    attr_reader *ATTRIBUTES
+    
+    def initialize(params = {})
+      @text = params['text']
+    end
+  end
+
+  class Cue
+    ATTRIBUTES = [:sound, :part_of_speech, :text]
+    NOT_WRITABLE_ATTRIBUTES = [:text]
+    attr_accessor *(ATTRIBUTES - NOT_WRITABLE_ATTRIBUTES)
+    attr_reader *NOT_WRITABLE_ATTRIBUTES
+    
+    def initialize(params = {})
+      @text  = params['text']
+      @sound = params['sound']
+      @image = params['part_of_speech']
+    end
+  end
+
+  def self.recent(params = {})
+    response = Iknow::RestClient::Item.recent(params)
+    self.deserialize(response)
+  end
+
+  def self.matching(keyword, params = {})
+    params[:keyword] = keyword
+    response = Iknow::RestClient::Item.matching(params)
+    self.deserialize(response)
+  end
+
+  def self.extract(text, params = {})
+    params[:text] = text
+    response = Iknow::RestClient::Item.extract(params)
+    self.deserialize(response)
+  end
+
+  def initialize(params = {})
+    @id = params['id'].to_i
+    @sentences = []
+    params['sentences'].each do |sentence|
+      @sentences << Iknow::Sentence.new(sentence)
+    end
+    @response = params['response'] ? Iknow::Item::Response.new(params['response']) : nil
+    @cue      = Iknow::Item::Cue.new(params['cue'])
+  end
+
+end

data/lib/iknow/model/list.rb

@@ -0,0 +1,84 @@
+class Iknow::List < Iknow::Base
+  ATTRIBUTES = [:list_id, :title, :description, :link,
+                :language, :translation_language, :list_type, :transcript, :embed,
+                :tags, :media_entry, :author, :author_url, :attribution_license_id]
+  NOT_WRITABLE_ATTRIBUTES = [:list_id]
+  attr_accessor *(ATTRIBUTES - NOT_WRITABLE_ATTRIBUTES)
+  attr_reader   *NOT_WRITABLE_ATTRIBUTES
+
+  def self.recent(params = {})
+    response = Iknow::RestClient::List.recent(params)
+    self.deserialize(response)
+  end
+
+  def self.matching(keyword, params = {})
+    params[:keyword] = keyword
+    response = Iknow::RestClient::List.matching(params)
+    self.deserialize(response)
+  end
+
+  def self.create(params = {})
+    new_list = self.new(params)
+    new_list.save!
+  end
+
+  def initialize(params = {})
+    @list_id     = params['id'].to_i if params['id']
+    @title       = params[:title]       || params['title']
+    @description = params[:description] || params['description']
+    @link        = params[:link]        || params['link']
+  end
+
+  def items(params = {})
+    return @items if @items
+
+    response = Iknow::RestClient::List.items(params.merge(:id => self.list_id))
+    @items = self.deserialize(response, :as => Iknow::Item)
+    @items
+  end
+
+  def sentences(params = {})
+    return @sentences if @sentences
+
+    response = Iknow::RestClient::List.sentences(params.merge(:id => self.list_id))
+    @sentences = self.deserialize(response, :as => Iknow::Sentence)
+    @sentences
+  end
+
+  def save!
+    Iknow::RestClient::List.create(self.to_post_data)
+  end
+
+  def save
+    self.save!
+    true
+  rescue
+    false
+  end
+
+  protected
+
+  def to_post_data
+    raise ArgumentError.new("List title is needed.") if self.title.nil? or self.title.empty?
+    
+    post_data = {
+      'list[name]'                 => self.title,
+      'list[description]'          => self.description,
+      'list[language]'             => self.language             || 'en',
+      'list[translation_language]' => self.translation_language || 'ja'
+    }
+    # Object#type should not be used
+    if self.list_type
+      post_data['list[type]'] = self.list_type
+    end
+    # Optional attributes
+    [ :transcript, :embed, :tags, :media_entry,
+      :author, :author_url, :attribution_license_id ].each do |key|
+      if self.send("#{key}")
+        post_data["list[#{key}]"] = self.send("#{key}")
+      end
+    end
+    post_data
+  end
+
+end

data/lib/iknow/model/sentence.rb

@@ -0,0 +1,24 @@
+class Iknow::Sentence < Iknow::Base
+  ATTRIBUTES = [:sound, :image, :text]
+  WRITABLE_ATTRIBUTES = [:sound, :image]
+  attr_accessor *WRITABLE_ATTRIBUTES
+  attr_reader *(ATTRIBUTES - WRITABLE_ATTRIBUTES)
+  
+  def self.recent(params = {})
+    response = Iknow::RestClient::Sentence.recent(params)
+    self.deserialize(response)
+  end
+  
+  def self.matching(keyword, params = {})
+    params[:keyword] = keyword
+    response = Iknow::RestClient::Sentence.matching(params)
+    self.deserialize(response)
+  end
+  
+  def initialize(params = {})
+    @sound = params['sound']
+    @image = params['image']
+    @text  = params['text']
+  end
+  
+end

data/lib/iknow/model/user.rb

@@ -0,0 +1,84 @@
+class Iknow::User < Iknow::Base
+  ATTRIBUTES = [:username, :profile]
+  attr_reader *ATTRIBUTES
+
+  class Profile < Iknow::User
+    ATTRIBUTES = [:name, :gender, :birthday, :description, :blog_url, :profile_url, :foaf_url, :icon_url]
+    attr_reader *ATTRIBUTES
+
+    def initialize(params = {})
+      @name        = params['name']
+      @gender      = params['gender']
+      @birthday    = (Date.parse(params['birthday']) rescue nil)
+      @description = params['description']
+      @blog_url    = params['blog_url']
+      @profile_url = params['profile_url']
+      @foaf_url    = params['foaf_url']
+      @icon_url    = params['icon_url']
+    end
+  end
+
+  class StudyResult < Iknow::User
+    ATTRIBUTES = [:timestamp, :seconds, :totals, :seen, :completed, :date]
+    attr_reader *ATTRIBUTES
+
+    def initialize(params = {})
+      @timestamp = (params['timestamp'].to_i   rescue nil)
+      @seconds   = (params['seconds'].to_i     rescue nil)
+      @totals    = {
+        :seconds   => (params['totals']['seconds'].to_i   rescue nil),
+        :seen      => (params['totals']['seen'].to_i      rescue nil),
+        :completed => (params['totals']['completed'].to_i rescue nil)
+      }
+      @seen      = (params['seen'].to_i        rescue nil)
+      @completed = (params['completed'].to_i   rescue nil)
+      @date      = (Date.parse(params['date']) rescue nil)
+    end
+  end
+
+  def self.find(username)
+    response = Iknow::RestClient::User.find(:username => username)
+    self.deserialize(response)
+  end
+
+  def self.matching(keyword, params = {})
+    params[:keyword] = keyword
+    response = Iknow::RestClient::User.matching(params)
+    self.deserialize(response)
+  end
+
+  def initialize(params)
+    @profile  = Profile.new(params['profile'])
+    @username = params['username']
+  end
+
+  def items(params = {})
+    return @items if @items
+
+    response = Iknow::RestClient::User.items(params.merge(:username => self.username))
+    self.deserialize(response, :as => Iknow::Item)
+  end
+
+  def lists(params = {})
+    return @lists if @lists
+
+    response = Iknow::RestClient::User.lists(params.merge(:username => self.username))
+    self.deserialize(response, :as => Iknow::List)
+  end
+
+  def friends(params = {})
+    return @friends if @friends
+
+    response = Iknow::RestClient::User.friends(params.merge(:username => self.username))
+    self.deserialize(response)
+  end
+
+  def study_results(params = {})
+    return @study_results if @study_results
+
+    params[:application] ||= :iknow
+    response = Iknow::RestClient::User.study_results(params.merge(:username => self.username))
+    self.deserialize(response, :as => Iknow::User::StudyResult)
+  end
+
+end

data/lib/iknow/model.rb

@@ -0,0 +1,5 @@
+require 'iknow/model/base'
+require 'iknow/model/user'
+require 'iknow/model/list'
+require 'iknow/model/item'
+require 'iknow/model/sentence'

data/lib/iknow/rest_client/base.rb

@@ -0,0 +1,128 @@
+class Iknow::RestClient::Base
+
+  class RESTError < Exception
+    attr_accessor :code, :message, :uri
+
+    def initialize(params = {})
+      self.code    = params[:code]
+      self.message = params[:message]
+      self.uri     = params[:uri]
+    end
+
+    def to_s
+      "HTTP #{@code}: #{@message} at #{@uri}"
+    end
+  end
+  class ResourceError < RESTError            ; end
+  class ResourceNotFound < ResourceError     ; end
+  class ResourceAccessDenied < ResourceError ; end
+
+  def self.valid_action?(action) ; self::ACTIONS.keys.include? action.to_sym          end
+  def self.path(action)          ; self::ACTIONS[action.to_sym][:path]                end
+  def self.http_method(action)   ; self::ACTIONS[action.to_sym][:http_method] || :get end
+
+  def self.method_missing(action, *args)
+    # GET methods are handled here
+    # POST and DELETE methods should be implemented in each class
+    super unless self.valid_action?(action)
+    uri, params = replace_uri_params(self.path(action), args[0])
+    http_connect do |conn|
+      case self.http_method(action)
+      when :get
+        http_get_request(uri, params)
+      when :post
+        http_post_request(uri, params)
+      when :delete
+        http_delete_request(uri, params)
+      end
+    end
+  end
+
+  private
+
+  def self.config; Iknow::Config.instance end
+  
+  def self.api_key_required
+    raise ArgumentError.new("iKnow! API key is required") if self.config.api_key == ''
+  end
+
+  def self.http_connect
+    connection = Net::HTTP.new(self.config.host, self.config.port)
+    connection.start do |conn|
+      request  = yield connection
+      response = conn.request(request)
+      handle_rest_response(response)
+      json_response = JSON.parse(response.body)
+      handle_json_response(json_response)
+      json_response
+    end
+  end
+
+  def self.raise_json_error(code, message, uri = nil)
+    case code
+    when 403
+      raise ResourceAccessDenied.new(:code => code, :message => message, :uri => uri)
+    when 404
+      raise ResourceNotFound.new(:code => code, :message => message, :uri => uri)
+    else
+      raise ResourceError.new(:code => code, :message => message, :uri => uri)
+    end
+  end
+
+  def self.raise_rest_error(response, uri = nil)
+    raise RESTError.new(:code => response.code, :message => response.message, :uri => uri)
+  end
+
+  def self.handle_json_response(json_response, uri = nil)
+    jsoon_error = json_response.is_a?(Hash) ? json_response['error'] : nil
+    raise_json_error(jsoon_error['code'], jsoon_error['message'], uri) unless jsoon_error.nil?
+  end
+
+  def self.handle_rest_response(response, uri = nil)
+    raise_rest_error(response, uri) unless response.is_a?(Net::HTTPSuccess)
+  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,
+    }
+    @@http_header
+  end
+
+  def self.replace_uri_params(uri, params = {})
+    unless params.empty?
+      params.each do |key, value|
+        if uri=~/__#{key}__/
+          uri.sub!(/__#{key}__/, value.to_s)
+          params.delete(key)
+        end
+      end
+    end
+    return uri, params
+  end
+
+  def self.http_get_request(uri, params = {})
+    path = (params.size > 0) ? "#{uri}?#{params.to_http_str}" : uri
+    Net::HTTP::Get.new(path, http_header)
+  end
+
+  def self.http_post_request(uri, params = {})
+    self.api_key_required
+    request = Net::HTTP::Post.new(uri, http_header)
+    request.body = params.merge(:api_key => self.config.api_key).to_http_str
+    request
+  end
+
+  def self.http_delete_request(uri, params = {})
+    path = (params.size > 0) ? "#{uri}?#{params.to_http_str}" : uri
+    Net::HTTP::Delete.new(path, http_header)
+  end
+
+  private_class_method :http_connect, :raise_rest_error, :handle_rest_response, :http_header,
+                       :replace_uri_params, :http_get_request, :http_post_request, :http_delete_request
+
+end

data/lib/iknow/rest_client/item.rb

@@ -0,0 +1,11 @@
+class Iknow::RestClient::Item < Iknow::RestClient::Base
+  
+  ACTIONS = {
+    :recent    => { :path => '/items'                                      },
+    :matching  => { :path => '/items/matching/__keyword__'                 },
+    :add_image => { :path => '/items/__id__/images', :http_method => :post },
+    :add_sound => { :path => '/items/__id__/sounds', :http_method => :post },
+    :extract   => { :path => '/items/extract',       :http_method => :post }
+  }
+  
+end

data/lib/iknow/rest_client/list.rb

@@ -0,0 +1,12 @@
+class Iknow::RestClient::List < Iknow::RestClient::Base
+  
+  ACTIONS = {
+    :recent    => { :path => '/lists'                                 },
+    :items     => { :path => '/lists/__id__/items'                    },
+    :sentences => { :path => '/lists/__id__/sentences'                },
+    :matching  => { :path => '/lists/matching/__keyword__'            },
+    :create    => { :path => '/lists',        :http_method => :post   },
+    :delete    => { :path => '/lists/__id__', :http_method => :delete }
+  }
+
+end

data/lib/iknow/rest_client/sentence.rb

@@ -0,0 +1,11 @@
+class Iknow::RestClient::Sentence < Iknow::RestClient::Base
+  
+  ACTIONS = {
+    :recent    => { :path => '/sentences'                                      },
+    :matching  => { :path => '/sentences/matching/__keyword__'                 },
+    :create    => { :path => '/sentences',               :http_method => :post },
+    :add_image => { :path => '/sentences/__id__/images', :http_method => :post },
+    :add_sound => { :path => '/sentences/__id__/sounds', :http_method => :post }
+  }
+  
+end

data/lib/iknow/rest_client/user.rb

@@ -0,0 +1,12 @@
+class Iknow::RestClient::User < Iknow::RestClient::Base
+  
+  ACTIONS = {
+    :find          => { :path => '/users/__username__'         },
+    :lists         => { :path => '/users/__username__/lists'   },
+    :items         => { :path => '/users/__username__/items'   },
+    :friends       => { :path => '/users/__username__/friends' },
+    :study_results => { :path => '/users/__username__/study_results/__application__'   },
+    :matching      => { :path => '/users/matching/__keyword__' }
+  }
+  
+end

data/lib/iknow/rest_client.rb

@@ -0,0 +1,8 @@
+module Iknow::RestClient
+end
+
+require 'iknow/rest_client/base'
+require 'iknow/rest_client/user'
+require 'iknow/rest_client/list'
+require 'iknow/rest_client/item'
+require 'iknow/rest_client/sentence'

data/lib/iknow.rb

@@ -0,0 +1,14 @@
+module Iknow
+end
+
+require 'date'
+require 'net/https'
+require 'uri'
+
+require 'rubygems'
+require 'json'
+
+require 'ext/hash'
+require 'iknow/core'
+require 'iknow/rest_client'
+require 'iknow/model'

data/test/iknow_test.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+require "test/unit"
+class IknowTest < Test::Unit::TestCase
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/iknow'
+

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: nov-iknow
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- nov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A rubygem for iKnow! APIs
+email: developer@iknow.co.jp
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- ChangeLog
+files: 
+- README
+- ChangeLog
+- Rakefile
+- test/iknow_test.rb
+- test/test_helper.rb
+- lib/ext
+- lib/ext/hash.rb
+- lib/iknow
+- lib/iknow/core
+- lib/iknow/core/config.rb
+- lib/iknow/core/version.rb
+- lib/iknow/core.rb
+- lib/iknow/model
+- lib/iknow/model/base.rb
+- lib/iknow/model/item.rb
+- lib/iknow/model/list.rb
+- lib/iknow/model/sentence.rb
+- lib/iknow/model/user.rb
+- lib/iknow/model.rb
+- lib/iknow/rest_client
+- lib/iknow/rest_client/base.rb
+- lib/iknow/rest_client/item.rb
+- lib/iknow/rest_client/list.rb
+- lib/iknow/rest_client/sentence.rb
+- lib/iknow/rest_client/user.rb
+- lib/iknow/rest_client.rb
+- lib/iknow.rb
+- examples/pure_ruby.rb
+has_rdoc: true
+homepage: http://iknow.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --title
+- iknow documentation
+- --charset
+- utf-8
+- --opname
+- index.html
+- --line-numbers
+- --main
+- README
+- --inline-source
+- --exclude
+- ^(examples|extras)/
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: iknow
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A rubygem for iKnow! APIs
+test_files: 
+- test/iknow_test.rb