ribose 0.1.0 → 0.2.0

data/lib/ribose/profile.rb

@@ -0,0 +1,56 @@
+module Ribose
+  class Profile < Ribose::Base
+    include Ribose::Actions::Fetch
+    include Ribose::Actions::Update
+
+    def set_login
+      update_login_name[resource_key]
+    end
+
+    # Fetch user profile
+    #
+    # @param options [Hash] The query parameters
+    # @return [Sawyer::Resource] The user profile
+    #
+    def self.fetch(options = {})
+      new(resource_id: nil, **options).fetch
+    end
+
+    # Update user profile
+    #
+    # @param attributes [Hash] The new attributes
+    # @return [Sawyer::Resource] The user profile
+    #
+    def self.update(attributes)
+      new(resource_id: nil, **attributes).update
+    end
+
+    # Set login name
+    #
+    # @param login [String] The user login name
+    # @return [Sawyer::Resource] The user profile
+    #
+    def self.set_login(name, options = {})
+      new(login: name, **options).set_login
+    end
+
+    private
+
+    def resource
+      "user"
+    end
+
+    def resources_path
+      "people/profile"
+    end
+
+    def update_login_name
+      Ribose::Request.put(
+        "people/users/#{fetch.user_id}",
+        custom_option.merge(
+          resource_key.to_sym => { login: attributes[:login] }
+        ),
+      )
+    end
+  end
+end

data/lib/ribose/request.rb

@@ -0,0 +1,122 @@
+module Ribose
+  class Request
+    # Initialize a Request
+    #
+    # @param http_method [Symbol] HTTP verb as sysmbol
+    # @param endpoint [String] The relative API endpoint
+    # @param data [Hash] Attributes / Options as a Hash
+    # @return [Ribose::Request]
+    #
+    def initialize(http_method, endpoint, **data)
+      @data = data
+      @endpoint = endpoint
+      @http_method = http_method
+      @client = find_suitable_client
+    end
+
+    # Make a HTTP Request
+    #
+    # @param options [Hash] Additonal options hash
+    # @return [Sawyer::Resource]
+    #
+    def request(options = {})
+      options[:query] = extract_config_option(:query) || {}
+      agent.call(http_method, api_endpoint, data, options).data
+    end
+
+    # Make a HTTP GET Request
+    #
+    # @param endpoint [String] The relative API endpoint
+    # @param options [Hash] The additional query params
+    # @return [Sawyer::Resource]
+    #
+    def self.get(endpoint, options = {})
+      new(:get, endpoint, options).request
+    end
+
+    # Make a HTTP POST Request
+    #
+    # @param endpoint [String] The relative API endpoint
+    # @param data [Hash] The request data as a Hash
+    # @return [Sawyer::Resource]
+    #
+    def self.post(endpoint, data)
+      new(:post, endpoint, data).request
+    end
+
+    # Make a HTTP PUT Request
+    #
+    # @param endpoint [String] The relative API endpoint
+    # @param data [Hash] The request data as a Hash
+    # @return [Sawyer::Resource]
+    #
+    def self.put(endpoint, data)
+      new(:put, endpoint, data).request
+    end
+
+    # Make a HTTP DELETE Request
+    #
+    # @param endpoint [String] The relative API endpoint
+    # @return [Sawyer::Resource]
+    #
+    def self.delete(endpoint, options = {})
+      new(:delete, endpoint, options).request
+    end
+
+    private
+
+    attr_reader :client, :data, :http_method
+
+    def ribose_host
+      Ribose.configuration.api_host
+    end
+
+    def extract_config_option(key)
+      if data.is_a?(Hash)
+        data.delete(key.to_sym)
+      end
+    end
+
+    def find_suitable_client
+      client = extract_config_option(:client) || Ribose::Client.new
+      client.is_a?(Ribose::Client) ? client: raise(Ribose::Unauthorized)
+    end
+
+    def require_auth_headers?
+      auth_header = extract_config_option(:auth_header)
+      auth_header == false ? false : true
+    end
+
+    def api_endpoint
+      URI::HTTPS.build(
+        host: ribose_host,
+        path: ["", @endpoint].join("/").squeeze("/"),
+      )
+    end
+
+    def sawyer_options
+      {
+        links_parser: Sawyer::LinkParsers::Simple.new,
+        faraday: Faraday.new(builder: custom_rack_builder),
+      }
+    end
+
+    def custom_rack_builder
+      Faraday::RackBuilder.new do |builder|
+        Ribose.configuration.add_default_middleware(builder)
+      end
+    end
+
+    def agent
+      @agent ||= Sawyer::Agent.new(ribose_host, sawyer_options) do |http|
+        http.headers[:accept] = "application/json"
+        http.headers[:content_type] = "application/json"
+
+        if require_auth_headers?
+          http.headers["X-Indigo-Token"] = client.api_token
+          http.headers["X-Indigo-Email"] = client.user_email
+        end
+      end
+    end
+  end
+end

