nov-smartfm 0.4.0 → 0.4.1

data/ChangeLog

@@ -40,4 +40,8 @@
 == 0.3.1
 
 * add sessions API support
-* fixed extract API bugs
+* fixed extract API bugs
+
+== 0.4.0
+
+* OAuth DELETE calls works fine now.

data/README

@@ -7,8 +7,8 @@
   This rubygem is a wrapper of smart.fm API.
   You can get pure-ruby example at examples/pure_ruby.rb.
   http://github.com/nov/smartfm/tree/master/examples/pure_ruby.rb
-  
-  It shows all API calls you can use with this gem.
+
+  It shows almost all API calls you can use with this gem.
 
 == Installation
 
@@ -26,15 +26,8 @@
 
 == Features/Problems
 
-  Test! Test!! Test!!!
-
-  Create/Add/Delete APIs are not implemented.
-  They will be implemented in a few weeks.
-  
-  smart.fm OAuth is still pre-alpha.
-
 == Synopsis
-  
+
   See examples and smart.fm Developers, please.
   smart.fm Developers (http://developer.smart.fm)
 

data/lib/smartfm.rb

@@ -10,7 +10,8 @@ require 'json'
 
 require 'ext/hash'
 require 'smartfm/core'
-require 'smartfm/rest_client'
-require 'smartfm/model'
+require 'smartfm/rest_clients'
+require 'smartfm/modules'
+require 'smartfm/models'
 
 Smartfm::Config.init

data/lib/smartfm/core/version.rb

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

data/lib/smartfm/models.rb

@@ -0,0 +1,7 @@
+require 'smartfm/models/base'
+require 'smartfm/models/user'
+require 'smartfm/models/list'
+require 'smartfm/models/item'
+require 'smartfm/models/sentence'
+require 'smartfm/models/like'
+require 'smartfm/models/notification'

data/lib/smartfm/{model → models}/base.rb

@@ -1,9 +1,10 @@
 class Smartfm::Base
 
   def self.attributes; self::ATTRIBUTES end
-
   def attributes; self.class.attributes  end
 
+  protected
+
   def self.deserialize(hash, params = {})
     return nil if hash.nil?
 

data/lib/smartfm/{model → models}/item.rb

@@ -1,9 +1,16 @@
 class Smartfm::Item < Smartfm::Base
-  ATTRIBUTES = [:sentences, :responses, :cue, :id, :list]
-  READONLY_ATTRIBUTES = [:sentences, :responses, :cue, :id]
+  ATTRIBUTES = [:sentences, :responses, :cue, :id, :list, :user]
+  READONLY_ATTRIBUTES = [:sentences, :responses, :cue, :id, :user]
   attr_accessor *(ATTRIBUTES - READONLY_ATTRIBUTES)
   attr_reader *READONLY_ATTRIBUTES
 
+  include Smartfm::PublicContent
+  include Smartfm::MediaSupport
+  include Smartfm::ActsAsLikable
+
+  def self.rest_client; Smartfm::RestClient::Item; end
+  def rest_client; self.class.rest_client; end
+
   class Response < Smartfm::Base
     ATTRIBUTES = [:text, :text_with_character, :type, :language]
     READONLY_ATTRIBUTES = [:type]
@@ -34,99 +41,24 @@ class Smartfm::Item < Smartfm::Base
     end
   end
 
-  def self.recent(params = {})
-    hash = Smartfm::RestClient::Item.recent(params)
-    self.deserialize(hash) || []
-  end
-
-  def self.find(item_id, params = {})
-    params[:id] = item_id
-    hash = Smartfm::RestClient::Item.find(params)
-    self.deserialize(hash)
-  end
-
-  def self.matching(keyword, params = {})
-    params[:keyword] = keyword
-    hash = Smartfm::RestClient::Item.matching(params)
-    self.deserialize(hash) || []
-  end
-
-  def self.extract(text, params = {})
-    params[:text] = text
-    hash = Smartfm::RestClient::Item.extract(params)
-    if params[:words_only] == false
-      self.deserialize(hash) || []
-    else
-      hash
-    end
-  end
-
-  def self.create(auth, params = {})
-    self.new(params).save(auth)
-  end
-
   def initialize(params = {})
     params[:responses] = [params[:response]] if params[:response]
     @id        = params[:id].to_i
     @list      = params[:list]
-    @cue       = self.deserialize(params[:cue], :as => Smartfm::Item::Cue)
+    @cue       = self.deserialize(params[:cue],       :as => Smartfm::Item::Cue)
     @responses = self.deserialize(params[:responses], :as => Smartfm::Item::Response)
     @sentences = self.deserialize(params[:sentences], :as => Smartfm::Sentence)
+    @user      = self.deserialize(params[:user],      :as => Smartfm::User)
   end
 
-  def save(auth)
-    begin
-      item_id = Smartfm::RestClient::Item.create(auth, self.to_post_data)
-    rescue
-      return false
-    end
-    Smartfm::Item.find(item_id)
-  end
-
-  def add_image(auth, params)
-    post_params = if params.is_a?(String)
-      { 'image[url]' => params }
-    else
-      image_params = { 
-        'image[url]'     => params[:url],
-        'image[list_id]' => params[:list_id]
-      }
-      if params[:attribution]
-        attribution_params = { 
-          'attribution[media_entity]'           => params[:attribution][:media_entity],
-          'attribution[author]'                 => params[:attribution][:media_entity],
-          'attribution[author_url]'             => params[:attribution][:media_entity],
-          'attribution[attribution_license_id]' => params[:attribution][:media_entity]
-        }
-        image_params.merge(attribution_params)
-      else
-        image_params
-      end
-    end
-    Smartfm::RestClient::Item.add_image(auth, post_params.merge(:id => self.id))
-  end
-
-  def add_sound(auth, params)
-    post_params = if params.is_a?(String)
-      { 'sound[url]' => params }
+  def self.extract(text, params = {})
+    params[:text] = text
+    hash = self.rest_client.extract(params)
+    if params[:words_only] == false
+      self.deserialize(hash) || []
     else
-      sound_params = {
-        'sound[url]' => params[:url],
-        'sound[list_id]' => params[:list_id]
-      }
-      if params[:attribution]
-        attribution_params = { 
-          'attribution[media_entity]'           => params[:attribution][:media_entity],
-          'attribution[author]'                 => params[:attribution][:media_entity],
-          'attribution[author_url]'             => params[:attribution][:media_entity],
-          'attribution[attribution_license_id]' => params[:attribution][:media_entity]
-        }
-        sound_params.merge(attribution_params)
-      else
-        sound_params
-      end
+      hash
     end
-    Smartfm::RestClient::Item.add_sound(auth, post_params.merge(:id => self.id))
   end
 
   def add_tags(auth, *tags)
@@ -139,7 +71,7 @@ class Smartfm::Item < Smartfm::Base
         post_params["semantic_tags[#{idx}][disambiguation]"] = tag[:disambiguation]
       end
     end
-    Smartfm::RestClient::Item.add_tags(auth, post_params.merge(:id => self.id))
+    self.rest_client.add_tags(auth, post_params.merge(:id => self.id))
   end
 
   protected

data/lib/smartfm/models/like.rb

@@ -0,0 +1,20 @@
+class Smartfm::Like < Smartfm::Base
+  ATTRIBUTES = [:id, :type, :title, :description, :href, :favorite, :user]
+  attr_reader *ATTRIBUTES
+  
+  include Smartfm::PrivateContent
+
+  def self.rest_client; Smartfm::RestClient::Like; end
+  def rest_client; self.class.rest_client; end
+
+  def initialize(params)
+    @id          = params[:id]
+    @type        = params[:user]
+    @title       = params[:title]
+    @description = params[:description]
+    @href        = params[:href]
+    @favorite    = params[:favorite]
+    @user        = self.deserialize(params[:user], :as => Smartfm::User)
+  end
+
+end

data/lib/smartfm/{model → models}/list.rb

@@ -1,49 +1,37 @@
 class Smartfm::List < Smartfm::Base
   ATTRIBUTES = [:id, :title, :description, :icon, :square_icon, :item_count, :user_count, :iknow, :dictation, :brainspeed,
-                :language, :translation_language, :list_type, :transcript, :embed,
-                :tags, :media_entry, :author, :author_id, :author_url, :attribution_license_id,
-                :items, :sentences]
-  READONLY_ATTRIBUTES = [:id, :icon, :item_count, :user_count, :iknow, :dictation, :brainspeed]
+                :language, :translation_language, :list_type, :transcript, :embed, :tags, :media_entry,
+                :attribution_license_id, :items, :sentences, :user]
+  READONLY_ATTRIBUTES = [:id, :icon, :item_count, :user_count, :iknow, :dictation, :brainspeed, :user]
   attr_accessor *(ATTRIBUTES - READONLY_ATTRIBUTES)
   attr_reader   *READONLY_ATTRIBUTES
 
