nov-smartfm 0.4.0

data/lib/smartfm/rest_client/base.rb

@@ -0,0 +1,194 @@
+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
+      if args[0].is_a?(Smartfm::Auth)
+        path, params = path_with_params(self.path(action), args[1])
+        http_get_with_auth(auth(args[0]), path, params)
+      else
+        path, params = path_with_params(self.path(action), args[0])
+        http_get(path, params)
+      end
+    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_get_with_auth(auth, path, params = {})
+    params.merge!(:api_key => self.config.api_key) unless self.config.api_key == ''
+    path = (params.size > 0) ? "#{path}?#{params.to_http_str}" : path
+    case auth.mode
+    when :oauth
+      response = auth.auth_token.get(path, http_header)
+      handle_rest_response(response, :text)
+    when :basic_auth
+      http_connect do
+        get_req = Net::HTTP::Get.new(path, http_header)
+        get_req.basic_auth(auth.account.username, auth.account.password)
+        [get_req, :text]
+      end
+    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)
+    path = "#{path}?#{params.to_http_str}"
+    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::Delete.new(path, http_header)
+        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,14 @@
+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__'   },
+    :username      => { :path => '/sessions'                     }
+  }
+
+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.rb

@@ -0,0 +1,16 @@
+module Smartfm
+end
+
+require 'date'
+require 'net/https'
+require 'uri'
+
+require 'rubygems'
+require 'json'
+
+require 'ext/hash'
+require 'smartfm/core'
+require 'smartfm/rest_client'
+require 'smartfm/model'
+
+Smartfm::Config.init

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

data/spec/smartfm/model/base_spec.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+subclasses = [ Smartfm::Item, Smartfm::List, Smartfm::Sentence, Smartfm::User ]
+
+subclasses.each do |klass|
+
+  describe klass, '.attributes' do
+    it "should return Array of attributes" do
+      klass.attributes.should be_a(Array)
+    end
+  end
+
+  describe klass, '.find' do
+    it "should return nil if NOT FOUND" do
+      klass.find(-1).should be_nil
+    end
+  end
+
+  if klass.respond_to?(:recent)
+    describe klass, '.recent' do
+      it "should return Array" do
+        klass.recent.should be_a(Array)
+        # blank response should be []
+        klass.recent(:per_page => 20, :page => 100000000000000).should be_empty
+        klass.recent(:per_page => 20, :page => 100000000000000).should_not be_nil
+      end
+    end
+  end
+  
+  if klass.respond_to?(:matching)
+    describe klass, '.recent' do
+      it "should return Array" do
+        klass.matching("hello").should be_a(Array)
+        klass.matching(rand_string).should be_empty
+        klass.matching(rand_string).should_not be_nil
+      end
+    end
+  end
+
+end

data/spec/smartfm/model/item_spec.rb

@@ -0,0 +1,41 @@
+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|
+      smart.should respond_to(attr)
+    end
+    Smartfm::Item::Response::ATTRIBUTES.each do |attr|
+      smart.responses.first.should respond_to(attr)
+    end
+    Smartfm::Item::Cue::ATTRIBUTES.each do |attr|
+      smart.cue.should respond_to(attr)
+    end
+  end
+end
+
+describe Smartfm::Item, '#cue' do
+  it "should return a instance o Smartfm::Item::Cue" do
+    smart.cue.should be_a(Smartfm::Item::Cue)
+  end
+end
+
+describe Smartfm::Item, '#responses' do
+  it "should return a Array of Smartfm::Item::Response" do
+    smart.responses.should be_a(Array)
+    smart.responses.each do |response|
+      response.should be_a(Smartfm::Item::Response)
+    end
+  end
+end
+
+describe Smartfm::Item, '#sentences' do
+  it "should return a Array of Smartfm::Sentence" do
+    smart.sentences.should be_a(Array)
+    smart.sentences.each do |sentence|
+      sentence.should be_a(Smartfm::Sentence)
+    end
+  end
+end

data/spec/smartfm/model/list_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe String do
+  it "should respond to length" do
+    "hoge".should respond_to(:length)
+  end
+end

data/spec/smartfm/model/sentence_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe String do
+  it "should respond to length" do
+    "hoge".should respond_to(:length)
+  end
+end

data/spec/smartfm/model/user_spec.rb

