smartfm 0.3.0

data/lib/smartfm/model/user.rb

@@ -0,0 +1,108 @@
+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 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/rest_client.rb

@@ -0,0 +1,8 @@
+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/base.rb

@@ -0,0 +1,173 @@
+require 'timeout'
+
+class Smartfm::RestClient::Base
+
+  class RESTError < Exception
+    attr_accessor :code, :message
+
+    def initialize(params = {})
+      self.code    = params[:code]
+      self.message = params[:message]
+    end
+
+    def to_s
+      "HTTP #{@code}: #{@message}"
+    end
+  end
+
+  def self.valid_action?(action) ; self::ACTIONS.keys.include? action.to_sym          end
+  def self.path(action)          ; self::ACTIONS[action.to_sym][:path]                end
+  def self.http_method(action)   ; self::ACTIONS[action.to_sym][:http_method] || :get end
+
+  def self.method_missing(action, *args)
+    # GET methods are handled here
+    # POST and DELETE methods should be implemented in each class
+    super unless self.valid_action?(action)
+    case self.http_method(action)
+    when :get
+      path, params = path_with_params(self.path(action), args[0])
+      http_get(path, params)
+    when :post
+      path, params = path_with_params(self.path(action), args[1])
+      http_post(auth(args[0]), path, params)
+    when :delete
+      path, params = path_with_params(self.path(action), args[1])
+      http_delete(auth(args[0]), path, params)
+    end
+  end
+
+  private
+
+  def self.config; Smartfm::Config end
+
+  def self.auth(auth)
+    if auth.is_a?(Smartfm::Auth)
+      auth
+    else
+      raise ArgumentError.new("Authorized Smartfm::Auth instance is required")
+    end
+  end
+
+  def self.api_key_required
+    raise ArgumentError.new("smart.fm API key is required") if self.config.api_key == ''
+  end
+
+  def self.raise_rest_error(response)
+    raise RESTError.new(:code => response.code, :message => response.message)
+  end
+
+  def self.handle_rest_response(response, format)
+    raise_rest_error(response) unless response.is_a?(Net::HTTPSuccess)
+    case format
+    when :json
+      handle_json_response(response.body)
+    when :nothing
+      # success => nothing / failure => json error
+      begin
+        handle_json_response(response.body)
+      rescue Exception => e
+        e.is_a?(RESTError) ? raise(e) : :success
+      end
+    else  
+      begin
+        handle_json_response(response.body)
+      rescue Exception => e
+        e.is_a?(RESTError) ? raise(e) : response.body
+      end
+    end
+  end
+
+  def self.handle_json_response(json_response)
+    hash = JSON.parse(json_response)
+    unless (hash['error'].nil? rescue :success) # success response may be Array, not Hash.
+      if hash['error']['code'] == 404
+        return nil
+      else
+        raise RESTError.new(:code => hash['error']['code'], :message => hash['error']['message'])
+      end
+    end
+    hash
+  end
+
+  def self.http_header
+    @@http_header ||= {
+      'User-Agent' => "#{self.config.application_name} v#{Smartfm::Version.to_version} [#{self.config.user_agent}]",
+      'Accept'     => 'text/x-json',
+      'X-smartfm-Gem-Client'         => self.config.application_name,
+      'X-smartfm-Gem-Client-Version' => self.config.application_version,
+      'X-smartfm-Gem-Client-URL'     => self.config.application_url,
+    }
+  end
+
+  def self.http_connect
+    http = Net::HTTP.new(self.config.api_host, self.config.api_port)
+    http.start do |conn|
+      request, format = yield
+      begin
+        timeout(self.config.timeout) do
+          response = conn.request(request)
+          handle_rest_response(response, format)
+        end
+      rescue
+        raise RESTError.new(:code => 408, :message => "smart.fm Gem Timeout (#{self.config.timeout} [sec])")
+      end
+    end
+  end
+
+  def self.path_with_params(path, params = {})
+    path_with_params = path.clone
+    unless params.empty?
+      params.each do |key, value|
+        if path_with_params=~/__#{key}__/
+          path_with_params.sub!(/__#{key}__/, URI.encode(value.to_s))
+          params.delete(key)
+        end
+      end
+    end
+    return path_with_params, params
+  end
+
+  def self.http_get(path, params = {})
+    http_connect do
+      params.merge!(:api_key => self.config.api_key) unless self.config.api_key == ''
+      path = (params.size > 0) ? "#{path}?#{params.to_http_str}" : path
+      get_req = Net::HTTP::Get.new(path, http_header)
+      [get_req, :json]
+    end
+  end
+
+  def self.http_post(auth, path, params = {})
+    self.api_key_required
+    params.merge!(:api_key => self.config.api_key)
+    case auth.mode
+    when :oauth
+      response = auth.auth_token.post(path, params, http_header)
+      handle_rest_response(response, :text)
+    when :basic_auth
+      http_connect do
+        post_req = Net::HTTP::Post.new(path, http_header)
+        post_req.body = params.to_http_str
+        post_req.basic_auth(auth.account.username, auth.account.password)
+        [post_req, :text]
+      end
+    end
+  end
+
+  def self.http_delete(auth, path, params = {})
+    self.api_key_required
+    params.merge!(:api_key => self.config.api_key)
+    case auth.mode
+    when :oauth
+      response = auth.auth_token.delete(path, params.stringfy_keys!.stringfy_values!)
+      handle_rest_response(response, :nothing)
+    when :basic_auth
+      http_connect do
+        delete_req = Net::HTTP::Post.new(path, http_header)
+        delete_req.body = params.merge(:_method => 'DELETE').to_http_str
+        delete_req.basic_auth(auth.account.username, auth.account.password)
+        [delete_req, :nothing]
+      end
+    end
+  end
+
+end

data/lib/smartfm/rest_client/item.rb

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,13 @@
+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__'   }
+  }
+
+end

