nov-smartfm 0.4.0

data/lib/smartfm/model/item.rb

@@ -0,0 +1,178 @@
+class Smartfm::Item < Smartfm::Base
+  ATTRIBUTES = [:sentences, :responses, :cue, :id, :list]
+  READONLY_ATTRIBUTES = [:sentences, :responses, :cue, :id]
+  attr_accessor *(ATTRIBUTES - READONLY_ATTRIBUTES)
+  attr_reader *READONLY_ATTRIBUTES
+
+  class Response < Smartfm::Base
+    ATTRIBUTES = [:text, :text_with_character, :type, :language]
+    READONLY_ATTRIBUTES = [:type]
+    attr_accessor *(ATTRIBUTES - READONLY_ATTRIBUTES)
+    attr_reader *READONLY_ATTRIBUTES
+
+    def initialize(params = {})
+      @text     = params[:text]
+      @type     = params[:type]
+      @language = params[:language]
+    end
+  end
+
+  class Cue < Smartfm::Base
+    ATTRIBUTES = [:type, :text, :image, :sound, :part_of_speech, :language, :transliterations]
+    READONLY_ATTRIBUTES = [:sound]
+    attr_accessor *(ATTRIBUTES - READONLY_ATTRIBUTES)
+    attr_reader *READONLY_ATTRIBUTES
+
+    def initialize(params = {})
+      @type             = params[:type]
+      @text             = params[:text]
+      @image            = params[:image]
+      @sound            = params[:sound]
+      @part_of_speech   = params[:part_of_speech]
+      @language         = params[:language]
+      @transliterations = params[:transliterations]
+    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)
+    @responses = self.deserialize(params[:responses], :as => Smartfm::Item::Response)
+    @sentences = self.deserialize(params[:sentences], :as => Smartfm::Sentence)
+  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 }
+    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
+    end
+    Smartfm::RestClient::Item.add_sound(auth, post_params.merge(:id => self.id))
+  end
+
+  def add_tags(auth, *tags)
+    post_params = {}
+    tags.each_with_index do |tag, idx|
+      if tag.is_a?(String)
+        post_params["semantic_tags[#{idx}][name]"] = tag
+      else
+        post_params["semantic_tags[#{idx}][name]"] = tag[:name]
+        post_params["semantic_tags[#{idx}][disambiguation]"] = tag[:disambiguation]
+      end
+    end
+    Smartfm::RestClient::Item.add_tags(auth, post_params.merge(:id => self.id))
+  end
+
+  protected
+
+  def to_post_data
+    self.validate
+    post_data = {
+      'cue[text]'           => self.cue.text,
+      'cue[language]'       => self.cue.language,
+      'cue[part_of_speech]' => self.cue.part_of_speech,
+      'response[text]'      => self.response.text,
+      'response[language]'  => self.response.language
+    }
+    # Optional attributes
+    if self.list
+      post_data['item[list_id]'] = self.list.id
+    end
+    if response.text_with_character
+      post_data['character_response[text]'] = self.response.character_text
+    end
+    post_data
+  end
+
+  def validate
+    raise ArgumentError.new("Item cue[text] is required.") if self.cue.text.nil? or self.cue.text.empty?
+    raise ArgumentError.new("Item cue[language] is required.") if self.cue.language.nil? or self.cue.language.empty?
+    raise ArgumentError.new("Item cue[part_of_speech] is required.") if self.cue.part_of_speech.nil? or self.cue.part_of_speech.empty?
+    raise ArgumentError.new("Item response[text] is required.") if self.response.text.nil? or self.response.text.empty?
+    raise ArgumentError.new("Item response[language] is required.") if self.response.language.nil? or self.response.language.empty?
+  end
+
+  def response
+    self.responses.first
+  end
+
+end

data/lib/smartfm/model/list.rb