@@ -0,0 +1,90 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+matake = Smartfm::User.find('matake')
+
+describe Smartfm::User do
+  it "should respond to attribute methods" do
+    Smartfm::User::ATTRIBUTES.each do |attr|
+      matake.should respond_to(attr)
+    end
+    Smartfm::User::Profile::ATTRIBUTES.each do |attr|
+      matake.profile.should respond_to(attr)
+    end
+    Smartfm::User::Study::ATTRIBUTES.each do |attr|
+      matake.study.should respond_to(attr)
+    end
+    Smartfm::User::Study::Result::ATTRIBUTES.each do |attr|
+      matake.study.results.each do |result|
+        result.should respond_to(attr)
+      end
+    end
+    Smartfm::User::Study::TotalSummary::ATTRIBUTES.each do |attr|
+      matake.study.total_summary.should respond_to(attr)
+    end
+  end
+end
+
+describe Smartfm::User, '#items' do
+  it "should return a Array of Smartfm::Item or []" do
+    matake.items.should be_a(Array)
+    matake.items.each do |item|
+      item.should be_a(Smartfm::Item)
+    end
+    matake.items(:page => 10000000000).should be_empty
+    matake.items(:page => 10000000000).should_not be_nil
+  end
+end
+
+describe Smartfm::User, '#lists' do
+  it "should return a Array of Smartfm::List or []" do
+    matake.lists.should be_a(Array)
+    matake.lists.each do |list|
+      list.should be_a(Smartfm::List)
+    end
+    matake.lists(:page => 10000000000).should be_empty
+    matake.lists(:page => 10000000000).should_not be_nil
+  end
+end
+
+describe Smartfm::User, '#friends' do
+  it "should return a Array of Smartfm::User" do
+    matake.friends.should be_a(Array)
+    matake.friends.each do |friend|
+      friend.should be_a(Smartfm::User)
+    end
+  end
+end
+
+describe Smartfm::User, '#followers' do
+  it "should return a Array of Smartfm::User" do
+    matake.followers.should be_a(Array)
+    matake.followers.each do |follower|
+      follower.should be_a(Smartfm::User)
+    end
+  end
+end
+
+describe Smartfm::User, '#study' do
+  it "should return a instance of Smartfm::User::Study" do
+    matake.study.should be_a(Smartfm::User::Study)
+    matake.study(:application => 'iknow').should be_a(Smartfm::User::Study)
+    matake.study(:application => 'dictation').should be_a(Smartfm::User::Study)
+    matake.study(:application => 'brainspeed').should be_a(Smartfm::User::Study)
+    matake.study(:application => 'fuckin_windows').should be_nil
+  end
+end
+
+describe Smartfm::User::Study, '#results' do
+  it "should return a Array of Smartfm::User::Study::Result" do
+    matake.study.results.should be_a(Array)
+    matake.study.results.each do |result|
+      result.should be_a(Smartfm::User::Study::Result)
+    end
+  end
+end
+
+describe Smartfm::User::Study, '#total_summary' do
+  it "should return a Array of Smartfm::User::Study::TotalSummary" do
+    matake.study.total_summary.should be_a(Smartfm::User::Study::TotalSummary)
+  end
+end

data/spec/smartfm/rest_client/base_spec.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+subclasses = [ Smartfm::RestClient::Item, Smartfm::RestClient::List, Smartfm::RestClient::Sentence, Smartfm::RestClient::User ]
+
+describe Smartfm::RestClient::Base do
+  it "should be a Class" do
+    true
+  end
+end

data/spec/smartfm/rest_client/item_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Smartfm::RestClient::Item, '::ACTIONS' do
+  it "should be a Hash" do
+    Smartfm::RestClient::Item::ACTIONS.should be_a(Hash)
+  end
+end

data/spec/smartfm/rest_client/list_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Smartfm::RestClient::List, '::ACTIONS' do
+  it "should be a Hash" do
+    Smartfm::RestClient::List::ACTIONS.should be_a(Hash)
+  end
+end

data/spec/smartfm/rest_client/sentence_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Smartfm::RestClient::Sentence, '::ACTIONS' do
+  it "should be a Hash" do
+    Smartfm::RestClient::Sentence::ACTIONS.should be_a(Hash)
+  end
+end

data/spec/smartfm/rest_client/user_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Smartfm::RestClient::User, '::ACTIONS' do
+  it "should be a Hash" do
+    Smartfm::RestClient::User::ACTIONS.should be_a(Hash)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
+require File.join(File.dirname(__FILE__), '..', 'lib', 'smartfm')
+
+def be_a(klass)
+  be_is_a(klass)
+end
+
+def rand_string(length = 100)
+  chars = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
+  Array.new(length){ chars[rand(chars.size)] }.join
+end

data/test/smartfm_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+require "test/unit"
+class SmartfmTest < Test::Unit::TestCase
+  def test_truth
+    true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/smartfm'
+