ribose 0.4.1 → 0.5.0

data/lib/ribose/actions/create.rb

@@ -23,7 +23,7 @@ module Ribose
       end
 
       def request_body(attributes)
-        custom_option.merge(resource_key.to_sym => validate(attributes))
+        custom_option.merge(resource_key.to_sym => validate(**attributes))
       end
 
       def create_resource

data/lib/ribose/client.rb

@@ -1,14 +1,9 @@
 module Ribose
   class Client
-    attr_accessor :api_token, :api_email, :user_email,
-                  :client_id, :uid, :access_token
+    attr_accessor :api_email, :api_token, :access_token, :uid, :client_id
 
     def initialize(options = {})
-      @api_token    = options.fetch(:api_token, configuration.api_token).to_s
-      @api_email    = options.fetch(:api_email, configuration.api_email).to_s
-      @client_id    = options[:client_id]
-      @uid          = options[:uid]
-      @access_token = options[:access_token]
+      initialize_client_details(options)
     end
 
     # Initiate a ribose client
@@ -23,20 +18,17 @@ module Ribose
     # @param :api_token [String] The authentication token for your API account
     # @return [Ribose::Client] A new client with your details
     #
-    def self.from_login(email:, password:, api_email:, api_token:)
-      session = Session.create(
-        username: email,
-        password: password,
-        api_email: api_email,
-        api_token: api_token
+    def self.from_login(email:, password:)
+      session = Ribose::Session.create(
+        username: email, password: password,
       )
 
       new(
-        api_email:    api_email,
-        api_token:    api_token,
-        client_id:    session.nil? ? nil : session['client'],
-        uid:          session.nil? ? nil : session['uid'],
-        access_token: session.nil? ? nil : session['access-token'],
+        api_email: email,
+        uid: session.uid,
+        client_id: session.client,
+        api_token: session["access-token"],
+        access_token: session["access-token"],
       )
     end
 
@@ -45,5 +37,13 @@ module Ribose
     def configuration
       Ribose.configuration
     end
+
+    def initialize_client_details(options)
+      @uid = options.fetch(:uid, nil)
+      @client_id = options.fetch(:client_id, nil)
+      @access_token = options.fetch(:access_token, nil)
+      @api_email = options.fetch(:api_email, configuration.api_email)
+      @api_token = options.fetch(:api_token, configuration.api_token)
+    end
   end
 end

data/lib/ribose/configuration.rb

@@ -2,15 +2,13 @@ require "ribose/response/raise_error"
 
 module Ribose
   class Configuration
-    attr_accessor :api_host, :api_email, :api_token,
-                  :user_email, :user_password,
-                  :verify_ssl,
-                  :debug_mode
+    attr_accessor :api_email, :verify_ssl, :client, :api_host,
+                  :api_token, :user_email, :user_password, :debug_mode
 
     def initialize
       @debug_mode = false
       @verify_ssl = true
-      @api_host ||= "https://www.ribose.com"
+      @api_host ||= "www.ribose.com"
     end
 
     def debug_mode?
@@ -21,8 +19,14 @@ module Ribose
       !!verify_ssl
     end
 
-    def ssl_verification_mode
-      verify_ssl? ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+    def api_email
+      @user_email || @api_email
+    end
+
+    def client
+      @client ||= Ribose::Client.from_login(
+        email: api_email, password: user_password,
+      )
     end
 
     def add_default_middleware(builder)
@@ -30,5 +34,9 @@ module Ribose
       builder.response(:logger, nil, bodies: true) if debug_mode?
       builder.adapter(Faraday.default_adapter)
     end
+
+    def ssl_verification_mode
+      verify_ssl? ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+    end
   end
 end

data/lib/ribose/event.rb

@@ -12,7 +12,7 @@ module Ribose
     # @return [Sawyer::Resource] Calendar Events
     #
     def self.all(calendar_id, options = {})
-      Ribose::Calendar.fetch(calendar_id, options)
+      Ribose::Calendar.fetch(calendar_id, **options)
     end
 
     # Fetch a calendar event

data/lib/ribose/file_uploader.rb

@@ -31,7 +31,7 @@ module Ribose
     # @param attributes [Hash] Attributes as a Hash
     # @return [Sawyer::Resource] File upload response.
     def self.upload(space_id, file:, **attributes)
-      new(space_id, attributes.merge(file: file)).create
+      new(space_id, **attributes.merge(file: file)).create
     end
 
     private

data/lib/ribose/file_version.rb

@@ -16,12 +16,11 @@ module Ribose
     # @returns [Sawyer::Resource] The file version
     #
     def self.fetch(space_id:, file_id:, version_id:, **options)
-      new(
-        file_id: file_id,
-        space_id: space_id,
-        resource_id: version_id,
-        **options,
-      ).fetch
+      options = options.merge(
+        file_id: file_id, space_id: space_id, resource_id: version_id,
+      )
+
+      new(options).fetch
     end
 
     # Download file version
@@ -32,12 +31,11 @@ module Ribose
     # @param options [Hash] Options as key and value pair
     #
     def self.download(space_id, file_id, version_id:, **options)
-      new(
-        file_id: file_id,
-        space_id: space_id,
-        resource_id: version_id,
-        **options,
-      ).download
+      options = options.merge(
+        file_id: file_id,space_id: space_id, resource_id: version_id,
+      )
+
+      new(options).download
     end
 
     # Create a new file version
@@ -49,10 +47,8 @@ module Ribose
     # @return [Sawyer::Resource] Newly updated version
     #
     def self.create(space_id, file_id, file:, **attributes)
-      upload = VersionUploader.upload(
-        space_id, file_id, attributes.merge(file: file)
-      )
-
+      attributes = attributes.merge(file: file)
+      upload = VersionUploader.upload(space_id, file_id, **attributes)
       upload[:attachment]
     end
 

data/lib/ribose/request.rb

@@ -1,7 +1,7 @@
 module Ribose
   class Request
-
     DEFAULT_CONTENT_TYPE = "application/json"
+
     # Initialize a Request
     #
     # @param http_method [Symbol] HTTP verb as sysmbol
@@ -9,7 +9,7 @@ module Ribose
     # @param data [Hash] Attributes / Options as a Hash
     # @return [Ribose::Request]
     #
-    def initialize(http_method, endpoint, **data)
+    def initialize(http_method, endpoint, data = {})
       @data = data
       @endpoint = endpoint
       @http_method = http_method
@@ -26,11 +26,7 @@ module Ribose
       options[:query] = extract_config_option(:query) || {}
 
       response = agent.call(http_method, api_endpoint, data, options)
-
-      # update client headers from response
-      client.client_id    = response.headers['client']
-      client.uid          = response.headers['uid']
-      client.access_token = response.headers['access-token']
+      update_client_headers(response.headers)
 
       parsable == true ? response.data : response
     end
@@ -79,7 +75,7 @@ module Ribose
     attr_reader :client, :data, :http_method
 
     def ribose_host
-      Ribose.configuration.api_host.host
+      Ribose.configuration.api_host
     end
 
     def extract_config_option(key)
@@ -89,13 +85,7 @@ module Ribose
     end
 
     def find_suitable_client
-      # client = extract_config_option(:client) || Ribose::Client.new
-      client = extract_config_option(:client) ||
-               Ribose::Client.from_login(
-                 email:     Ribose.configuration.user_email,
-                 password:  Ribose.configuration.user_password,
-                 api_token: Ribose.configuration.api_token
-               )
+      client = extract_config_option(:client) || Ribose.configuration.client
       client.is_a?(Ribose::Client) ? client : raise(Ribose::Unauthorized)
     end
 
@@ -119,13 +109,12 @@ module Ribose
       unless Ribose.configuration.verify_ssl?
         faraday_options.merge!(ssl: Faraday::SSLOptions.new(
           false, nil, nil, OpenSSL::SSL::VERIFY_NONE
-          )
-        )
+        ))
       end
 
       {
-        links_parser: Sawyer::LinkParsers::Simple.new,
         faraday: Faraday.new(faraday_options),
+        links_parser: Sawyer::LinkParsers::Simple.new,
       }
     end
 
