emojidex 0.1.0 → 0.2.0

data/lib/emojidex/service/error.rb

@@ -2,6 +2,7 @@ module Emojidex
   module Service
     module Error
       class Unauthorized < SecurityError; end
+      class PaymentRequired < StandardError; end
       class UnprocessableEntity < StandardError; end
       class InvalidJSON < StandardError; end
     end

data/lib/emojidex/service/indexes.rb

@@ -8,18 +8,34 @@ module Emojidex
     class Indexes
       # Obtain a service Collection of emoji indexed by score.
       # This is the default index.
-      def self.emoji(detailed = false, limit = Emojidex::Defaults.limit, page = 1)
-        Emojidex::Service::Collection.new({endpoint: 'emoji', detailed: detailed, limit: limit, page: page})
+      def self.emoji(detailed = false, limit = Emojidex::Defaults.limit, page = 0)
+        Emojidex::Service::Collection.new(endpoint: 'emoji', detailed: detailed,
+                                          limit: limit, page: page)
       end
 
       # Obtain a service Collection of emoji indexed by date of creation (or in some cases update).
-      def self.newest(detailed = false, limit = Emojidex::Defaults.limit, page = 1)
-        Emojidex::Service::Collection.new({endpoint: 'newest', detailed: detailed, limit: limit, page: page})
+      def self.newest(detailed = false, limit = Emojidex::Defaults.limit, page = 0,
+                      username = nil, auth_token = nil)
+        if auth_token.nil?
+          username = Emojidex::Client.USER.username
+          auth_token = Emojidex::Client.USER.auth_token
+        end
+        Emojidex::Service::Collection.new(endpoint: 'newest', detailed: detailed,
+                                          limit: limit, page: page,
+                                          username: username, auth_token: auth_token)
       end
 
-      # Obtain a service Collection of emoji indexed by popularity [how many times they have been favorited].
-      def self.popular(detailed = false, limit = Emojidex::Defaults.limit, page = 1)
-        Emojidex::Service::Collection.new({endpoint: 'popular', detailed: detailed, limit: limit, page: page})
+      # Obtain a service Collection of emoji indexed by popularity
+      # [how many times they have been favorited].
+      def self.popular(detailed = false, limit = Emojidex::Defaults.limit, page = 0,
+                       username = nil, auth_token = nil)
+        if auth_token.nil?
+          username = Emojidex::Client.USER.username
+          auth_token = Emojidex::Client.USER.auth_token
+        end
+        Emojidex::Service::Collection.new(endpoint: 'popular', detailed: detailed,
+                                          limit: limit, page: page,
+                                          username: username, auth_token: auth_token)
       end
 
       # Obtains a hash with three different types of chracter [moji] code indexes:
@@ -31,13 +47,18 @@ module Emojidex
       #   the emoji short codes in the locale [language] specified (defaults to english).
       def self.moji_codes(locale = Emojidex::Defaults.lang)
         begin
-          res = Emojidex::Service::Transactor.get('moji_codes', { locale: locale })
+          res = Emojidex::Service::Transactor.get('moji_codes', locale: locale)
         rescue
-          return { moji_string: "", moji_array: [], moji_index: {} }
+          return { moji_string: '', moji_array: [], moji_index: {} }
         end
-        res[:moji_index] = Hash[res[:moji_index].map{ |k, v| [k.to_s, v] }]
+        res[:moji_index] = Hash[res[:moji_index].map { |k, v| [k.to_s, v] }]
         res
       end
+
+      def self.user_emoji(username, detailed = false, limit = Emojidex::Defaults.limit, page = 0)
+        Emojidex::Service::Collection.new(endpoint: "users/#{username}/emoji", detailed: detailed,
+                                          limit: limit, page: page)
+      end
     end
   end
 end

data/lib/emojidex/service/search.rb

@@ -4,8 +4,8 @@ require_relative '../../emojidex'
 
 module Emojidex
   module Service
+    # Search functionality for the emojidex service
     class Search
-
       # Searches by term with the options given. Options are:
       # tags: an array of tags to restrict the search to
       # categories: an arry of categories to restrict the serach to
