smartfm 0.4.0 → 1.0.0

data/ChangeLog

@@ -39,9 +39,13 @@
 
 == 0.3.1
 
-* add sessions API support
+* add sessions API calls
 * fixed extract API bugs
 
 == 0.4.0
 
-* OAuth DELETE calls works fine now.
+* OAuth DELETE calls works fine now.
+
+== 1.0.0
+
+* add friends, followers, likes and notifications API calls

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,6 +1,6 @@
 module Smartfm::Version
-  MAJOR = 0
-  MINOR = 4
+  MAJOR = 1
+  MINOR = 0
   REVISION = 0
   class << self
     def to_version

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