+  include Smartfm::PublicContent
+  include Smartfm::ActsAsLikable
+
+  def self.rest_client; Smartfm::RestClient::List; end
+  def rest_client; self.class.rest_client; end
+
   class Application < Smartfm::Base
-    ATTRIBUTES = [:application, :list_id, :lang]
+    ATTRIBUTES = [:application, :available, :progress, :list_id, :lang]
     attr_reader *ATTRIBUTES
 
     def initialize(params = {})
-      @application  = params[:application]
-      @list_id      = params[:list_id]
-      @lang         = params[:lang]
-    end
-    def url
-      "http://smart.fm/flash?swf=#{self.name}&course_id=#{self.list_id}&lang=#{self.lang}"
+      @application = case
+        when params[:iknow]      then :iknow
+        when params[:dictation]  then :dictation
+        when params[:brainspeed] then :brainspeed
+        end
+      @available = params[self.application][:available]
+      @progress  = params[self.application][:progress]
+      @href      = params[self.application][:href]
+      @list_id   = params[:list_id]
+      @lang      = params[:lang]
     end
-  end
-
-  def self.recent(params = {})
-    hash = Smartfm::RestClient::List.recent(params)
-    self.deserialize(hash) || []
-  end
-
-  def self.find(list_id, params = {})
-    params[:id] = list_id
-    hash = Smartfm::RestClient::List.find(params)
-    self.deserialize(hash)
-  end
-
-  def self.matching(keyword, params = {})
-    params[:keyword] = keyword
-    hash = Smartfm::RestClient::List.matching(params)
-    self.deserialize(hash) || []
-  end
-
-  def self.create(auth, params = {})
-    self.new(params).save(auth)
-  end
 
