smartfm 0.3.0

data/lib/smartfm/core/config.rb

@@ -0,0 +1,51 @@
+require 'singleton'
+
+class Smartfm::Config
+  include Singleton
+  ATTRIBUTES = [ :protocol, :host, :port, :api_protocol, :api_host, :api_port, :api_key, :timeout,
+                 :oauth_consumer_key, :oauth_consumer_secret, :oauth_http_method, :oauth_scheme,
+                 :user_agent, :application_name, :application_version, :application_url ]
+  attr_accessor *ATTRIBUTES
+
+  def self.init(&block)
+    conf = Smartfm::Config.instance
+    { :protocol              => 'http',
+      :host                  => 'smart.fm',
+      :port                  => 80,
+      :api_protocol          => 'http',
+      :api_host              => 'api.smart.fm',
+      :api_port              => 80,
+      :api_key               => '',
+      :timeout               => 30,
+      :oauth_consumer_key    => '',
+      :oauth_consumer_secret => '',
+      :oauth_http_method     => :post,
+      :oauth_scheme          => :header,
+      :user_agent            => 'default',
+      :application_name      => 'smart.fm gem',
+      :application_version   => Smartfm::Version.to_version,
+      :application_url       => 'http://github.com/nov/smartfm'
+    }.each do |key, value| conf.send("#{key}=", value) end
+    yield conf if block_given?
+    conf
+  end
+
+  def base_url
+    port = self.port==80 ? nil : ":#{self.port}"
+    "#{self.protocol}://#{self.host}#{port}"
+  end
+
+  def api_base_url
+    port = self.api_port==80 ? nil : ":#{self.api_port}"
+    "#{self.api_protocol}://#{self.api_host}#{port}"
+  end
+
+  # hack: Object.timeout is already defined..
+  def self.timeout
+    instance.timeout
+  end
+
+  def self.method_missing(method, *args)
+    Smartfm::Config.instance.send(method, *args)
+  end
+end

data/lib/smartfm/core/version.rb

@@ -0,0 +1,14 @@
+module Smartfm::Version
+  MAJOR = 0
+  MINOR = 3
+  REVISION = 0
+  class << self
+    def to_version
+      "#{MAJOR}.#{MINOR}.#{REVISION}"
+    end
+    
+    def to_name
+      "#{MAJOR}_#{MINOR}_#{REVISION}"
+    end
+  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'

data/lib/smartfm/model/base.rb

@@ -0,0 +1,26 @@
+class Smartfm::Base
+
+  def self.attributes; self::ATTRIBUTES end
+
+  def attributes; self.class.attributes  end
+
+  def self.deserialize(hash, params = {})
+    return nil if hash.nil?
+
+    klass = params[:as] ? params[:as] : self
+    if hash.is_a?(Array)
+      hash.inject([]) { |results, hash|
+        hash.symbolize_keys!
+        results << klass.new(hash)
+      }
+    else
+      hash.symbolize_keys!
+      klass.new(hash)
+    end
+  end
+
+  def deserialize(hash, params = {})
+    self.class.deserialize(hash, params)
+  end
+
+end

data/lib/smartfm/model/item.rb

@@ -0,0 +1,174 @@
+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)
+    self.deserialize(hash) || []
+  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