emojidex 0.0.7 → 0.0.9

data/lib/emojidex/categories.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Emojidex
+  # Holds a master list of categories
+  class Categories
+    attr_accessor :categories
+
+    def initialize(categories_json = nil)
+      if categories_json
+        load_categories(categories_json)
+      else
+        load_standard_categories
+      end
+    end
+
+    def load_categories(json)
+      raw = JSON.parse(json, symbolize_names: true)
+      raw = raw[:categories]
+
+      @categories ||= {}
+      raw.each do |category_info|
+        category = Emojidex::Category.new category_info
+        @categories[category.code.to_sym] = category
+      end
+    end
+
+    def load_standard_categories
+      load_categories(IO.read(
+          File.expand_path('../../../emoji/categories.json', __FILE__)))
+    end
+  end
+end

data/lib/emojidex/category.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Emojidex
+  # Category information
+  class Category
+    attr_accessor :code, :en, :ja
+
+    def initialize(details = {})
+      @code = details[:code]
+      @en = details[:en]
+      @ja = details[:ja]
+    end
+  end
+end

data/lib/emojidex/client.rb

@@ -0,0 +1,60 @@
+require 'faraday'
+require 'faraday_middleware'
+
+require 'emojidex/api/categories'
+require 'emojidex/api/emoji'
+require 'emojidex/api/search/emoji'
+
+module Emojidex
+  # get the data from emojidex.com
+  class Client
+    attr_accessor :api_key, :api_username
+    attr_reader :host
+
+    include Emojidex::API::Categories
+    include Emojidex::API::Emoji
+    include Emojidex::API::Search::Emoji
+
+    def initialize(opts = {})
+      @api_key = opts[:api_key]
+      @api_username = opts[:api_username]
+      @host = opts[:host] || 'https://www.emojidex.com/'
+    end
+
+    def connection_options
+      @connection_options ||= {
+        url: @host,
+        headers: {
+          accept: 'application/json',
+          user_agent: user_agent
+        }
+      }
+    end
+
+    def user_agent
+      @user_agent ||= 'Emojidex Toolkit Client'
+    end
+
+    def get(path, params = {})
+      request(:get, path, params)
+    end
+
+    private
+
+    def connection
+      @connection ||= Faraday.new connection_options do |conn|
+        conn.request :url_encoded
+        conn.response :json
+        # conn.response :logger
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    def request(method, path, params = {})
+      response = connection.send(method.to_sym, path, params)
+      response.env
+    rescue Faraday::Error::ClientError, JSON::ParserError
+     raise Emojidex::Error
+    end
+  end
+end

