emojidex 0.0.23 → 0.1.0

data/lib/emojidex/service/error.rb

@@ -0,0 +1,9 @@
+module Emojidex
+  module Service
+    module Error
+      class Unauthorized < SecurityError; end
+      class UnprocessableEntity < StandardError; end
+      class InvalidJSON < StandardError; end
+    end
+  end
+end

data/lib/emojidex/service/indexes.rb

@@ -0,0 +1,43 @@
+require_relative 'transactor'
+require_relative 'collection'
+require_relative '../defaults'
+
+module Emojidex
+  module Service
+    # emoji indexes
+    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})
+      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})
+      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})
+      end
+
+      # Obtains a hash with three different types of chracter [moji] code indexes:
+      # moji_string: a string that can be used for things like regex matches.
+      #   Contains conglomorate codes ahead of single chracter codes.
+      # moji_array: an array of emoji characters.
+      #   Contains conglomorate codes ahead of single chracter codes.
+      # moji_index: a hash map with the keys being emoji strings and the values being
+      #   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 })
+        rescue
+          return { moji_string: "", moji_array: [], moji_index: {} }
+        end
+        res[:moji_index] = Hash[res[:moji_index].map{ |k, v| [k.to_s, v] }]
+        res
+      end
+    end
+  end
+end

data/lib/emojidex/service/search.rb

@@ -0,0 +1,82 @@
+require_relative '../defaults'
+require_relative 'collection'
+require_relative '../../emojidex'
+
+module Emojidex
+  module 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
+      # detailed: set to true to enable detailed results (defaults to false)
+      # limit: sets the number of items per page (default Emojidex::Defaults.limit)
+      # Returns a service Collection.
+      def self.term(code_cont, opts = {})
+        opts[:code_cont] = Emojidex.escape_code(code_cont)
+        _do_search(opts)
+      end
+      def self.search(code_cont, opts = {})
+        self.term(code_cont, opts)
+      end
+
+      # Searches for a code starting with the given term.
+      # Available options are the same as term.
+      # Returns a service Collection.
+      def self.starting(code_sw, opts = {})
+        opts[:code_sw] = Emojidex.escape_code(code_sw)
+        _do_search(opts)
+      end
+
+      # Searches for a code ending with the given term.
+      # Available options are the same as term.
+      # Returns a service Collection.
+      def self.ending(code_ew, opts = {})
+        opts[:code_ew] = Emojidex.escape_code(code_ew)
+        _do_search(opts)
+      end
+
+      # Searches an array of tags for emoji associated with all those tags.
+      # Available options are the same as term.
+      # Returns a service Collection.
+      def self.tags(tags, opts = {})
+        tags = [] << tags unless tags.class == Array
+        opts[:tags] = tags
+        _do_search(opts)
+      end
+
+      # An expanded version of term with categories and tags as arguments.
+      # Options are:
+      # detailed: set to true to enable detailed results (defaults to false)
+      # limit: sets the number of items per page (default Emojidex::Defaults.limit)
+      # Returns a service Collection.
+      def self.advanced(code_cont, categories = [], tags = [], opts = {})
+        opts[:code_cont] = Emojidex.escape_code(code_cont)
+        tags = [] << tags unless tags.class == Array
+        opts[:tags] = tags
+        categories = [] << categories unless categories.class == Array
+        opts[:categories] = categories
+        _do_search(opts)
+      end
+
+      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
+      end
+
+      def self._do_search(opts)
+        opts = _sanitize_opts(opts)
+        opts[:endpoint] = 'search/emoji'
+        begin
+          col = Emojidex::Service::Collection.new(opts)
+        rescue
+          return Emojidex::Service::Collection.new
+        end
+        col
+      end
+    end
+  end
+end

data/lib/emojidex/service/transactor.rb