@@ -135,21 +124,10 @@ module Ribose
       end
     end
 
-    def set_content_type(headers)
-      header = custom_content_headers
-
-      headers[:content_type] = DEFAULT_CONTENT_TYPE
-      headers[:accept] = header.fetch(:accept, DEFAULT_CONTENT_TYPE)
-    end
-
     def agent
       @agent ||= Sawyer::Agent.new(ribose_host, sawyer_options) do |http|
         set_content_type(http.headers)
-
-        # set headers for devise-token-auth
-        http.headers["access-token"] = client.access_token
-        http.headers["client"]       = client.client_id
-        http.headers["uid"]          = client.uid
+        set_devise_specific_headers(http.headers)
 
         if require_auth_headers?
           http.headers["X-Indigo-Token"] = client.api_token
@@ -157,5 +135,24 @@ module Ribose
         end
       end
     end
+
+    def update_client_headers(headers)
+      client.uid = headers["uid"]
+      client.client_id = headers["client"]
+      client.access_token = headers["access-token"]
+    end
+
+    def set_content_type(headers)
+      headers[:content_type] = DEFAULT_CONTENT_TYPE
+      headers[:accept] = custom_content_headers.fetch(
+        :accept, DEFAULT_CONTENT_TYPE
+      )
+    end
+
+    def set_devise_specific_headers(headers)
+      headers["uid"] = client.uid
+      headers["client"] = client.client_id
+      headers["access-token"] = client.access_token
+    end
   end
 end

