emojidex 0.0.23 → 0.1.0

data/lib/emojidex/api/categories.rb

@@ -1,16 +0,0 @@
-module Emojidex
-  module API
-    # Get cateegories from API
-    module Categories
-      def categories(*args)
-        response = get('/api/v1/categories.json', args)
-        response[:body]['categories']
-      end
-
-      def category(*args)
-        response = get('/api/v1/categories/category.json', args)
-        response[:body]
-      end
-    end
-  end
-end

data/lib/emojidex/api/emoji.rb

@@ -1,26 +0,0 @@
-module Emojidex
-  module API
-    # Get emoji from API
-    module Emoji
-      def emoji(*args)
-        response = get('/api/v1/emoji.json', args)
-        response[:body]['emoji']
-      end
-
-      def single_emoji(*args)
-        response = get('/api/v1/emoji/emoji.json', args)
-        response[:body]
-      end
-
-      def emoji_detailed(*args)
-        response = get('/api/v1/emoji/detailed.json', args)
-        response[:body]
-      end
-
-      def single_emoji_detailed(*args)
-        response = get('/api/v1/emoji/1/detailed.json', args)
-        response[:body]
-      end
-    end
-  end
-end

data/lib/emojidex/api/search/emoji.rb

@@ -1,16 +0,0 @@
-module Emojidex
-  module API
-    module Search
-      # Search API for emoji
-      module Emoji
-        def emoji_code_cont(term, options = {})
-          response = get(
-                          '/api/v1/search/emoji.json',
-                          options.merge('q[code_cont]' => term)
-                        )
-          response[:body]
-        end
-      end
-    end
-  end
-end

data/lib/emojidex/client.rb

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

@@ -1,156 +0,0 @@
-# encoding: utf-8
-
-require 'json'
-require_relative 'emoji'
-require_relative 'categories'
-require_relative 'collection/cache'
-require_relative 'collection/asset_information'
-require_relative 'collection/moji_data'
-
-module Emojidex
-  # listing and search of standard UTF emoji
-  class Collection
-    include Emojidex::CollectionCache
-    include Emojidex::CollectionAssetInformation
-    include Emojidex::CollectionMojiData
-    attr_accessor :emoji, :categories,
-                  :source_path, :vector_source_path, :raster_source_path
-
-    # Initialize Collection. You can pass a list of emoji to seed the collection
-    def initialize(emoji_list = nil, local_load_path = nil)
-      @emoji = {}
-      load_local_collection(local_load_path) unless local_load_path.nil?
-      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)
-      @vector_source_path = @source_path if @vector_source_path.nil?
-      @raster_source_path = @source_path if @raster_source_path.nil?
-      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(&block)
-      @emoji.values.each(&block)
-    end
-
-    # select override to map select functionality to the emoji hash values
-    def select(&block)
-      @emoji.values.select(&block)
-    end
-
-    def map(&block)
-      @emoji.values.map(&block)
-    end
-
-    def collect(&block)
-      @emoji.values.collect(&block)
-    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)
-      each do |m|
-        return m if m[:moji] == moji
-      end
-      nil
-    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 |m|
-        return m if m[:code_ja] == code_ja
-      end
-      nil
-    end
-
-    alias_method :コード検索, :find_by_code_ja
-
-    def find_by_unicode(unicode)
-      unicode = unicode.downcase
-      each do |m|
-        return m if m[:unicode] == unicode
-      end
-      nil
-    end
-
-    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
-      associate_variants
-      condense_moji_code_data
-      @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 associate_variants
-      @emoji.values.each do |emoji_obj|
-        if emoji_obj.code.match(/\(.*\)$/) # this emoji is a variant
-          # check for base
-          base_code = emoji_obj.code.sub(/\(.*\)$/, '').to_sym
-          if @emoji.has_key? base_code
-            @emoji[base_code].variants << emoji_obj.code.to_sym
-            emoji_obj.base = base_code
-          end
-        end
-      end
-    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/collection/asset_information.rb