-  def self.delete(list_id)
-    self.find(list_id).delete
+    def available?
+      self.available
+    end
   end
 
   def initialize(params = {})
@@ -56,55 +44,39 @@ class Smartfm::List < Smartfm::Base
     @user_count  = (params[:user_count].to_i rescue nil)
     @language    = params[:language]
     @translation_language = params[:translation_language]
-    if @list_id and @translation_language
+    if @id and @translation_language
       common_settings = {:list_id => @id, :lang => @translation_language}
-      @iknow      = Application.new(common_settings.merge(:application => 'iknow'))      if params[:iknow]
-      @dictation  = Application.new(common_settings.merge(:application => 'dictation'))  if params[:dictation]
-      @brainspeed = Application.new(common_settings.merge(:application => 'brainspeed')) if params[:brainspeed]
+      @iknow      = Application.new(common_settings.merge(:iknow      => params[:iknow]))
+      @dictation  = Application.new(common_settings.merge(:dictation  => params[:dictation]))
+      @brainspeed = Application.new(common_settings.merge(:brainspeed => params[:brainspeed]))
     end
-    @author      = params[:author]      # display_name or username
-    @author_id   = params[:author_id]   # username
-    @author_url  = params[:author_url]
     @list_type   = params[:list_type]   # for list creation
     @transcript  = params[:transcript]  # for list creation
     @embed       = params[:embed]       # for list creation
     @tags        = params[:tags]        # for list creation
     @media_entry = params[:media_entry] # for list creation
     @attribution_license_id = params[:attribution_license_id] # for list creation
-    @items     = self.deserialize(params[:items],     :as => Smartfm::Item)
-    @sentences = self.deserialize(params[:sentences], :as => Smartfm::Sentence)
+    @items       = self.deserialize(params[:items],     :as => Smartfm::Item)
+    @sentences   = self.deserialize(params[:sentences], :as => Smartfm::Sentence)
+    @user        = self.deserialize(params[:user],      :as => Smartfm::User)
   end
 
   def items(params = {})
-    hash = Smartfm::RestClient::List.items(params.merge(:id => self.id))
+    hash = self.rest_client.items(params.merge(:id => self.id))
     self.deserialize(hash, :as => Smartfm::Item) || []
   end
 
   def sentences(params = {})
-    hash = Smartfm::RestClient::List.sentences(params.merge(:id => self.id))
+    hash = self.rest_client.sentences(params.merge(:id => self.id))
     self.deserialize(hash, :as => Smartfm::Sentence) || []
   end
 
-  def save(auth)
-    begin
-      list_id = Smartfm::RestClient::List.create(auth, self.to_post_data)
-    rescue
-      return false
-    end
-    Smartfm::List.find(list_id)
-  end
-
-  def delete(auth)
-    Smartfm::RestClient::List.delete(auth, {:id => self.id})
-  end
-  alias_method :destroy, :delete
-
   def add_item(auth, item)
-    Smartfm::RestClient::List.add_item(auth, {:list_id => self.id, :id => item.id})
+    self.rest_client.add_item(auth, {:id => self.id, :item_id => item.id})
   end
 
   def delete_item(auth, item)
-    Smartfm::RestClient::List.delete_item(auth, {:list_id => self.id, :id => item.id})
+    self.rest_client.delete_item(auth, {:id => self.id, :item_id => item.id})
   end
 
   protected
@@ -121,8 +93,7 @@ class Smartfm::List < Smartfm::Base
     if self.list_type
       post_data['list[type]'] = self.list_type
     end