data/lib/ribose/response/raise_error.rb

@@ -3,8 +3,6 @@ require "ribose/error"
 module Ribose
   module Response
     class RaiseError < Faraday::Response::Middleware
-      private
-
       def on_complete(response)
         if error = Ribose::Error.from_response(response)
           raise error

data/lib/ribose/session.rb

@@ -1,62 +1,72 @@
-require "json"
-require 'net/http'
-require 'uri'
-require "ribose/config"
+require "uri"
+require "ostruct"
+require "net/http"
 
 module Ribose
   class Session
-    def initialize(username, password, api_email, api_token)
-      @username  = username
-      @password  = password
-      @api_email = api_email
-      @api_token = api_token
+    def initialize(username, password)
+      @username = username
+      @password = password
     end
 
     def create
       authenticate_user
+    rescue NoMethodError, JSON::ParserError
+      raise Ribose::Unauthorized
     end
 
-    def self.create(username:, password:, api_email:, api_token:)
-      new(username, password, api_email, api_token).create
+    def self.create(username:, password:)
+      new(username, password).create
     end
 
     private
 
-    attr_reader :username, :password, :api_email, :api_token
+    attr_reader :username, :password
 
     def authenticate_user
-      uri = URI.parse(ribose_url_for("api/v2/auth/sign_in"))
-      response = Net::HTTP.start(
-        uri.host,
-        uri.port,
-        use_ssl: true,
-        verify_mode: Ribose.configuration.ssl_verification_mode
-      ) do |http|
-        request = Net::HTTP::Post.new(uri)
-        # set request headers
-        request['X-Indigo-Username'] = api_email
-        request['X-Indigo-Token']    = api_token
-        request['Content-Type']      = 'application/json'
-
-        # set form data
-        request.set_form_data(
-          'username' => username,
-          'password' => password
-        )
+      response = submit_user_login_request
+
+      case response
+      when Net::HTTPSuccess
+        build_session_data(response.each_header.to_h)
+      when Net::HTTPForbidden
+        raise(Ribose::Unauthorized)
+      end
+    end
+
+    def submit_user_login_request
+      Net::HTTP.start(login_uri.host, login_uri.port, http_options) do |http|
+        request = Net::HTTP::Post.new(login_uri)
+
+        request["Content-Type"] = "application/json"
+        request.set_form_data(username: username, password: password)
+
         http.request(request)
       end
+    end
 
