smartfm 0.4.0 → 1.0.0

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 → models}/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 → models}/item_spec.rb

@@ -2,15 +2,25 @@ require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
 smart = Smartfm::Item.find(33158, :include_sentences => true)
 
-describe Smartfm::Item do
-  it "should respond to attribute methods" do
-    Smartfm::Item::ATTRIBUTES.each do |attr|
+Smartfm::Item::ATTRIBUTES.each do |attr|
+  describe Smartfm::Item, "##{attr}" do
+    it "should be accessible" do
       smart.should respond_to(attr)
     end
-    Smartfm::Item::Response::ATTRIBUTES.each do |attr|
+  end
+end
+
+Smartfm::Item::Response::ATTRIBUTES.each do |attr|
+  describe Smartfm::Item::Response, "##{attr}" do
+    it "should be accessible" do
       smart.responses.first.should respond_to(attr)
     end
-    Smartfm::Item::Cue::ATTRIBUTES.each do |attr|
+  end
+end
+
+Smartfm::Item::Cue::ATTRIBUTES.each do |attr|
+  describe Smartfm::Item::Cue, "##{attr}" do
+    it "should be accessibles" do
       smart.cue.should respond_to(attr)
     end
   end
@@ -39,3 +49,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/models/like_spec.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+matake_likes = Smartfm::User.find('matake').likes
+
+Smartfm::Like::ATTRIBUTES.each do |attr|
+  describe Smartfm::Like, "##{attr}" do
+    it "should be accessible" do
+      matake_likes.first.should respond_to(attr)
+    end
+  end
+end
+
+Smartfm::Like::ATTRIBUTES.each do |attr|
+  describe Smartfm::Like, "##{attr}" do
+    it "should not be nil" do
+      matake_likes.first.should_not be_nil
+    end
+  end
+end