@@ -1,49 +0,0 @@
-require 'digest/md5'
-
-module Emojidex
-  # Asset Information for Collections
-  module CollectionAssetInformation
-    def generate_checksums(formats = Emojidex::Defaults.formats, sizes = Emojidex::Defaults.sizes)
-      @emoji.values.each do |moji|
-        moji.checksums = get_checksums(moji, formats, sizes)
-      end
-    end
-
-    def get_checksums(moji, formats, sizes)
-      sums = {}
-      sums[:svg] = _checksum_for_file("#{@vector_source_path}/#{moji.code}.svg") if formats.include? :svg
-      if formats.include? :png
-        sums[:png] = {}
-        sizes.keys.each do |size|
-          sums[:png][size] = _checksum_for_file("#{@raster_source_path}/#{size}/#{moji.code}.png")
-        end
-      end
-      sums
-    end
-
-    def generate_paths(formats = Emojidex::Defaults.formats, sizes = Emojidex::Defaults.sizes)
-      @emoji.values.each do |moji|
-        moji.paths = get_paths(moji, formats, sizes)
-      end
-    end
-
-    def get_paths(moji, formats, sizes)
-      paths = {}
-      path = "#{@vector_source_path}/#{moji.code}.svg"
-      paths[:svg] = path if File.exist? path
-      if formats.include? :png
-        paths[:png] = {}
-        sizes.keys.each do |size|
-          path = "#{@raster_source_path}/#{size}/#{moji.code}.png"
-          paths[:png][size] = path if File.exist? path
-        end
-      end
-      paths
-    end
-
-    private
-    def _checksum_for_file(path)
-      (File.exist? path)? Digest::MD5.file(path).hexdigest : nil
-    end
-  end
-end

data/lib/emojidex/collection/cache.rb

@@ -1,78 +0,0 @@
-require 'json'
-require 'fileutils'
-require_relative '../defaults'
-
-module Emojidex
-  # local caching functionality for collections
-  module CollectionCache
-    attr_reader :cache_path
-
-    def setup_cache(path = nil)
-      # check if cache dir is already set
-      return @cache_path if @cache_path && path.nil?
-      # setup cache
-      @cache_path = File.expand_path(path || ENV['EMOJI_CACHE'] || "#{ENV['HOME']}/.emojidex/cache")
-      ENV['EMOJI_CACHE'] = @cache_path
-      FileUtils.mkdir_p(@cache_path)
-      Emojidex::Defaults.sizes.keys.each do |size|
-        FileUtils.mkdir_p(@cache_path + "/#{size}")
-      end
-      @cache_path
-    end
-
-    # Caches emoji to local emoji storage cache
-    # Options:
-    #   cache_path: manually specify cache location
-    #     (default is ENV['EMOJI_CACHE'] or '$HOME/.emoji_cache')
-    #   formats: formats to cache (default is SVG only)
-    #   sizes: sizes to cache (default is px32, but this is irrelivant for SVG)
-    def cache!(options = {})
-      setup_cache options[:cache_path]
-      formats = options[:formats] || [:svg, :png]
-      sizes = options[:sizes] || [:px32]
-      @emoji.values.each do |moji|
-        _svg_check_copy(moji) if formats.include? :svg
-        _raster_check_copy(moji, :png, sizes) if formats.include? :png
-      end
-      cache_index
-    end
-
-    def cache_index(destination = nil)
-      destination ||= @cache_path
-      idx = Emojidex::Collection.new
-      idx.load_local_collection(destination) if FileTest.exist? "#{destination}/emoji.json"
-      idx.add_emoji @emoji.values
-      File.open("#{destination}/emoji.json", 'w') do |f|
-        f.write idx.emoji.values.to_json
-      end
-    end
-
-    def write_index(destination)
-      idx = @emoji.values.to_json
-      idx = JSON.parse idx
-      idx.each { |moji| moji.delete_if{ |k, v| v.nil? }}
-      File.open("#{destination}/emoji.json", 'w') { |f| f.write idx.to_json }
-    end
-
-    private
-
-    def _svg_check_copy(moji)
-      src = @source_path + "/#{moji.code}"
-      if File.exist? "#{src}.svg"
-        unless File.exist?("#{@cache_path}/#{moji.code}.svg") &&
-          FileUtils.compare_file("#{src}.svg", "#{@cache_path}/#{moji.code}.svg")
-          FileUtils.cp("#{src}.svg", @cache_path)
-        end
-      end
-      FileUtils.cp_r src, @cache_path if File.directory? src
-    end
-
-    def _raster_check_copy(moji, format, sizes)
-      sizes.each do |size|
-        src = @source_path + "/#{size}/#{moji.code}"
-        FileUtils.cp "#{src}.#{format}", (@cache_path + "/#{size}") if FileTest.exist? "#{src}.#{format}"
-        FileUtils.cp_r src, @cache_path if File.directory? src
-      end
-    end
-  end
-end