-    [ :transcript, :embed, :tags, :media_entry,
-      :author, :author_url, :attribution_license_id ].each do |key|
+    [: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

data/lib/smartfm/models/notification.rb

@@ -0,0 +1,26 @@
+class Smartfm::Notification < Smartfm::Base
+  ATTRIBUTES = [:type, :message, :recipient, :sender, :context]
+  READONLY_ATTRIBUTES = [:type, :recipient, :sender, :context]
+  attr_accessor *(ATTRIBUTES - READONLY_ATTRIBUTES)
+  attr_reader   *READONLY_ATTRIBUTES
+
+  include Smartfm::PrivateContent
+
+  def self.rest_client; Smartfm::RestClient::Notification; end
+  def rest_client; self.class.rest_client; end
+
+  def initialize(params)
+    @type      = params[:type]
+    @message   = params[:message]
+    @recipient = params[:recipient]
+    @sender    = params[:sender]
+    @context   = params[:context]
+  end
+
+  private
+
+  def to_post_data
+    {:message => self.message}
+  end
+
+end

data/lib/smartfm/models/sentence.rb

@@ -0,0 +1,70 @@
+class Smartfm::Sentence < Smartfm::Base
+  ATTRIBUTES = [:sound, :image, :square_image, :text, :language, :id, :transliterations, :translations, :item, :list, :user]
+  READONLY_ATTRIBUTES = [:id, :user]
+  attr_accessor *(ATTRIBUTES - READONLY_ATTRIBUTES)
+  attr_reader *READONLY_ATTRIBUTES
+
+  include Smartfm::PublicContent
+  include Smartfm::MediaSupport
+  include Smartfm::ActsAsLikable
+
+  def self.rest_client; Smartfm::RestClient::Sentence; end
+  def rest_client; self.class.rest_client; end
+
+  def initialize(params = {})
+    params[:translations] = [params[:translation]] if params[:translation]
+    params[:transliterations] = [params[:transliteration]] if params[:transliteration]
+    @id               = params[:id]
+    @item             = params[:item]
+    @list             = params[:list]
+    @sound            = params[:sound]
+    @image            = params[:image]
+    @square_image     = params[:square_image]
+    @text             = params[:text]
+    @language         = params[:language]
+    @transliterations = params[:transliterations]
+    @translations     = self.deserialize(params[:translations], :as => Smartfm::Sentence)
+    @user             = self.deserialize(params[:user],         :as => Smartfm::User)
+  end
+
+  protected
+
+  def to_post_data
+    self.validate
+    post_data = {
+      'item_id' => self.item.id,
+      'sentence[text]' => self.text
+    }
+    # Optional attributes
+    if self.list
+      post_data['sentence[list_id]'] = self.list.id
+    end
+    [:language, :transliteration].each do |key|
+      if self.send("#{key}")
+        post_data["sentence[#{key}]"] = self.send("#{key}")
+      end
+    end
+    if self.translation
+      [:text, :language, :transliteration].each do |key|
+        if self.translation.send("#{key}")
+          post_data["translation[#{key}]"] = self.translation.send("#{key}")
+        end
+      end
+    end
+    post_data
+  end
+
+  def validate
+    raise ArgumentError.new("Item is required.") unless self.item
+    raise ArgumentError.new("Sentence text is required.") if self.text.nil? or self.text.empty?
+  end
+
+  def translation
+    self.translations.first rescue nil
+  end
+
+  def transliteration
+    self.transliterations.first rescue nil
+  end
+
+end

data/lib/smartfm/{model → models}/user.rb

@@ -2,6 +2,9 @@ class Smartfm::User < Smartfm::Base
   ATTRIBUTES = [:username, :profile]
   attr_reader *ATTRIBUTES
 
+  def self.rest_client; Smartfm::RestClient::User; end
+  def rest_client; self.class.rest_client; end
+
   class Profile < Smartfm::Base
     ATTRIBUTES = [:name, :gender, :birthday, :description, :blog_url, :profile_url, :foaf_url, :icon_url]
     attr_reader *ATTRIBUTES
@@ -58,54 +61,89 @@ class Smartfm::User < Smartfm::Base
       @results       = self.deserialize(params[:study_results], :as => Smartfm::User::Study::Result)
       @total_summary = self.deserialize(params[:total_summary], :as => Smartfm::User::Study::TotalSummary)
     end
+  end
 
+  def initialize(params)
+    @profile  = Profile.new(params[:profile])
+    @username = params[:username]
   end
 
   def self.find(username, params = {})
     params[:username] = username
-    hash = Smartfm::RestClient::User.find(params)
+    hash = self.rest_client.find(params)
     self.deserialize(hash)
   end
 
   def self.matching(keyword, params = {})
     params[:keyword] = keyword
-    hash = Smartfm::RestClient::User.matching(params)
+    hash = self.rest_client.matching(params)
     self.deserialize(hash) || []
   end
 
-  def self.username(auth)
-    Smartfm::RestClient::User.username(auth, {})
+  def self.current(auth, params = {})
+    self.rest_client.current(auth, params)
   end
 
-  def initialize(params)
-    @profile  = Profile.new(params[:profile])
-    @username = params[:username]
+  def self.friends(auth, params = {})
+    self.rest_client.friends_of_current(auth, params)
+  end
+
+  def self.followers(auth, params = {})
+    self.rest_client.followers_of_current(auth, params)
+  end
+
+  def friends(params = {})
+    hash = self.rest_client.friends(params.merge(:username => self.username))
+    self.deserialize(hash) || []
+  end
+
+  def followers(params = {})
+    hash = self.rest_client.followers(params.merge(:username => self.username))
+    self.deserialize(hash) || []
+  end
+
+  def friends_of_current(auth, params = {})
+    hash = self.rest_client.friends_of_current(auth, params)
+    self.deserialize(hash) || []
+  end
+
+  def followers_of_current(auth, params = {})
+    hash = self.rest_client.followers_of_current(auth, params)
+    self.deserialize(hash) || []
+  end
+
+  def follow!(auth, params = {})
+    self.rest_client.follow!(auth, params.merge(:username => self.username))
+  end
+
+  def unfollow!(auth, params = {})
+    self.rest_client.unfollow!(auth, params.merge(:username => self.username))
   end
 
   def items(params = {})
-    hash = Smartfm::RestClient::User.items(params.merge(:username => self.username))
+    hash = self.rest_client.items(params.merge(:username => self.username))
     self.deserialize(hash, :as => Smartfm::Item) || []
   end
 
   def lists(params = {})
-    hash = Smartfm::RestClient::User.lists(params.merge(:username => self.username))
+    hash = self.rest_client.lists(params.merge(:username => self.username))
     self.deserialize(hash, :as => Smartfm::List) || []
   end
 
-  def friends(params = {})
-    hash = Smartfm::RestClient::User.friends(params.merge(:username => self.username))
-    self.deserialize(hash) || []
+  def likes(params = {})
+    hash = self.rest_client.likes(params.merge(:username => self.username))
+    self.deserialize(hash, :as => Smartfm::Like) || []
   end
 
-  def followers(params = {})
-    hash = Smartfm::RestClient::User.followers(params.merge(:username => self.username))
-    self.deserialize(hash) || []
+  def notifications(params = {})
+    hash = self.rest_client.notifications(params.merge(:username => self.username))
+    self.deserialize(hash, :as => Smartfm::Notification) || []
   end
 
   def study(params = {})
     params[:application] ||= 'iknow'
     return nil unless ['iknow', 'dictation', 'brainspeed', ].include?(params[:application])
-    hash = Smartfm::RestClient::User.study_results(params.merge(:username => self.username))
+    hash = self.rest_client.study_results(params.merge(:username => self.username))
     self.deserialize(hash, :as => Smartfm::User::Study)
   end
 

data/lib/smartfm/modules.rb

@@ -0,0 +1,4 @@
+require 'smartfm/modules/acts_as_likable'
+require 'smartfm/modules/private_content'
+require 'smartfm/modules/public_content'
+require 'smartfm/modules/media_support'

data/lib/smartfm/modules/acts_as_likable.rb

@@ -0,0 +1,16 @@
+module Smartfm::ActsAsLikable
+
+  def likes(params = {})
+    hash = self.rest_client.likes(params.merge(:id => self.id))
+    self.deserialize(hash, :as => Smartfm::Like) || []
+  end
+
+  def like!(auth, params)
+    self.rest_client.like!(auth, params.merge(:id => self.id))
+  end
+
+  def unlike!(auth, params)
+    self.rest_client.unlike!(auth, params.merge(:id => self.id))
+  end
+
+end

data/lib/smartfm/modules/media_support.rb

@@ -0,0 +1,37 @@
+module Smartfm::MediaSupport
+
+  def attribution_params(attr_params)
+    return {} unless attr_params
+    {
+      'attribution[medias_entity]'           => attr_params[:media_entity],
+      'attribution[author]'                  => attr_params[:author],
+      'attribution[author_url]'              => attr_params[:author_url],
+      'attributions[attribution_license_id]' => attr_params[:attribution_license_id]
+    }
+  end
+
+  def add_image(auth, params)
+    post_params = if params.is_a?(String)
+      {'image[url]' => params}
+    else
+      {
+        'image[url]' => params[:url],
+        'image[list_id]' => params[:list_id]
+      }.merge(attribution_params(params[:attribution]))
+    end
+    self.rest_client.add_image(auth, post_params.merge(:id => self.id))
+  end
+
+  def add_sound(auth, params)
+    post_params = if params.is_a?(String)
+      {'sound[url]' => params}
+    else
+      {
+        'sound[url]' => params[:url],
+        'sound[list_id]' => params[:list_id]
+      }.merge(attribution_params(params[:attribution]))
+    end
+    self.rest_client.add_sound(auth, post_params.merge(:id => self.id))
+  end
+
+end

data/lib/smartfm/modules/private_content.rb

@@ -0,0 +1,25 @@
+module Smartfm::PrivateContent
+
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    def of_current(auth, params = {})
+      hash = self.rest_client.of_current(auth, params)
+      self.deserialize(hash) || []
+    end
+
+    def create(auth, params = {})
+      self.new(params).save
+    end
+  end
+
+  module InstanceMethods
+    def save(auth)
+      self.rest_client.create(auth, self.to_post_data)
+    end
+  end
+
+end

data/lib/smartfm/modules/public_content.rb

@@ -0,0 +1,51 @@
+module Smartfm::PublicContent
+
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    def recent(params = {})
+      hash = self.rest_client.recent(params)
+      self.deserialize(hash) || []
+    end
+
+    def find(list_id, params = {})
+      params[:id] = list_id
+      hash = self.rest_client.find(params)
+      self.deserialize(hash)
+    end
+
+    def matching(keyword, params = {})
+      params[:keyword] = keyword
+      hash = self.rest_client.matching(params)
+      self.deserialize(hash) || []
+    end
+
+    def create(auth, params = {})
+      self.new(params).save(auth)
+    end
+
+    def delete(obj_id)
+      self.find(obj_id).delete
+    end
+  end
+
+  module InstanceMethods
+    def save(auth)
+      begin
+        obj_id = self.rest_client.create(auth, self.to_post_data)
+      rescue
+        return false
+      end
+      self.find(obj_id)
+    end
+
+    def delete(auth)
+      self.rest_client.delete(auth, {:id => self.id})
+    end
+    alias_method :destroy, :delete
+  end
+
+end

data/lib/smartfm/rest_clients.rb

@@ -0,0 +1,9 @@
+module Smartfm::RestClient; end
+
+require 'smartfm/rest_clients/base'
+require 'smartfm/rest_clients/user'
+require 'smartfm/rest_clients/list'
+require 'smartfm/rest_clients/item'
+require 'smartfm/rest_clients/sentence'
+require 'smartfm/rest_clients/like'
+require 'smartfm/rest_clients/notification'

data/lib/smartfm/rest_clients/item.rb

@@ -0,0 +1,17 @@
+class Smartfm::RestClient::Item < Smartfm::RestClient::Base
+
+  ACTIONS = {
+    :recent    => {:path => '/items'                     },
+    :find      => {:path => '/items/__id__'              },
+    :matching  => {:path => '/items/matching/__keyword__'},
+    :extract   => {:path => '/items/extract',            },
+    :likes     => {:path => '/items/__id__/likes'        },
+    :create    => {:path => '/items',               :http_method => :post},
+    :add_image => {:path => '/items/__id__/images', :http_method => :post},
+    :add_sound => {:path => '/items/__id__/sounds', :http_method => :post},
+    :add_tags  => {:path => '/items/__id__/tags',   :http_method => :post},
+    :like!     => {:path => '/items/__id__/likes',  :http_method => :post},
+    :unlike!   => {:path => '/items/__id__/likes',  :http_method => :delete}
+  }
+
+end

data/lib/smartfm/rest_clients/like.rb

@@ -0,0 +1,7 @@
+class Smartfm::RestClient::Like < Smartfm::RestClient::Base
+
+  ACTIONS = {
+    :of_current => {:path => '/likes'}
+  }
+
+end

data/lib/smartfm/rest_clients/list.rb

@@ -0,0 +1,18 @@
+class Smartfm::RestClient::List < Smartfm::RestClient::Base
+  
+  ACTIONS = {
+    :recent      => {:path => '/lists'                     },
+    :find        => {:path => '/lists/__id__'              },
+    :items       => {:path => '/lists/__id__/items'        },
+    :sentences   => {:path => '/lists/__id__/sentences'    },
+    :matching    => {:path => '/lists/matching/__keyword__'},
+    :likes       => {:path => '/lists/__id__/likes'        },
+    :create      => {:path => '/lists',                          :http_method => :post},
+    :add_item    => {:path => '/lists/__id__/items',             :http_method => :post},
+    :like!       => {:path => '/lists/__id__/likes',             :http_method => :post},
+    :delete      => {:path => '/lists/__id__',                   :http_method => :delete},
+    :delete_item => {:path => '/lists/__id__/items/__item_id__', :http_method => :delete},
+    :unlike!     => {:path => '/lists/__id__/likes',             :http_method => :delete}
+  }
+
+end

data/lib/smartfm/rest_clients/notification.rb

@@ -0,0 +1,8 @@
+class Smartfm::RestClient::Notification < Smartfm::RestClient::Base
+
+  ACTIONS = {
+    :of_current => {:path => '/notifications'},
+    :create     => {:path => '/notifications', :http_method => :post},
+  }
+
+end

data/lib/smartfm/rest_clients/sentence.rb

@@ -0,0 +1,14 @@
+class Smartfm::RestClient::Sentence < Smartfm::RestClient::Base
+  
+  ACTIONS = {
+    :recent    => {:path => '/sentences'                     },
+    :find      => {:path => '/sentences/__id__'              },
+    :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},
+    :like!     => {:path => '/sentences/__id__/likes',  :http_method => :post},
+    :unlike!   => {:path => '/sentences/__id__/likes',  :http_method => :delete}
+  }
+  
+end