@@ -16,8 +16,9 @@ module Emojidex
         opts[:code_cont] = Emojidex.escape_code(code_cont)
         _do_search(opts)
       end
+
       def self.search(code_cont, opts = {})
-        self.term(code_cont, opts)
+        term(code_cont, opts)
       end
 
       # Searches for a code starting with the given term.
@@ -62,8 +63,8 @@ module Emojidex
       private
 
       def self._sanitize_opts(opts)
-        opts[:tags].map! { |tag| tag.to_s } if opts.include? :tags
-        opts[:categories].map! { |category| category.to_s } if opts.include? :categories
+        opts[:tags].map!(&:to_s) if opts.include? :tags
+        opts[:categories].map!(&:to_s) if opts.include? :categories
         opts
       end
 

data/lib/emojidex/service/transactor.rb

@@ -1,5 +1,6 @@
 require 'faraday'
 require 'json'
+require_relative '../../emojidex'
 require_relative 'error'
 
 module Emojidex
@@ -7,6 +8,7 @@ module Emojidex
     # API transaction utility
     class Transactor
       @@connection = nil
+      @@retries = 3
 
       @@settings = {
         api: {
@@ -23,40 +25,43 @@ module Emojidex
       }
 
       def self.get(endpoint, params = {})
-        response = self.connect.get(
-          "#{self.api_url}#{endpoint}", params)
+        response = connect.get(
+          "#{api_url}#{endpoint}", params)
 
-        self._status_raiser(response)
-        self._datafy_json(response.body)
+        _status_raiser(response)
+        _datafy_json(response.body)
       end
 
       def self.post(endpoint, params = {})
-        response = self.connect.post(
-          "#{self.api_url}#{endpoint}", params)
+        response = connect.post(
+          "#{api_url}#{endpoint}", params)
 
-        self._status_raiser(response)
-        self._datafy_json(response.body)
+        _status_raiser(response)
+        _datafy_json(response.body)
       end
 
       def self.delete(endpoint, params = {})
-        response = self.connect.delete(
-          "#{self.api_url}#{endpoint}", params)
+        response = connect.delete(
+          "#{api_url}#{endpoint}", params)
 
-        self._status_raiser(response)
-        self._datafy_json(response.body)
+        _status_raiser(response)
+        _datafy_json(response.body)
       end
 
       def self.download(file_subpath)
-        self.connect.get(URI.escape("#{self.cdn_url}#{file_subpath}"))
+        connect.get(URI.escape("#{cdn_url}#{file_subpath.tr(' ', '_')}"))
       end
 
       def self.connect
         return @@connection if @@connection
         @@connection = Faraday.new do |conn|
           conn.request :url_encoded
+          conn.request :retry, max: @@retries, interval: 0.05, interval_randomness: 0.05,
+                        backoff_factor: 2
           # conn.response :logger
           conn.adapter Faraday.default_adapter
         end
+        _kludge_windows if Gem.win_platform?
         @@connection
       end
 
@@ -75,26 +80,37 @@ module Emojidex
         when 200..299
           return # don't raise
         when 401
-          raise Error::Unauthorized.new(self._extract_status_line(response))
+          fail Error::Unauthorized, _extract_status_line(response)
+        when 402
+          fail Error::PaymentRequired, _extract_status_line(response)
         when 422
-          raise Error::UnprocessableEntity.new(self._extract_status_line(response))
+          fail Error::UnprocessableEntity _extract_status_line(response)
         end
       end
 
       def self._extract_status_line(response)
-          data = self._datafy_json(response.body)
-          status_line = (data.key?(:status) ? data[:status] : '')
-          status_line
+        data = _datafy_json(response.body)
+        status_line = (data.key?(:status) ? data[:status] : '')
+        status_line
       end
 
       def self._datafy_json(body)
         begin
           data = JSON.parse(body, symbolize_names: true)
         rescue JSON::ParserError
-          raise Error::InvalidJSON.new('could not parse JSON')
+          raise Error::InvalidJSON, 'could not parse JSON'
         end
         data
       end
+
+      def self._kludge_windows
+        cert_loc = "#{__dir__}/cacert.pem"
+        unless File.exist? cert_loc
+          response = @@connection.get('http://curl.haxx.se/ca/cacert.pem')
+          File.open(cert_loc, 'wb') { |fp| fp.write(response.body) }
+        end
+        ENV['SSL_CERT_FILE'] = cert_loc
+      end
     end
   end
 end

data/lib/emojidex/service/user.rb

@@ -2,13 +2,14 @@ require_relative '../../emojidex'
 require_relative 'error'
 require_relative 'transactor'
 require_relative 'collection'
+require_relative './user/history_item'
 
 module Emojidex
   module Service
     # User auth and user details
     class User
       attr_reader :username, :auth_token, :premium, :pro, :premium_exp, :pro_exp, :status
-      attr_accessor :favorites, :history, :cache_path
+      attr_accessor :favorites, :history, :history_page, :cache_path
 
       @@auth_status_codes = { none: false, failure: false,
                               unverified: false, verified: true,
@@ -21,13 +22,19 @@ module Emojidex
         clear_auth_data
         @status = :none
         @history = []
+        @history_page = 0
         @favorites = Emojidex::Data::Collection.new
+        if opts.key?(:cache_path)
+          load(opts[:cache_path])
+        elsif opts[:load_cache] == true
+          load
+        end
       end
 
       def login(user, password, sync_on_login = true)
         begin
           auth_response = Transactor.get('users/authenticate',
-                            { user: user, password: password })
+                                         user: user, password: password)
         rescue Error::Unauthorized
           @status = :unverified
           return false
@@ -44,7 +51,7 @@ module Emojidex
       def authorize(username, auth_token, sync_on_auth = true)
         begin
           auth_response = Transactor.get('users/authenticate',
-                            { username: username, token: auth_token })
+                                         username: username, token: auth_token)
         rescue Error::Unauthorized
           @status = :unverified
           return false