@@ -0,0 +1,100 @@
+require 'faraday'
+require 'json'
+require_relative 'error'
+
+module Emojidex
+  module Service
+    # API transaction utility
+    class Transactor
+      @@connection = nil
+
+      @@settings = {
+        api: {
+          host: 'www.emojidex.com',
+          prefix: '/api/v1/',
+          protocol: 'https'
+        },
+        cdn: {
+          host: 'cdn.emojidex.com',
+          prefix: '/emoji/',
+          protocol: 'http'
+        },
+        closed_net: false
+      }
+
+      def self.get(endpoint, params = {})
+        response = self.connect.get(
+          "#{self.api_url}#{endpoint}", params)
+
+        self._status_raiser(response)
+        self._datafy_json(response.body)
+      end
+
+      def self.post(endpoint, params = {})
+        response = self.connect.post(
+          "#{self.api_url}#{endpoint}", params)
+
+        self._status_raiser(response)
+        self._datafy_json(response.body)
+      end
+
+      def self.delete(endpoint, params = {})
+        response = self.connect.delete(
+          "#{self.api_url}#{endpoint}", params)
+
+        self._status_raiser(response)
+        self._datafy_json(response.body)
+      end
+
+      def self.download(file_subpath)
+        self.connect.get(URI.escape("#{self.cdn_url}#{file_subpath}"))
+      end
+
+      def self.connect
+        return @@connection if @@connection
+        @@connection = Faraday.new do |conn|
+          conn.request :url_encoded
+          # conn.response :logger
+          conn.adapter Faraday.default_adapter
+        end
+        @@connection
+      end
+
+      def self.api_url()
+        "#{@@settings[:api][:protocol]}://#{@@settings[:api][:host]}#{@@settings[:api][:prefix]}"
+      end
+
+      def self.cdn_url()
+        "#{@@settings[:cdn][:protocol]}://#{@@settings[:cdn][:host]}#{@@settings[:cdn][:prefix]}"
+      end
+
+      private
+
+      def self._status_raiser(response)
+        case response.status
+        when 200..299
+          return # don't raise
+        when 401
+          raise Error::Unauthorized.new(self._extract_status_line(response))
+        when 422
+          raise Error::UnprocessableEntity.new(self._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
+      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')
+        end
+        data
+      end
+    end
+  end
+end

data/lib/emojidex/service/user.rb

@@ -0,0 +1,233 @@
+require_relative '../../emojidex'
+require_relative 'error'
+require_relative 'transactor'
+require_relative 'collection'
+
+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
+
+      @@auth_status_codes = { none: false, failure: false,
+                              unverified: false, verified: true,
+                              loaded: false }
+      def self.auth_status_codes
+        @@auth_status_codes
+      end
+
+      def initialize(opts = {})
+        clear_auth_data
+        @status = :none
+        @history = []
+        @favorites = Emojidex::Data::Collection.new
+      end
+
+      def login(user, password, sync_on_login = true)
+        begin
+          auth_response = Transactor.get('users/authenticate',
+                            { user: user, password: password })
+        rescue Error::Unauthorized
+          @status = :unverified
+          return false
+        end
+
+        return false unless _process_auth_response(auth_response)
+        if sync_on_login
+          sync_favorites
+          sync_history
+        end
+        true
+      end
+
+      def authorize(username, auth_token, sync_on_auth = true)
+        begin
+          auth_response = Transactor.get('users/authenticate',
+                            { username: username, token: auth_token })
+        rescue Error::Unauthorized
+          @status = :unverified
+          return false
+        end
+
+        return false unless _process_auth_response(auth_response)
+        if sync_on_auth
+          sync_favorites
+          sync_history
+        end
+        true
+      end
+
+      def authorized?
+        @@auth_status_codes[@status]
+      end
+
+      def sync_favorites(limit = Emojidex::Defaults.limit, detailed = true)
+        return false unless authorized?
+
+        begin
+          res = Emojidex::Service::Collection.new(
+            { endpoint: 'users/favorites', limit: limit, detailed: detailed,
+             username: @username, auth_token: @auth_token })
+        rescue Error::Unauthorized
+          return false
+        end
+
+        @favorites = res
+        true
+      end
+
+      def add_favorite(code)
+        return false unless authorized?
+
+        begin
+          res = Transactor.post('users/favorites',
+                  { 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
+      end
+
+      def remove_favorite(code)
+        return false unless authorized?
+
+        begin
+          res = Transactor.delete('users/favorites',
+                  { 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
+        true
+      end
+
+      def sync_history(limit = Emojidex::Defaults.limit, page = 1)
+        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.
+        true
+      end
+
+      def add_history(code)
+      end
+
+      def clear_auth_data()
+        @username = @auth_token = ''
+        @pro = false
+        @premium = false
+        @pro_exp = nil
+        @premium_exp = nil
+      end
+
+      def sync
+        authorize(@username, @auth_token) &&
+        sync_favorites &&
+        sync_history
+      end
+
+      def save(path)
+        _set_cache_path(path)
+        _save_user
+        _save_favorites
+        _save_history
+      end
+
+      def load(path, auto_sync = true)
+        _set_cache_path(path)
+        _load_user
+        _load_favorites
+        _load_history
+        sync if auto_sync
+      end
+
+      private
+
+      def _process_auth_response(auth_response)
+        if auth_response[:auth_status] == 'verified'
+          _set_verified_data(auth_response)
+          return true
+        elsif auth_response[:auth_status] == 'unverified'
+          @status = :unverified
+        else
+          @status = :failure
+        end
+        clear_auth_data
+        false
+      end
+
+      def _set_verified_data(auth_response)
+        @status = :verified
+        @username = auth_response[:auth_user]
+        @auth_token = auth_response[:auth_token]
+        @pro = auth_response[:pro]
+        @premium = auth_response[:premium]
+        @pro_exp = auth_response[:pro_exp]
+        @premium_exp = auth_response[:premium_exp]
+      end
+
+      def _set_cache_path(path)
+        @cache_path = @cache_path || File.expand_path(
+          path || ENV['EMOJI_CACHE'] || "#{ENV['HOME']}/.emojidex/")
+        FileUtils.mkdir_p(@cache_path)
+        @cache_path
+      end
+
+      def _save_user
+        user_info = { username: username, auth_token: auth_token,
+                      premium: premium, pro: pro,
+                      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 }
+      end
+
+      def _save_history
+        File.open("#{@cache_path}/history.json", 'w') { |f| f.write @history.to_json }
+      end
+
+      def _load_user
+        json = IO.read("#{@cache_path}/user.json")
+        user_info = JSON.parse(json, symbolize_names: true)
+        @username = user_info[:username]
+        @auth_token = user_info[:auth_token]
+        @premium = user_info[:premium]
+        @pro = user_info[:pro]
+        @premium_exp = user_info[:premium_exp]
+        @pro_exp = user_info[:pro_exp]
+        @status = :loaded
+      end
+
+      def _load_favorites
+        json = IO.read("#{@cache_path}/favorites.json")
+        @favorites = Emojidex::Service::Collection.new(
+          emoji: JSON.parse(json, symbolize_names: true),
+          auto_init: false)
+      end
+
+      def _load_history
+        json = IO.read("#{@cache_path}/history.json")
+        @history = JSON.parse json
+      end
+    end
+  end
+end