data/lib/emojidex/collection_checker.rb

@@ -1,93 +0,0 @@
-
-require 'find'
-require_relative 'defaults.rb'
-
-module Emojidex
-  # Check collections for presence of image assets and discrepencies in emoji indexes.
-  class CollectionChecker
-    attr_reader :index_only, :asset_only
-
-    def initialize(collections, options = {})
-      collections = *collections
-      @index_only = {}
-      @asset_only = {}
-      asset_path = options[:asset_path] || collections.first.source_path
-      sizes = options[:sizes] || Defaults.sizes.keys
-      formats = options[:formats] || Defaults.formats
-
-      asset_files = create_asset_file_list(asset_path, sizes, formats)
-      check_for_index_only(collections, asset_files, sizes, formats)
-      check_for_asset_only(collections, asset_files)
-    end
-
-    private
-
-    def create_asset_file_list(dir, sizes, formats)
-      result = {}
-      result.merge!(create_file_list(dir, '.svg', '')) if formats.include?(:svg)
-      if formats.include?(:png)
-        sizes.each do |size|
-          result.merge!(create_file_list("#{dir}/#{size}", '.png', "#{size}/"))
-        end
-      end
-      result
-    end
-
-    def create_file_list(dir, ext, prefix)
-      result = {}
-      return result unless Dir.exists?(dir)
-      Dir.foreach(dir) do |file|
-        result["#{prefix}#{File.basename(file, '.*')}".to_sym] =
-          "#{prefix}#{file}" if File.extname(file) == ext
-      end
-      result
-    end
-
-    def check_for_index_only(collections, asset_files, sizes, formats)
-      collections.each do |collection|
-        collection.emoji.values.each do |emoji|
-          tmp = []
-          tmp += create_svg_array(emoji, asset_files) if formats.include?(:svg)
-          tmp += create_png_array(emoji, asset_files, sizes) if formats.include?(:png)
-          @index_only[emoji.code.to_sym] = tmp unless tmp.empty?
-        end
-      end
-    end
-
-    def create_svg_array(emoji, asset_files)
-      result = []
-      asset_file = asset_files[emoji.code.to_sym]
-      result << "#{emoji.code}.svg" if asset_files[emoji.code.to_sym].nil?
-      result
-    end
-
-    def create_png_array(emoji, asset_files, sizes)
-      result = []
-      sizes.each do |size|
-        name = "#{size}/#{emoji.code}"
-        result << "#{name}.png" if asset_files[name.to_sym].nil?
-      end
-      result
-    end
-
-    def check_for_asset_only(collections, asset_files)
-      asset_files.each do |_key, value|
-        code = File.basename(value, '.*')
-
-        next if find_emoji_from_collections(collections, code)
-
-        symbol = code.to_sym
-        @asset_only[symbol] = [] if @asset_only[symbol].nil?
-        @asset_only[symbol] << value
-      end
-    end
-
-    def find_emoji_from_collections(collections, code)
-      symbol = code.to_sym
-      collections.each do |collection|
-        return true unless collection.emoji[symbol].nil?
-      end
-      false
-    end
-  end # class CollectionChecker
-end # module Emojidex