@@ -67,8 +74,8 @@ module Emojidex
 
         begin
           res = Emojidex::Service::Collection.new(
-            { endpoint: 'users/favorites', limit: limit, detailed: detailed,
-             username: @username, auth_token: @auth_token })
+            endpoint: 'users/favorites', limit: limit, detailed: detailed,
+            username: @username, auth_token: @auth_token)
         rescue Error::Unauthorized
           return false
         end
@@ -82,18 +89,14 @@ module Emojidex
 
         begin
           res = Transactor.post('users/favorites',
-                  { username: @username, auth_token: @auth_token,
-                   emoji_code: Emojidex.escape_code(code) })
+                                username: @username, auth_token: @auth_token,
+                                emoji_code: Emojidex.escape_code(code))
         rescue Error::Unauthorized
           return false
-        rescue Error::UnprocessableEntity => e
-          # TODO: API is currently returning this both when emoji already registered
-          # and when code is invalid. When already registerd it will return 202 on
-          # next update
-          return true if e.message == 'emoji already in user favorites'
-          return false
         end
-        return true
+        return false if res.include?(:status) && res[:status] == 'emoji already in user favorites'
+        @favorites.add_emoji([res])
+        true
       end
 
       def remove_favorite(code)
@@ -101,31 +104,48 @@ module Emojidex
 
         begin
           res = Transactor.delete('users/favorites',
-                  { username: @username, auth_token: @auth_token,
-                   emoji_code: Emojidex.escape_code(code) })
+                                  username: @username, auth_token: @auth_token,
+                                  emoji_code: Emojidex.escape_code(code))
         rescue Error::Unauthorized
           return false
-        rescue Error::UnprocessableEntity => e
-          # TODO: API is currently returning this both when emoji already registered
-          # and when code is invalid. When already registerd it will return 200 on
-          # next update
-          return true if e.message == 'emoji not in user favorites'
-          return false
         end
+        return false if res.include?(:status) && res[:status] == 'emoji not in user favorites'
+        @favorites.remove_emoji(code.to_sym)
         true
       end
 
-      def sync_history(limit = Emojidex::Defaults.limit, page = 1)
+      def sync_history(limit = Emojidex::Defaults.limit, page = 0)
         return false unless authorized?
 