-      # return response headers in hash if success
-      return response.each_header.to_h if response.is_a? Net::HTTPSuccess
-      nil
+    def api_host
+      api_host = Ribose.configuration.api_host
+
+      unless api_host[/\Ahttp:\/\//] || api_host[/\Ahttps:\/\//]
+        "https://#{api_host}"
+      end
+    end
+
+    def login_uri
+      @login_uri ||= URI.parse([api_host, "api/v2/auth/sign_in"].join("/"))
     end
 
-    def agent
-      @agent ||= Mechanize.new
+    def http_options
+      { use_ssl: true, verify_ssl: Ribose.configuration.ssl_verification_mode }
     end
 
-    def ribose_url_for(*endpoint)
-      [Ribose.configuration.api_host, *endpoint].join("/")
+    def build_session_data(headers)
+      SessionData.new(headers.slice("uid", "expiry", "client", "access-token"))
     end
   end
+
+  class SessionData < ::OpenStruct
+    alias :read_attribute_for_serialization :send
+  end
 end

data/lib/ribose/space_file.rb

@@ -57,7 +57,7 @@ module Ribose
     # @return [Sawyer::Resource] The file upload response.
     #
     def self.create(space_id, file:, **attributes)
-      upload = FileUploader.upload(space_id, attributes.merge(file: file))
+      upload = FileUploader.upload(space_id, **attributes.merge(file: file))
       upload[:attachment]
     end
 

data/lib/ribose/version.rb

@@ -1,3 +1,3 @@
 module Ribose
-  VERSION = "0.4.1".freeze
+  VERSION = "0.5.0".freeze
 end

data/lib/ribose/version_uploader.rb

@@ -8,7 +8,7 @@ module Ribose
     end
 
     def self.upload(space_id, file_id, file:, **attributes)
-      new(space_id, file_id, attributes.merge(file: file)).create
+      new(space_id, file_id, **attributes.merge(file: file)).create
     end
 
     private

data/ribose.gemspec

@@ -28,5 +28,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "pry"
-  spec.add_development_dependency "webmock", "~> 2.0"
+  spec.add_development_dependency "webmock", "~> 3.0"
 end

data/spec/ribose/client_spec.rb

@@ -7,42 +7,41 @@ RSpec.describe Ribose::Client do
         client = Ribose::Client.new
 
         expect(client.api_token).to eq(Ribose.configuration.api_token)
-        expect(client.user_email).to eq(Ribose.configuration.user_email)
+        expect(client.api_email).to eq(Ribose.configuration.api_email)
       end
     end
 
     context "custom attribtues provided" do
       it "initialize with the supplied attribtues" do
-        client = Ribose::Client.new(token: 123, email: "john@ex.com")
+        email = "john@ex.com"
+        token = "SECRET_API_TOKEN"
+        client = Ribose::Client.new(api_token: token, api_email: email)
 
-        expect(client.api_token).to eq("123")
-        expect(client.user_email).to eq("john@ex.com")
+        expect(client.api_token).to eq(token)
+        expect(client.api_email).to eq(email)
       end
     end
   end
 
   describe ".from_login" do
     it "authenticate the user and build a client" do
-      email = "useremail@example..com"
-      password = "supersecretpassword"
+      email = "user.email@gmail.com"
+      password = "supser.secrect.password"
 
-      allow(Ribose::Session).to receive(:create).and_return(session_hash)
+      allow(Ribose::Session).to receive(:create).and_return(session)
       client = Ribose::Client.from_login(email: email, password: password)
 
-      expect(client.user_email).to eq(email)
-      expect(client.api_token).to eq(session_hash["authentication_token"])
+      expect(client.api_email).to eq(email)
+      expect(client.uid).to eq(session.uid)
+      expect(client.client_id).to eq(session.client)
     end
   end
 
-  def session_hash
-    {
-      "authentication_token" => "SecretToken",
-      "last_activity" => {
-        "id" => 122072207,
-        "session_id" => "SessionId",
-        "browser" => "Ribose Ruby Client",
-        "user_id" => "user-uuid-123-4567"
-      },
-    }
+  def session
+    @session ||= Ribose::SessionData.new(
+      uid: "hello",
+      expiry: Time.now + 3600,
+      client: "RIBOSE_RUBY_CLIENT",
+    )
   end
 end

data/spec/ribose/config_spec.rb

@@ -20,7 +20,6 @@ RSpec.describe Ribose::Config do
       expect(Ribose.configuration.debug_mode?).to be_falsey
       expect(Ribose.configuration.api_token).to eq(api_token)
       expect(Ribose.configuration.user_email).to eq(user_email)
-      expect(Ribose.configuration.web_url).to eq ["https", api_host].join("://")
     end
   end
 

data/spec/ribose/file_uploader_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe Ribose::FileUploader do
         space_id = 123_456_789
 
         stub_ribose_space_file_upload_api(space_id, file_attributes)
-        file_upload = Ribose::FileUploader.upload(space_id, file_attributes)
+        file_upload = Ribose::FileUploader.upload(space_id, **file_attributes)
 
         expect(file_upload.attachment.id).not_to be_nil
         expect(file_upload.attachment.author).to eq("John Doe")
@@ -21,7 +21,7 @@ RSpec.describe Ribose::FileUploader do
         attributes = file_attributes(File.join(Ribose.root, "Rakefile"))
 
         stub_ribose_space_file_upload_api(space_id, attributes)
-        file_upload = Ribose::FileUploader.upload(space_id, attributes)
+        file_upload = Ribose::FileUploader.upload(space_id, **attributes)
 
         expect(file_upload.attachment.id).not_to be_nil
         expect(file_upload.attachment.author).to eq("John Doe")

data/spec/ribose/file_version_spec.rb

@@ -47,7 +47,7 @@ RSpec.describe Ribose::FileVersion do
       space_id = 456_789
 
       stub_ribose_space_file_upload_api(space_id, file_attributes, file_id)
-      file = Ribose::FileVersion.create(space_id, file_id, file_attributes)
+      file = Ribose::FileVersion.create(space_id, file_id, **file_attributes)
 
       expect(file.id).not_to be_nil
       expect(file.author).to eq("John Doe")

data/spec/ribose/message_spec.rb

@@ -20,9 +20,10 @@ RSpec.describe Ribose::Message do
   describe ".create" do
     it "creates a new message into a conversation" do
       space_id = 123_456
+      message_attributes = message_attrs.merge(space_id: space_id)
 
       stub_ribose_message_create(space_id, message: message_attrs)
-      message = Ribose::Message.create(message_attrs.merge(space_id: space_id))
+      message = Ribose::Message.create(**message_attributes)
 
       expect(message.id).not_to be_nil
       expect(message.user.name).to eq("John Doe")
@@ -37,7 +38,7 @@ RSpec.describe Ribose::Message do
 
       stub_ribose_message_update(space_id, message_id, message: message_attrs)
       message = Ribose::Message.update(
-        message_attrs.merge(space_id: space_id, message_id: message_id),
+        **message_attrs.merge(space_id: space_id, message_id: message_id),
       )
 
       expect(message.user.name).to eq("John Doe")

data/spec/ribose/session_spec.rb

@@ -6,41 +6,35 @@ RSpec.describe Ribose::Session do
       username = "super.user"
       password = "supper.secreet.password"
 
-      stub_session_creation_request_via_web
+      stub_post_signin_request
       session = Ribose::Session.create(username: username, password: password)
 
-      expect(session["created_at"]).not_to be_nil
-      expect(session["authentication_token"]).to eq("user-super-secret-token")
+      expect(session.uid).to eq(session_headers["uid"])
+      expect(session.client).to eq(session_headers["client"])
+      expect(session["access-token"]).to eq(session_headers["access-token"])
     end
   end
 
-  def login_url
-    ribose_url_for("api/v2/auth/sign_in")
-  end
-
-  def ribose_url_for(*endpoints)
-    [Ribose.configuration.api_host, *endpoints].join("/")
+  def session_headers
+    @session_headers ||= {
+      "uid" => "user@example.com",
+      "expiry" => Time.now,
+      "client" => "sample-user-client",
+      "access-token" => "super.secret.access.token",
+    }
   end
 
-  def stub_session_creation_request_via_web
-    stub_get_request_with_login_page
-    stub_post_request_with_empty_body
-    stub_general_inforomation_request
-  end
-
-  def stub_get_request_with_login_page
-    stub_request(:get, login_url).and_return(
-      body: ribose_fixture("login", "html"),
-      headers: { content_type: "text/html" },
+  def stub_post_signin_request
+    stub_request(:post, login_url).and_return(
+      body: ribose_fixture("empty"), headers: session_headers,
     )
   end
 
-  def stub_general_inforomation_request
-    stub_request(:get, ribose_url_for(["settings", "general", "info"])).
-      and_return(body: ribose_fixture("general_information"), status: 200)
+  def login_url
+    [api_host, "api/v2/auth/sign_in"].join("/")
   end
 
-  def stub_post_request_with_empty_body
-    stub_request(:post, login_url).and_return(body: ribose_fixture("empty"))
+  def api_host
+    "https://#{Ribose.configuration.api_host}"
   end
 end

data/spec/ribose/space_file_spec.rb

@@ -64,7 +64,7 @@ RSpec.describe Ribose::SpaceFile do
       space_id = 123_456_789
 
       stub_ribose_space_file_upload_api(space_id, file_attributes)
-      file = Ribose::SpaceFile.create(space_id, file_attributes)
+      file = Ribose::SpaceFile.create(space_id, **file_attributes)
 
       expect(file.id).not_to be_nil
       expect(file.author).to eq("John Doe")

data/spec/ribose/space_spec.rb

@@ -28,7 +28,7 @@ RSpec.describe Ribose::Space do
   describe ".create" do
     it "creates a new space with provided details" do
       stub_ribose_space_create_api(space_attributes)
-      space = Ribose::Space.create(space_attributes)
+      space = Ribose::Space.create(**space_attributes)
 
       expect(space.id).not_to be_nil
       expect(space.visibility).to eq("invisible")