data/lib/smartfm/rest_clients/user.rb

@@ -0,0 +1,20 @@
+class Smartfm::RestClient::User < Smartfm::RestClient::Base
+
+  ACTIONS = {
+    :current              => {:path => '/users'                           },
+    :find                 => {:path => '/users/__username__'              },
+    :lists                => {:path => '/users/__username__/lists'        },
+    :items                => {:path => '/users/__username__/items'        },
+    :friends              => {:path => '/users/__username__/friends'      },
+    :followers            => {:path => '/users/__username__/followers'    },
+    :friends_of_current   => {:path => '/friends'                         },
+    :followers_of_current => {:path => '/followers'                       },
+    :likes                => {:path => '/users/__username__/likes'        },
+    :notifications        => {:path => '/users/__username__/notifications'},
+    :matching             => {:path => '/users/matching/__keyword__'      },
+    :study_results        => {:path => '/users/__username__/study_results/__application__'},
+    :follow!              => {:path => '/users/__username__/friends', :http_method => :post},
+    :unfollow!            => {:path => '/users/__username__/friends', :http_method => :delete}
+  }
+
+end

data/spec/smartfm/model/base_spec.rb

@@ -10,9 +10,11 @@ subclasses.each do |klass|
     end
   end
 
-  describe klass, '.find' do
-    it "should return nil if NOT FOUND" do
-      klass.find(-1).should be_nil
+  if klass.respond_to?(:recent)
+    describe klass, '.find' do
+      it "should return nil if NOT FOUND" do
+        klass.find(-1).should be_nil
+      end
     end
   end
 