data/lib/emojidex/collection.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+require 'json'
+require_relative 'emoji'
+require_relative 'categories'
+require_relative 'cache'
+
+module Emojidex
+  # listing and search of standard UTF emoji
+  class Collection
+    include Emojidex::Cache
+    attr_accessor :emoji, :categories
+    attr_reader :source_path
+    # Initialize Collection. You can pass a list of emoji to seed the collection
+    def initialize(emoji_list = nil)
+      @emoji = {}
+      add_emoji(emoji_list) unless emoji_list.nil?
+    end
+
+    # Loads an emoji collection on local storage
+    def load_local_collection(path)
+      @source_path = File.expand_path(path)
+      json = IO.read(@source_path + '/emoji.json')
+      list = JSON.parse(json, symbolize_names: true)
+      add_emoji(list)
+    end
+
+    # each override to map each functionality to the emoji hash values
+    def each
+      return @emoji.values.each unless block_given?
+      @emoji.values.each { |emoji| yield emoji }
+    end
+
+    # select override to map select functionality to the emoji hash values
+    def select
+      return @emoji.values.select unless block_given?
+      @emoji.values.select { |emoji| yield emoji }
+    end
+
+    # Retreives an Emoji object by the actual moji code/character code
+    # Will likely only return moji from UTF collection
+    def find_by_moji(moji)
+      result = nil
+      each do |emoji|
+        result = emoji if emoji[:moji] == moji
+      end
+      result
+    end
+
+    alias_method :文字検索, :find_by_moji
+
+    # Gets the emoji with the specified code
+    # Returns the Emoji object or nil if no emoji with that code is found
+    def find_by_code(code)
+      @emoji[code.gsub(/\s/, '_').to_sym]
+    end
+
+    # Locates emoji by Japanese code (original Japanese emoji name [絵文字名])
+    # Only applies to collections that contain JA codes, this function is mapped to
+    # find_by_code for all other implementations (such as client)
+    def find_by_code_ja(code_ja)
+      each do |emoji|
+        return emoji if emoji[:code_ja] == code_ja
+      end
+    end
+
+    alias_method :コード検索, :find_by_code_ja
+
+    def search(criteria = {})
+      Emojidex::Collection.new _sub_search(@emoji.values.dup, criteria)
+    end
+
+    # Get all emoji from this collection that are part of the specified category
+    # Returns a new collection of only emoji in the specified category
+    def category(category_code)
+      categorized = @emoji.values.select { |moji| moji.category == category_code }
+      Emojidex::Collection.new categorized
+    end
+
+    # Check to see if there are emoji in this collection which have the specified categories
+    # Returns true if there are emoji for all secified categories within this collection
+    def category?(*category_codes)
+      (category_codes.uniq - @categories).empty?
+    end
+
+    # Adds emojis to the collection
+    # After add categories are updated
+    def add_emoji(list)
+      list.each do |moji_info|
+        if moji_info.instance_of? Emojidex::Emoji
+          @emoji[moji_info.code.to_sym] = moji_info.dup
+        else
+          emoji = Emojidex::Emoji.new moji_info
+          @emoji[emoji.code.to_sym] = emoji
+        end
+      end
+      categorize
+      @emoji
+    end
+
+    alias_method :<<, :add_emoji
+
+    private
+
+    # Makes a list of all categories which contain emoji in this collection
+    def categorize
+      @categories = @emoji.values.map { |moji| moji.category }
+      @categories.uniq!
+    end
+
+    def _sub_search(list, criteria = {})
+      cr = criteria.shift
+      return list if cr.nil?
+
+      list = list.select { |moji| moji if moji[cr[0]] =~ /#{cr[1]}/ }
+      _sub_search(list, criteria)
+    end
+  end
+end

data/lib/emojidex/defaults.rb

@@ -0,0 +1,13 @@
+module Emojidex
+  # Global defines for emojidex
+  class Defaults
+    def self.sizes
+      { ldpi: 9, mdpi: 18, hdpi: 27, xhdpi: 36, px8: 8,
+        px16: 16, px32: 32, px64: 64, px128: 128, px256: 256 }
+    end
+
+    def self.formats
+      [':svg', ':png']
+    end
+  end
+end

data/lib/emojidex/emoji.rb

@@ -0,0 +1,74 @@
+#
+# Emojidex::Emoji
+#
+module Emojidex
+  # emoji base class
+  class Emoji
+    attr_accessor :moji, :category, :code, :unicode,
+                  :tags, :frames, :delays
+
+    def initialize(details = {})
+      @moji = details[:moji]
+      @code, @code_ja = details[:code], details[:code_ja]
+      @unicode = details[:unicode]
+      @category = details[:category] ? details[:category].to_sym : :other
+      @tags = details[:tags].map { |tag| tag.to_sym } unless details[:tags].nil?
+      @frames = details[:frames] || [@code]
+      @delays = details[:delays] || [100]
+      @loops = details[:loops]
+      @link = details[:link]
+      @is_wide = details[:is_wide]
+    end
+
+    def to_s
+      @moji || ':' + @code + ':'
+    end
+
+    def to_json(*args)
+      to_hash.to_json(*args)
+    end
+
+    def to_hash
+      hash = {}
+      instance_variables.each do |key|
+        hash[key.to_s.delete('@')] = instance_variable_get(key)
+      end
+      hash
+    end
+
+    def [](key)
+      instance_variable_get(key.to_s.delete(':').insert(0, '@'))
+    end
+
+    def []=(key, val)
+      instance_variable_set(key.to_s.delete(':').insert(0, '@'), val)
+    end
+
+    def set_animation_data(params)
+      set_frames(params)
+      set_delays(params)
+    end
+
+    def set_frames(params)
+      return if params[:frames].nil?
+
+      @frames = params[:frames].clone
+      params[:frames].each_with_index do |frame, i|
+        @frames[i] = frame.keys.first.to_s if frame.is_a? Hash
+      end
+    end
+
+    def set_delays(params)
+      default_delay = params[:default_delay] || 100
+
+      @delays = params[:delays] unless params[:delays].nil?
+      if @delays.length < @frames.length
+        @delays << default_delay until @delays.length == @frames.length
+      end
+    end
+
+    def animated?
+      @frames.count > 1
+    end
+  end
+end

data/lib/emojidex/error.rb

@@ -0,0 +1,15 @@
+module Emojidex
+  # emojidex error class
+  class Error < StandardError
+    attr_reader :wrapped_exception
+
+    def initialize(exception = $ERROR_INFO)
+      @wrapped_exception = exception
+      if exception.respond_to?(:message)
+        super(exception.message)
+      else
+        super(exception.to_s)
+      end
+    end
+  end
+end

data/lib/emojidex/extended.rb

@@ -0,0 +1,15 @@
+require_relative 'collection'
+
+module Emojidex
+  # listing and search of extended emoji from the emojidex set
+  class Extended < Collection
+    def initialize
+      super
+      if defined? Emojidex::Vectors
+        load_local_collection Emojidex::Vectors.path + '/extended'
+      else
+        # TODO load from service
+      end
+    end
+  end
+end

data/lib/emojidex/service.rb

@@ -0,0 +1,32 @@
+require_relative 'collection'
+require_relative 'client'
+
+module Emojidex
+  # listing and search of emoji from the online service/emojidex.com
+  class Service < Collection
+    attr_accessor :client
+    def initialize(emoji_list = nil, client_opts = {})
+      super emoji_list
+      @client = Emojidex::Client.new client_opts
+    end
+
+    # sends an API search, adding results with add_emoji
+    # returns a collection, and adds results to the @emoji array
+    def search(criteria = {})
+      # TODO *NOTE try and replicate regex search functionality by passing regex to server
+    end
+
+    # directly retrieves the emoji with the given code
+    def find_by_code(code)
+      # TODO
+    end
+
+    # emoji on the emojidex service make no language distinctions
+    # find_by_code_ja is simply remapped to find_by_code
+    def find_by_code_ja(code)
+      find_by_code(code)
+    end
+
+    # TODO override or add caching functionality to retrieve sized png or svg from service
+  end
+end

data/lib/emojidex/utf.rb

@@ -0,0 +1,15 @@
+require_relative 'collection'
+
+module Emojidex
+  # listing and search of standard UTF emoji
+  class UTF < Collection
+    def initialize
+      super 
+      if defined? Emojidex::Vectors
+        load_local_collection Emojidex::Vectors.path + '/utf'
+      else
+        # TODO load from service
+      end
+    end
+  end
+end

data/spec/api/categories_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Emojidex::API::Categories do
+
+  subject { Emojidex::Client.new(host: 'http://localhost') }
+  let!(:api_url) { 'http://localhost/api/v1' }
+
+  describe '#categories' do
+    before do
+      stub_get("#{api_url}/categories.json")
+        .to_return(
+                    body: fixture('categories.json'),
+                    headers: { content_type: 'application/json' }
+                  )
+    end
+
+    it 'requests the correct resource' do
+      subject.categories
+      expect(a_get("#{api_url}/categories.json")).to have_been_made
+    end
+
+    it 'returns the requested categories' do
+      categories = subject.categories
+      expect(categories).to be_an Array
+      expect(categories.first).to be_a Hash
+    end
+  end
+
+  describe '#category' do
+    before do
+      stub_get("#{api_url}/categories/category.json")
+        .to_return(
+                    body: fixture('category.json'),
+                    headers: { content_type: 'application/json' }
+                  )
+    end
+
+    it 'requests the correct resource' do
+      subject.category
+      expect(a_get("#{api_url}/categories/category.json")).to have_been_made
+    end
+
+    it 'returns the requested category' do
+      category = subject.category
+      expect(category).to be_a Hash
+    end
+  end
+
+end