@@ -0,0 +1,138 @@
+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]
+  attr_accessor *(ATTRIBUTES - READONLY_ATTRIBUTES)
+  attr_reader   *READONLY_ATTRIBUTES
+
+  class Application < Smartfm::Base
+    ATTRIBUTES = [:application, :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}"
+    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
+  end
+
+  def initialize(params = {})
+    @id          = (params[:id].to_i rescue nil)
+    @title       = params[:title]
+    @description = params[:description]
+    @icon        = params[:icon]
+    @square_icon = params[:square_icon]
+    @item_count  = (params[:item_count].to_i rescue nil)
+    @user_count  = (params[:user_count].to_i rescue nil)
+    @language    = params[:language]
+    @translation_language = params[:translation_language]
+    if @list_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]
+    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)
+  end
+
+  def items(params = {})
+    hash = Smartfm::RestClient::List.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))
+    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})
+  end
+
+  def delete_item(auth, item)
+    Smartfm::RestClient::List.delete_item(auth, {:list_id => self.id, :id => item.id})
+  end
+
+  protected
+
+  def to_post_data
+    self.validate
+    post_data = {
+      'list[name]'                 => self.title,
+      'list[description]'          => self.description,
+      'list[language]'             => self.language             || 'en',
+      'list[translation_language]' => self.translation_language || 'ja'
+    }
+    # Optional attributes
+    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|
+      if self.send("#{key}")
+        post_data["list[#{key}]"] = self.send("#{key}")
+      end
+    end
+    post_data
+  end
+
+  def validate
+    raise ArgumentError.new("List title is required.")       if self.title.nil?       or self.title.empty?
+    raise ArgumentError.new("List description is required.") if self.description.nil? or self.description.empty?
+  end
+
+end

data/lib/smartfm/model/sentence.rb

@@ -0,0 +1,118 @@
+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/model/user.rb

@@ -0,0 +1,112 @@
+class Smartfm::User < Smartfm::Base
+  ATTRIBUTES = [:username, :profile]
+  attr_reader *ATTRIBUTES
+
+  class Profile < Smartfm::Base
+    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 Study < Smartfm::Base
+    ATTRIBUTES = [:today, :results, :total_summary]
+    attr_reader *ATTRIBUTES
+
+    class Result < Smartfm::Base
+      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
+
+    class TotalSummary < Smartfm::Base
+      ATTRIBUTES = [:studied, :completed, :performance, :best_speed, :best_score]
+      attr_reader *ATTRIBUTES
+
+      def initialize(params = {})
+        @studied     = params[:studied]
+        @completed   = params[:completed]
+        @performance = params[:performance]
+        @best_speed  = params[:best_speed]
+        @best_score  = params[:best_score]
+      end
+    end
+
+    def initialize(params = {})
+      @today         = (Date.parse(params[:today]) rescue nil)
+      @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 self.find(username, params = {})
+    params[:username] = username
+    hash = Smartfm::RestClient::User.find(params)
+    self.deserialize(hash)
+  end
+
+  def self.matching(keyword, params = {})
+    params[:keyword] = keyword
+    hash = Smartfm::RestClient::User.matching(params)
+    self.deserialize(hash) || []
+  end
+
+  def self.username(auth)
+    Smartfm::RestClient::User.username(auth, {})
+  end
+
+  def initialize(params)
+    @profile  = Profile.new(params[:profile])
+    @username = params[:username]
+  end
+
+  def items(params = {})
+    hash = Smartfm::RestClient::User.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))
+    self.deserialize(hash, :as => Smartfm::List) || []
+  end
+
+  def friends(params = {})
+    hash = Smartfm::RestClient::User.friends(params.merge(:username => self.username))
+    self.deserialize(hash) || []
+  end
+
+  def followers(params = {})
+    hash = Smartfm::RestClient::User.followers(params.merge(:username => self.username))
+    self.deserialize(hash) || []
+  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))
+    self.deserialize(hash, :as => Smartfm::User::Study)
+  end
+
+end

data/lib/smartfm/model.rb

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