data/spec/smartfm/model/item_spec.rb

@@ -39,3 +39,12 @@ describe Smartfm::Item, '#sentences' do
     end
   end
 end
+
+describe Smartfm::Item, '#likes' do
+  it "should return a Array of Smartfm::Like" do
+    smart.likes.should be_a(Array)
+    smart.likes.each do |like|
+      like.should be_a(Smartfm::Like)
+    end
+  end
+end

data/spec/smartfm/model/like_spec.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+matake_likes = Smartfm::User.find('matake').likes
+
+describe Smartfm::Like do
+  it "should respond to attribute methods" do
+    Smartfm::Like::ATTRIBUTES.each do |attr|
+      matake_likes.first.should respond_to(attr)
+    end
+  end
+end

data/spec/smartfm/model/list_spec.rb

@@ -1,7 +1,43 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe String do
-  it "should respond to length" do
-    "hoge".should respond_to(:length)
+core_2000 = Smartfm::List.find(705)
+
+describe Smartfm::List do
+  it "should respond to attribute methods" do
+    Smartfm::List::ATTRIBUTES.each do |attr|
+      core_2000.should respond_to(attr)
+    end
+    Smartfm::List::Application::ATTRIBUTES.each do |attr|
+      core_2000.iknow.should respond_to(attr)
+      core_2000.dictation.should respond_to(attr)
+      core_2000.brainspeed.should respond_to(attr)
+    end
+  end
+end
+
+describe Smartfm::List, '#items' do
+  it "should return a Array of Smartfm::Item" do
+    core_2000.items.should be_a(Array)
+    core_2000.items.each do |item|
+      item.should be_a(Smartfm::Item)
+    end
+  end
+end
+
+describe Smartfm::List, '#sentences' do
+  it "should return a Array of Smartfm::Sentence" do
+    core_2000.sentences.should be_a(Array)
+    core_2000.sentences.each do |sentence|
+      sentence.should be_a(Smartfm::Sentence)
+    end
+  end
+end
+
+describe Smartfm::List, '#likes' do
+  it "should return a Array of Smartfm::Like" do
+    core_2000.likes.should be_a(Array)
+    core_2000.likes.each do |like|
+      like.should be_a(Smartfm::Like)
+    end
   end
 end