data/spec/ext/hash_spec.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Hash, "#to_http_str" do
+  before do
+    @params = {:page => 3, :per_page => 100}
+  end
+  it "should return http_parameter as String" do
+    @params.to_http_str.should be_a(String)
+    @params.to_http_str.should match(/^(page=3&per_page=100|per_page=100&page=3)$/)
+  end
+end

data/spec/smartfm/core/auth_spec.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+basic_auth_params = { :username => 'matake', :password => 'password' }
+oauth_params      = { :token => '1a2b3c4d5', :secret => 'z0y9x8w7v6' }
+
+describe Smartfm::Auth, '.new' do
+  before do
+    @basic_auth = Smartfm::Auth.new(basic_auth_params)
+    @oauth      = Smartfm::Auth.new(oauth_params)
+  end
+
+  it "should choose #{:basic_auth} mode" do
+    @basic_auth.mode.should equal(:basic_auth)
+    @basic_auth.should respond_to(:account)
+    @basic_auth.account.should respond_to(:username)
+    @basic_auth.account.should respond_to(:password)
+    @basic_auth.account.should_not respond_to(:token)
+    @basic_auth.account.should_not respond_to(:secret)
+  end
+
+  it "should choose #{:oauth} mode" do
+    @oauth.mode.should equal(:oauth)
+    @oauth.should respond_to(:auth_token)
+    @oauth.auth_token.should respond_to(:token)
+    @oauth.auth_token.should respond_to(:secret)
+    @oauth.auth_token.should_not respond_to(:username)
+    @oauth.auth_token.should_not respond_to(:password)
+  end
+end
+
+describe Smartfm::Auth, '.consumer' do
+  it "should be an instance of OAuth::Consumer" do
+    Smartfm::Auth.consumer.should be_a(OAuth::Consumer)
+  end
+
+  it "should be for http://api.smart.fm" do
+    Smartfm::Auth.consumer.site.should eql("http://api.smart.fm")
+  end
+end

data/spec/smartfm/core/config_spec.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Smartfm::Config, ".init" do
+  before do
+    Smartfm::Config.init
+  end
+
+  it "should return init config" do
+    Smartfm::Config.init.should equal(Smartfm::Config.instance)
+  end
+
+  it "should change config with block" do
+    Smartfm::Config.init do |conf|
+      Smartfm::Config::ATTRIBUTES.each do |method|
+        conf.send("#{method}=", "fuckin_windows!")
+      end
+    end
+    Smartfm::Config::ATTRIBUTES.each do |method|
+      Smartfm::Config.send("#{method}").should eql("fuckin_windows!")
+    end
+  end
+
+  after do
+    Smartfm::Config.init
+  end
+end
+
+(Smartfm::Config::ATTRIBUTES + [:base_url, :api_base_url]).each do |method|
+  describe Smartfm::Config, ".#{method}" do
+    it "should be same with Smartfm::Config.instance.#{method}" do
+      Smartfm::Config.send(method).should eql(Smartfm::Config.instance.send(method))
+    end
+  end
+end

data/spec/smartfm/core/version_spec.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+version_params = [Smartfm::Version::MAJOR, Smartfm::Version::MINOR, Smartfm::Version::REVISION]
+expected = {
+  :version => version_params.join('.'),
+  :name    => version_params.join('_')
+}
+
+describe Smartfm::Version, ".to_version" do
+  it "should return #{expected[:version]}" do
+    Smartfm::Version.to_version.should eql(expected[:version])
+  end
+end
+
+describe Smartfm::Version, ".to_name" do
+  it "should return #{expected[:name]}" do
+    Smartfm::Version.to_name.should eql(expected[:name])
+  end
+end