nokotime-ruby-client 0.1.0

data/lib/nokotime/authentication.rb

@@ -0,0 +1,28 @@
+module Nokotime
+  module Authentication
+    AUTHENTICATION_TYPE = [
+      :noko_token
+    ].freeze
+
+    def valid_auth?(type)
+      AUTHENTICATION_TYPE.include? type
+    end
+
+    def authorize_request(request)
+      case auth_type
+      when :noko_token
+        request.headers["X-NokoToken"] = token
+      end
+    end
+
+    private
+
+    def token
+      Nokotime.configuration.token
+    end
+
+    def auth_type
+      Nokotime.configuration.auth_type
+    end
+  end
+end

data/lib/nokotime/client/entries.rb

@@ -0,0 +1,41 @@
+module Nokotime
+  module Client
+    class Entries
+      ENDPOINT = "/v2/entries".freeze
+
+      attr_reader :params
+
+      def initialize(params = {})
+        @params = params
+      end
+
+      def all
+        multiple_pages.get(ENDPOINT, params: entry_params)
+      end
+
+      def show(id)
+        single_page.get("#{ENDPOINT}/#{id}")
+      end
+
+      private
+
+      def multiple_pages
+        @multiple_pages ||= Request::MultiplePages.new
+      end
+
+      def single_page
+        @single_page ||= Request::SinglePage.new
+      end
+
+      def entry_params
+        return params if validation.success?
+
+        raise Errors::InvalidParams, validation.messages
+      end
+
+      def validation
+        @validation ||= Validator::EntrySchema.validate(params)
+      end
+    end
+  end
+end

data/lib/nokotime/client/project_groups.rb

@@ -0,0 +1,33 @@
+module Nokotime
+  module Client
+    class ProjectGroups
+      ENDPOINT = "/v2/project_groups".freeze
+
+      attr_reader :params
+
+      def initialize(params = {})
+        @params = params
+      end
+
+      def all
+        multiple_pages.get(ENDPOINT, params: project_group_params)
+      end
+
+      private
+
+      def multiple_pages
+        @multiple_pages ||= Request::MultiplePages.new
+      end
+
+      def project_group_params
+        return params if validation.success?
+
+        raise Errors::InvalidParams, validation.messages
+      end
+
+      def validation
+        @validation ||= Validator::ProjectGroupSchema.validate(params)
+      end
+    end
+  end
+end

data/lib/nokotime/client/projects.rb

@@ -0,0 +1,41 @@
+module Nokotime
+  module Client
+    class Projects
+      ENDPOINT = "/v2/projects".freeze
+
+      attr_reader :params
+
+      def initialize(params = {})
+        @params = params
+      end
+
+      def all
+        multiple_pages.get(ENDPOINT, params: project_params)
+      end
+
+      def show(id)
+        single_page.get("#{ENDPOINT}/#{id}")
+      end
+
+      private
+
+      def multiple_pages
+        @multiple_pages ||= Request::MultiplePages.new
+      end
+
+      def single_page
+        @single_page ||= Request::SinglePage.new
+      end
+
+      def project_params
+        return params if validation.success?
+
+        raise Errors::InvalidParams, validation.messages
+      end
+
+      def validation
+        @validation ||= Validator::ProjectSchema.validate(params)
+      end
+    end
+  end
+end

data/lib/nokotime/client/tags.rb

@@ -0,0 +1,33 @@
+module Nokotime
+  module Client
+    class Tags
+      ENDPOINT = "/v2/tags".freeze
+
+      attr_reader :params
+
+      def initialize(params = {})
+        @params = params
+      end
+
+      def all
+        multiple_pages.get(ENDPOINT, params: tag_params)
+      end
+
+      private
+
+      def multiple_pages
+        @multiple_pages ||= Request::MultiplePages.new
+      end
+
+      def tag_params
+        return params if validation.success?
+
+        raise Errors::InvalidParams, validation.messages
+      end
+
+      def validation
+        @validation ||= Validator::TagSchema.validate(params)
+      end
+    end
+  end
+end

data/lib/nokotime/client/users.rb

@@ -0,0 +1,41 @@
+module Nokotime
+  module Client
+    class Users
+      ENDPOINT = "/v2/users".freeze
+
+      attr_reader :params
+
+      def initialize(params = {})
+        @params = params
+      end
+
+      def all
+        multiple_pages.get(ENDPOINT, params: user_params)
+      end
+
+      def show(id)
+        single_page.get("#{ENDPOINT}/#{id}")
+      end
+
+      private
+
+      def multiple_pages
+        @multiple_pages ||= Request::MultiplePages.new
+      end
+
+      def single_page
+        @single_page ||= Request::SinglePage.new
+      end
+
+      def user_params
+        return params if validation.success?
+
+        raise Errors::InvalidParams, validation.messages
+      end
+
+      def validation
+        @validation ||= Validator::UserSchema.validate(params)
+      end
+    end
+  end
+end

data/lib/nokotime/configuration.rb