data/lib/ribose/resource_helper.rb

@@ -0,0 +1,81 @@
+module Ribose
+  module ResourceHelper
+    # Resource
+    #
+    # This is the key interface for any resource and every single
+    # resource should implement this method.Ideally this should
+    # reflect resource name in singular form, eg: +space+.
+    #
+    # Once we've this method implemented then this module will try
+    # to auto-generate all of the related helper methods, but if
+    # we need something different that the standard format then we
+    # can always overirde that in those classes.
+    #
+    # @return resrouce [String] The singular form of the Resource
+    def resource
+      raise NotImplementedError
+    end
+
+    # Resource Id
+    #
+    # The id for the key component of any of the classes in
+    # Ribose module, ideally we will have that one as default
+    # attribtue to the base class, but we can override it if
+    # necessary.
+    #
+    # @return resource_id [String] The id/uuid for a Resource
+    def resource_id
+      raise NotImplementedError
+    end
+
+    # Resources
+    #
+    # The plural version of the resoruce name, ideally we will
+    # use this one to to identify an array or resources.
+    #
+    # @return resources [String] The plural form of the Resource
+    def resources
+      [resource, "s"].join
+    end
+
+    # Resource Key
+    #
+    # The resource key is the key that we use to build any of
+    # the post/put request body, and ideally it's the resoruce
+    # value, but occassionally it might be diffrent for any of
+    # the reason, so this method will keep that on portable.
+    #
+    # @return resource_key [String] The key to build a request
+    def resource_key
+      resource
+    end
+
+    # Resources Path
+    #
+    # This represent a restfull resoruce path, and internally
+    # this will be used to build the the api endpoint path for
+    # any specifies resources.
+    #
+    # Based on the Ribose API structure it's pretty similiar
+    # to the resources value with some minor exception of the
+    # nested resoruces, so we are keeping the +resources+ as
+    # default but we can override this when necessary.
+    #
+    # @return resource_path [String] The endpoit for Resources
+    def resources_path
+      resources
+    end
+
+    # Resource Path
+    #
+    # This represent a single resource in a Restfull API. In
+    # Ribose API structure, it's `resources/:id`, so we will
+    # use that one as default. If we need something different
+    # then please override this method.
+    #
+    # @return resoruce_path [String] The Single Resource path
+    def resource_path
+      [resources_path, resource_id].join("/")
+    end
+  end
+end

data/lib/ribose/response/raise_error.rb

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

data/lib/ribose/rspec.rb

@@ -0,0 +1,19 @@
+# RSpec Test Helpers
+#
+# Actual API requests are slow and expensive and we try not to make
+# actual request when possible. For most of our tests we mock those
+# API call which verifies the endpoint, http verb and headers and
+# based on those it responses with an identical fixture file
+#
+# The main purpose of this file is to allow the user to use our test
+# helpers by simplify adding this file to their application and then
+# use the available helper  method when necessary.
+#
+# We do not require this module with the gem by default, but you can
+# do so by adding `require "ribose/rspec"` on top of `spec_helper`
+#
+require File.join(Ribose.root, "spec/support/fake_ribose_api.rb")
+
+RSpec.configure do |config|
+  config.include Ribose::FakeRiboseApi
+end