-        @history = Transactor.get('users/history',
-                    { limit: limit, page: page, username: @username, auth_token: @auth_token })
-        # TODO: this is a temporary implementation of history. It will be revised after an
-        # API update.
+        page = @history_page + 1 if page == 0
+
+        begin
+          result = Transactor.get('users/history',
+                                  limit: limit, page: page,
+                                  username: @username, auth_token: @auth_token)
+        rescue
+          return false
+        end
+
+        return false unless (result.key?(:history) && result.key?(:meta))
+        @history_page = result[:meta][:page]
+        _merge_history(result[:history])
         true
       end
 
       def add_history(code)
+        return false unless authorized?
+
+        begin
+          result = Transactor.post('users/history',
+                                   username: @username, auth_token: @auth_token,
+                                   emoji_code: Emojidex.escape_code(code))
+        rescue
+          return false
+        end
+
+        _push_and_dedupe_history(result)
+        true
       end
 
       def clear_auth_data()
@@ -137,19 +157,17 @@ module Emojidex
       end
 
       def sync
-        authorize(@username, @auth_token) &&
-        sync_favorites &&
-        sync_history
+        authorize(@username, @auth_token) && sync_favorites && sync_history
       end
 
-      def save(path)
+      def save(path = nil)
         _set_cache_path(path)
         _save_user
         _save_favorites
         _save_history
       end
 
-      def load(path, auto_sync = true)
+      def load(path = nil, auto_sync = true)
         _set_cache_path(path)
         _load_user
         _load_favorites
@@ -183,8 +201,7 @@ module Emojidex
       end
 
       def _set_cache_path(path)
-        @cache_path = @cache_path || File.expand_path(
-          path || ENV['EMOJI_CACHE'] || "#{ENV['HOME']}/.emojidex/")
+        @cache_path ||= File.expand_path(path || Emojidex::Defaults.system_cache_path)
         FileUtils.mkdir_p(@cache_path)
         @cache_path
       end
@@ -192,13 +209,15 @@ module Emojidex
       def _save_user
         user_info = { username: username, auth_token: auth_token,
                       premium: premium, pro: pro,
-                      premium_exp: premium_exp, pro_exp: pro_exp 
+                      premium_exp: premium_exp, pro_exp: pro_exp
                     }
         File.open("#{@cache_path}/user.json", 'w') { |f| f.write user_info.to_json }
       end
 
       def _save_favorites
-        File.open("#{@cache_path}/favorites.json", 'w') { |f| f.write @favorites.emoji.values.to_json }
+        File.open("#{@cache_path}/favorites.json", 'w') do |f|
+          f.write @favorites.emoji.values.to_json
+        end
       end
 
       def _save_history
@@ -206,6 +225,7 @@ module Emojidex
       end
 
       def _load_user
+        _save_user unless File.exist? "#{@cache_path}/user.json"
         json = IO.read("#{@cache_path}/user.json")
         user_info = JSON.parse(json, symbolize_names: true)
         @username = user_info[:username]
@@ -218,6 +238,7 @@ module Emojidex
       end
 
       def _load_favorites
+        _save_favorites unless File.exist? "#{@cache_path}/favorites.json"
         json = IO.read("#{@cache_path}/favorites.json")
         @favorites = Emojidex::Service::Collection.new(
           emoji: JSON.parse(json, symbolize_names: true),
@@ -225,8 +246,30 @@ module Emojidex
       end
 
       def _load_history
+        _save_history unless File.exist? "#{@cache_path}/history.json"
         json = IO.read("#{@cache_path}/history.json")
-        @history = JSON.parse json
+        items = JSON.parse(json, symbolize_names: true)
+        @history = []
+        items.each { |item| @history << Emojidex::Service::HistoryItem.new(item[:emoji_code],
+                                                                           item[:times_used],
+                                                                           item[:last_used]) }
+      end
+
+      def _merge_history(history_delta = [])
+        history_delta.each do |item|
+          _push_and_dedupe_history(item)
+        end
+        _sort_history
+      end
+
+      def _push_and_dedupe_history(item)
+        @history.delete_if { |hi| hi.emoji_code == item[:emoji_code] }
+        @history.unshift Emojidex::Service::HistoryItem.new(item[:emoji_code],
+                                                            item[:times_used], item[:last_used])
+      end
+
+      def _sort_history
+        @history.sort_by! {|h| -h.last_used.to_i}
       end
     end
   end