data/spec/smartfm/model/notification_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe String do
+  it "should respond to length" do
+    "hoge".should respond_to(:length)
+  end
+end

data/spec/smartfm/model/user_spec.rb

@@ -64,6 +64,24 @@ describe Smartfm::User, '#followers' do
   end
 end
 
+describe Smartfm::User, '#likes' do
+  it "should return a Array of Smartfm::Like" do
+    matake.likes.should be_a(Array)
+    matake.likes.each do |like|
+      like.should be_a(Smartfm::Like)
+    end
+  end
+end
+
+describe Smartfm::User, '#notifications' do
+  it "should return a Array of Smartfm::Notification" do
+    matake.notifications.should be_a(Array)
+    matake.notifications.each do |notification|
+      notification.should be_a(Smartfm::Notification)
+    end
+  end
+end
+
 describe Smartfm::User, '#study' do
   it "should return a instance of Smartfm::User::Study" do
     matake.study.should be_a(Smartfm::User::Study)

data/spec/smartfm/rest_client/like_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Smartfm::RestClient::User, '::ACTIONS' do
+  it "should be a Hash" do
+    Smartfm::RestClient::Like::ACTIONS.should be_a(Hash)
+  end
+end

data/spec/smartfm/rest_client/notification_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Smartfm::RestClient::User, '::ACTIONS' do
+  it "should be a Hash" do
+    Smartfm::RestClient::Notification::ACTIONS.should be_a(Hash)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nov-smartfm
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors: 
 - nov
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-29 00:00:00 -07:00
+date: 2009-04-30 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,13 +57,17 @@ files:
 - spec/smartfm/model
 - spec/smartfm/model/base_spec.rb
 - spec/smartfm/model/item_spec.rb
+- spec/smartfm/model/like_spec.rb
 - spec/smartfm/model/list_spec.rb
+- spec/smartfm/model/notification_spec.rb
 - spec/smartfm/model/sentence_spec.rb
 - spec/smartfm/model/user_spec.rb
 - spec/smartfm/rest_client
 - spec/smartfm/rest_client/base_spec.rb
 - spec/smartfm/rest_client/item_spec.rb
+- spec/smartfm/rest_client/like_spec.rb
 - spec/smartfm/rest_client/list_spec.rb
+- spec/smartfm/rest_client/notification_spec.rb
 - spec/smartfm/rest_client/sentence_spec.rb
 - spec/smartfm/rest_client/user_spec.rb
 - spec/spec_helper.rb
@@ -75,20 +79,30 @@ files:
 - lib/smartfm/core/config.rb
 - lib/smartfm/core/version.rb
 - lib/smartfm/core.rb
-- lib/smartfm/model
-- lib/smartfm/model/base.rb
-- lib/smartfm/model/item.rb
-- lib/smartfm/model/list.rb
-- lib/smartfm/model/sentence.rb
-- lib/smartfm/model/user.rb
-- lib/smartfm/model.rb
-- lib/smartfm/rest_client
-- lib/smartfm/rest_client/base.rb
-- lib/smartfm/rest_client/item.rb
-- lib/smartfm/rest_client/list.rb
-- lib/smartfm/rest_client/sentence.rb
-- lib/smartfm/rest_client/user.rb
-- lib/smartfm/rest_client.rb
+- lib/smartfm/models
+- lib/smartfm/models/base.rb
+- lib/smartfm/models/item.rb
+- lib/smartfm/models/like.rb
+- lib/smartfm/models/list.rb
+- lib/smartfm/models/notification.rb
+- lib/smartfm/models/sentence.rb
+- lib/smartfm/models/user.rb
+- lib/smartfm/models.rb
+- lib/smartfm/modules
+- lib/smartfm/modules/acts_as_likable.rb
+- lib/smartfm/modules/media_support.rb
+- lib/smartfm/modules/private_content.rb
+- lib/smartfm/modules/public_content.rb
+- lib/smartfm/modules.rb
+- lib/smartfm/rest_clients
+- lib/smartfm/rest_clients/base.rb
+- lib/smartfm/rest_clients/item.rb
+- lib/smartfm/rest_clients/like.rb
+- lib/smartfm/rest_clients/list.rb
+- lib/smartfm/rest_clients/notification.rb
+- lib/smartfm/rest_clients/sentence.rb
+- lib/smartfm/rest_clients/user.rb
+- lib/smartfm/rest_clients.rb
 - lib/smartfm.rb
 - examples/pure_ruby.rb
 has_rdoc: true