@@ -0,0 +1,44 @@
+module Nokotime
+  class Configuration
+    include Nokotime::Authentication
+
+    attr_writer   :auth_type
+    attr_writer   :max_concurrency
+    attr_writer   :token
+    attr_accessor :url
+
+    DEFAULT_URL = "https://api.nokotime.com".freeze
+
+    def initialize
+      @auth_type = nil
+      @max_concurrency = nil
+      @token = nil
+      @url = DEFAULT_URL
+    end
+
+    def auth_type
+      unless valid_auth?(@auth_type)
+        raise(
+          Errors::Configuration,
+          "#{@auth_type} isn't valid type authentication."
+        )
+      end
+
+      @auth_type || raise(
+        Errors::Configuration, "Authentication type missing."
+      )
+    end
+
+    def max_concurrency
+      @max_concurrency || raise(
+        Errors::Configuration, "Max concurrency missing."
+      )
+    end
+
+    def token
+      @token || raise(
+        Errors::Configuration, "Token missing."
+      )
+    end
+  end
+end

data/lib/nokotime/connection.rb

@@ -0,0 +1,87 @@
+module Nokotime
+  class Connection
+    include Nokotime::Authentication
+
+    # rubocop:disable Metrics/MethodLength
+    def get(path, params: {}, request_options: {})
+      response = connection.get do |request|
+        authorize_request(request)
+        set_request_options(request, request_options)
+        request.url path, params
+      end
+
+      response
+    rescue Faraday::ConnectionFailed => e
+      raise Errors::ConnectionFailed.new(e), e.message
+    rescue Faraday::ResourceNotFound => e
+      raise Errors::ResourceNotFound.new(e), e.message
+    rescue Faraday::ClientError => e
+      raise Errors::ClientError.new(e), e.message
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def get_in_parallel(
+      path,
+      from_page_number,
+      to_page_number,
+      params: {},
+      request_options: {}
+    )
+      responses = []
+
+      connection.in_parallel(manager) do
+        (from_page_number..to_page_number).each do |page|
+          merged_params = {page: page}.merge(params)
+
+          responses << get(
+            path, params: merged_params, request_options: request_options
+          )
+        end
+      end
+
+      responses
+    rescue Faraday::ConnectionFailed => e
+      raise Errors::ConnectionFailed.new(e), e.message
+    rescue Faraday::ResourceNotFound => e
+      raise Errors::ResourceNotFound.new(e), e.message
+    rescue Faraday::ClientError => e
+      raise Errors::ClientError.new(e), e.message
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
+
+    private
+
+    def connection
+      @connection ||= Faraday.new(default_options) do |connection|
+        connection.request  :json
+        connection.response :json, content_type: /\bjson$/
+        connection.response :raise_error
+        connection.adapter  :typhoeus
+      end
+    end
+
+    def default_options
+      {
+        url: Nokotime.configuration.url,
+        headers: {
+          user_agent: "MyNokoBot/1.0",
+          accept: "application/json"
+        }
+      }
+    end
+
+    def set_request_options(request, options)
+      request.options.timeout = options[:timeout]
+      request.options.open_timeout = options[:open_timeout]
+    end
+
+    def manager
+      @manager ||= Typhoeus::Hydra.new(
+        max_concurrency: Nokotime.configuration.max_concurrency
+      )
+    end
+  end
+end

data/lib/nokotime/errors/configuration.rb

@@ -0,0 +1,5 @@
+module Nokotime
+  module Errors
+    class Configuration < StandardError; end
+  end
+end

data/lib/nokotime/errors/connection.rb

@@ -0,0 +1,7 @@
+module Nokotime
+  module Errors
+    class ConnectionFailed < StandardError; end
+    class ResourceNotFound < StandardError; end
+    class ClientError < StandardError; end
+  end
+end

data/lib/nokotime/errors/invalid_params.rb

@@ -0,0 +1,5 @@
+module Nokotime
+  module Errors
+    class InvalidParams < StandardError; end
+  end
+end

data/lib/nokotime/paginator.rb

@@ -0,0 +1,67 @@
+module Nokotime
+  class Paginator
+    attr_reader :raw_links
+
+    def initialize(raw_links)
+      @raw_links = raw_links
+    end
+
+    def next
+      find("next")&.dig(:url)
+    end
+
+    def prev
+      find("prev")&.dig(:url)
+    end
+
+    def first
+      find("first")&.dig(:url)
+    end
+
+    def last
+      find("last")&.dig(:url)
+    end
+
+    def total_pages
+      find("last")&.dig(:number_page)
+    end
+
+    private
+
+    def find(rel)
+      pages.find { |page| page[:rel] == rel }
+    end
+
+    def pages
+      return {} if raw_links.empty?
+
+      @pages ||=
+        raw_links.split(",").map do |link|
+          url, rel, number_page = split_and_clean_link(link)
+
+          {
+            url: "#{url.path}?#{url.query}",
+            rel: rel,
+            number_page: number_page
+          }
+        end
+    end
+
+    # Example of link response headers:
+    # "<https://api.nokotime.com/v2/users?page=2>; rel=\"last\""
+    #
+    # The first element is an URI. "Rel" means the relative position
+    # of the current page, in this case is last page.
+
+    def split_and_clean_link(link)
+      raw_url, rel = link.split(";").map(&:strip)
+
+      raw_url = raw_url.gsub(/<|>/, "")
+      rel = rel.gsub(/(rel=)?"/, "")
+      url = URI.parse(raw_url)
+      page = CGI.parse(url.query)["page"].first
+
+      [url, rel, page]
+    end
+  end
+end