data/lib/ribose/session.rb

@@ -0,0 +1,48 @@
+require "json"
+require "mechanize"
+require "ribose/config"
+
+module Ribose
+  class Session
+    def initialize(username, password)
+      @username = username
+      @password = password
+    end
+
+    def create
+      JSON.parse(authenticate_user)
+    rescue NoMethodError, JSON::ParserError
+      raise Ribose::Unauthorized
+    end
+
+    def self.create(username:, password:)
+      new(username, password).create
+    end
+
+    private
+
+    attr_reader :username, :password
+
+    def authenticate_user
+      page = agent.get(ribose_url_for("login"))
+      find_and_submit_the_user_login_form(page)
+      agent.get(ribose_url_for(["settings", "general", "info"])).body
+    end
+
+    def find_and_submit_the_user_login_form(page)
+      login_form = page.form_with(id: "new_user")
+      login_form.field_with(id: "loginEmail").value = username
+      login_form.field_with(id: "loginPassword").value = password
+
+      login_form.submit
+    end
+
+    def agent
+      @agent ||= Mechanize.new
+    end
+
+    def ribose_url_for(*endpoint)
+      [Ribose.configuration.web_url, *endpoint].join("/")
+    end
+  end
+end

data/lib/ribose/setting.rb

@@ -0,0 +1,16 @@
+require "ribose/actions"
+
+module Ribose
+  class Setting < Ribose::Base
+    include Ribose::Actions::All
+    include Ribose::Actions::Fetch
+    include Ribose::Actions::Update
+    include Ribose::Actions::Create
+
+    private
+
+    def resource
+      "setting"
+    end
+  end
+end

data/lib/ribose/space.rb

@@ -0,0 +1,30 @@
+require "ribose/actions"
+
+module Ribose
+  class Space < Ribose::Base
+    include Ribose::Actions::All
+    include Ribose::Actions::Fetch
+    include Ribose::Actions::Create
+    include Ribose::Actions::Update
+
+    def self.create(name:, **attributes)
+      new(attributes.merge(name: name)).create
+    end
+
+    def self.remove(space_uuid, options = {})
+      Ribose::Request.post("spaces/#{space_uuid}/freeze", options)
+    end
+
+    private
+
+    attr_reader :space
+
+    def resource
+      "space"
+    end
+
+    def extract_local_attributes
+      @space = attributes.delete(:space)
+    end
+  end
+end

data/lib/ribose/space_file.rb

@@ -0,0 +1,49 @@
+require "ribose/file_uploader"
+
+module Ribose
+  class SpaceFile < Ribose::Base
+    include Ribose::Actions::All
+
+    # List Files for Space
+    #
+    # This interface retrieves the files for any specific space, and
+    # the usages is pretty simple all we need to do, provide the space
+    # id and it will return the files as `Sawyer::Resource`
+    #
+    # @param space_id [String] The spcific space Id
+    # @param options [Hash] Query parameters as a Hash
+    # @return [Array<Sawyer::Resource>]
+    #
+    def self.all(space_id, options = {})
+      new(space_id: space_id, **options).all
+    end
+
+    # Create a new file upload
+    #
+    # @param space_id [String] The Space UUID
+    # @param file [String] The complete path for the file
+    # @param attributes [Hash] The file attributes as Hash
+    # @return [Sawyer::Resource] The file upload response.
+    #
+    def self.create(space_id, file:, **attributes)
+      upload = FileUploader.upload(space_id, attributes.merge(file: file))
+      upload[:attachment]
+    end
+
+    private
+
+    attr_reader :space_id
+
+    def resource
+      "file"
+    end
+
+    def resources_path
+      ["spaces", space_id, "file", "files"].join("/")
+    end
+
+    def extract_local_attributes
+      @space_id = attributes.delete(:space_id)
+    end
+  end
+end