data/lib/smartfm/model.rb

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

data/lib/smartfm/model/sentence.rb

@@ -1,118 +0,0 @@
-class Smartfm::Sentence < Smartfm::Base
-  ATTRIBUTES = [:sound, :image, :square_image, :text, :language, :id, :transliterations, :translations, :item, :list]
-  READONLY_ATTRIBUTES = [:id]
-  attr_accessor *(ATTRIBUTES - READONLY_ATTRIBUTES)
-  attr_reader *READONLY_ATTRIBUTES
-
-  def self.recent(params = {})
-    hash = Smartfm::RestClient::Sentence.recent(params)
-    self.deserialize(hash) || []
-  end
-
-  def self.find(sentence_id, params = {})
-    params[:id] = sentence_id
-    hash = Smartfm::RestClient::Sentence.find(params)
-    self.deserialize(hash)
-  end
-
-  def self.matching(keyword, params = {})
-    params[:keyword] = keyword
-    hash = Smartfm::RestClient::Sentence.matching(params)
-    self.deserialize(hash) || []
-  end
-
-  def self.create(auth, params = {})
-    self.new(params).save(auth)
-  end
-
-  def initialize(params = {})
-    params[:translations] = [params[:translation]] if params[:translation]
-    params[:transliterations] = [params[:transliteration]] if params[:transliteration]
-    @id               = params[:id]
-    @item             = params[:item]
-    @list             = params[:list]
-    @sound            = params[:sound]
-    @image            = params[:image]
-    @square_image     = params[:square_image]
-    @text             = params[:text]
-    @language         = params[:language]
-    @transliterations = params[:transliterations]
-    @translations     = self.deserialize(params[:translations], :as => Smartfm::Sentence)
-  end
-
-  def save(auth)
-    begin
-      sentence_id = Smartfm::RestClient::Sentence.create(auth, self.to_post_data)
-    rescue
-      return false
-    end
-    Smartfm::Sentence.find(sentence_id)
-  end
-
-  def add_image(auth, params)
-    post_params = if params.is_a?(String)
-      {'image[url]' => params}
-    else
-      {'image[url]' => params[:url], 'image[list_id]' => params[:list_id]}.merge(attribution_params(params[:attribution]))
-    end
-    Smartfm::RestClient::Sentence.add_image(auth, post_params.merge(:id => self.id))
-  end
-
-  def add_sound(auth, params)
-    post_params = if params.is_a?(String)
-      {'sound[url]' => params}
-    else
-      {'sound[url]' => params[:url], 'sound[list_id]' => params[:list_id]}.merge(attribution_params(params[:attribution]))
-    end
-    Smartfm::RestClient::Sentence.add_sound(auth, post_params.merge(:id => self.id))
-  end
-
-  protected
-
-  def to_post_data
-    self.validate
-    post_data = {
-      'item_id' => self.item.id,
-      'sentence[text]' => self.text
-    }
-    # Optional attributes
-    if self.list
-      post_data['sentence[list_id]'] = self.list.id
-    end
-    [:language, :transliteration].each do |key|
-      if self.send("#{key}")
-        post_data["sentence[#{key}]"] = self.send("#{key}")
-      end
-    end
-    if self.translation
-      [:text, :language, :transliteration].each do |key|
-        if self.translation.send("#{key}")
-          post_data["translation[#{key}]"] = self.translation.send("#{key}")
-        end
-      end
-    end
-    post_data
-  end
-
-  def validate
-    raise ArgumentError.new("Item is required.") unless self.item
-    raise ArgumentError.new("Sentence text is required.") if self.text.nil? or self.text.empty?
-  end
-
-  def translation
-    self.translations.first rescue nil
-  end
-
-  def transliteration
-    self.transliterations.first rescue nil
-  end
-
-  def attribution_params(attr_params)
-    return {} unless attr_params
-    {'attribution[medias_entity]'           => attr_params[:media_entity],
-     'attribution[author]'                  => attr_params[:author],
-     'attribution[author_url]'              => attr_params[:author_url],
-     'attributions[attribution_license_id]' => attr_params[:attribution_license_id] }
-  end
-
-end

data/lib/smartfm/rest_client.rb

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

data/lib/smartfm/rest_client/item.rb

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

data/lib/smartfm/rest_client/list.rb

@@ -1,15 +0,0 @@
-class Smartfm::RestClient::List < Smartfm::RestClient::Base
-  
-  ACTIONS = {
-    :recent      => { :path => '/lists'                      },
-    :find        => { :path => '/lists/__id__'               },
-    :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 },
-    :add_item    => { :path => '/lists/__list_id__/items',        :http_method => :post   },
-    :delete_item => { :path => '/lists/__list_id__/items/__id__', :http_method => :delete }
-  }
-
-end

data/lib/smartfm/rest_client/sentence.rb

@@ -1,12 +0,0 @@
-class Smartfm::RestClient::Sentence < Smartfm::RestClient::Base
-  
-  ACTIONS = {
-    :recent    => { :path => '/sentences'                                      },
-    :find      => { :path => '/sentences/__id__'                               },
-    :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/smartfm/rest_client/user.rb

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