myimagegemsdemo 1.0.2

data/lib/imagekit/imagekit.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+$VERBOSE = nil
+
+require_relative "./resource"
+require_relative "./file"
+require_relative "./url"
+require_relative "./utils/calculation"
+
+module ImageKit
+  class Error < StandardError
+  end
+
+  # ImageKit class holds each method will be used by user
+  class ImageKitClient
+    attr_reader :file
+
+    def initialize(private_key, public_key, url_endpoint, transformation_pos = nil, options = nil)
+      @private_key = private_key
+      @public_key = public_key
+      @url_endpoint = url_endpoint
+      @transformation_position = transformation_pos
+      @options = options
+
+      @ik_req = ImageKitRequest.new(private_key, public_key, url_endpoint)
+      @file = ImageKitFile.new(@ik_req)
+      @url_obj = Url.new(@ik_req)
+
+    end
+
+    def set_ik_request(ik_req)
+      # setter for imagekit request mainly will be used for
+      # test
+      @ik_req = ik_req
+    end
+
+    def url(options)
+      @url_obj.generate_url(options)
+    end
+
+    def upload_file(file = nil, file_name = nil, options = nil)
+      # upload file to imagekit server
+      @file.upload(file, file_name, options)
+    end
+
+    def list_files(options)
+      # list all files
+      @file.list(options)
+    end
+
+    def get_file_details(file_identifier)
+      # Get file detail by file-id or file_url
+      @file.details(file_identifier)
+    end
+
+    def update_file_details(file_id, options)
+      # update file details by file id and other options payload
+      @file.update_details(file_id, options)
+    end
+
+    def delete_file(file_id)
+      # Delete a file by file-id
+      @file.delete(file_id)
+    end
+
+    def bulk_file_delete(file_ids)
+      # Delete file in bulks by list of file id
+      @file.batch_delete(file_ids)
+    end
+
+    def get_file_metadata(file_id)
+      # Get metadata of a file by file-id
+      @file.get_metadata(file_id)
+    end
+
+    def purge_file_cache(file_url)
+      # Purge cache from ImageKit server by file_url
+      @file.purge_cache(file_url)
+    end
+
+    def purge_file_cache_status(request_id)
+      @file.purge_cache_status(request_id.to_s)
+    end
+
+    def get_remote_file_url_metadata(remote_file_url = "")
+      @file.get_metadata_from_remote_url(remote_file_url)
+    end
+
+    # Get metadata from remote_file_url
+    # param remote_file_url: url string of remote file
+
+    def phash_distance(first, second)
+      # Get hamming distance between two phash(image hash) to check
+      # similarity between images
+
+      unless first && second
+        raise ArgumentError, Error::MISSING_PHASH_VALUE
+      end
+      hamming_distance(first, second)
+    end
+
+    def get_authentication_parameters(token = nil, expire = nil)
+      # Get Authentication params
+      get_authenticated_params(token, expire, @ik_req.private_key)
+    end
+  end
+end
+

data/lib/imagekit/resource.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "base64"
+require "rest-client"
+require "json"
+require_relative "./constants/defaults"
+
+# ImageKitRequest requests and sends data from server
+class ImageKitRequest
+  attr_reader :private_key, :public_key, :url_endpoint, :transformation_position, :options
+
+  def initialize(private_key, public_key, url_endpoint, transformation_position = nil, options = nil)
+    @private_key = private_key
+    @public_key = public_key
+    @url_endpoint = url_endpoint
+    @transformation_position = transformation_position || Default::TRANSFORMATION_POSITION
+    @options = options || {}
+  end
+
+  # creates required headers
+  def create_headers
+    headers = {'Accept-Encoding': "application/json", 'Content-Type': "application/json"}
+    headers.update(auth_headers)
+  end
+
+  def auth_headers
+    encoded_private_key = Base64.strict_encode64(@private_key+":")
+    {Authorization: "Basic #{encoded_private_key}"}
+  end
+
+  # request method communicates with server
+  def request(method, url, headers = nil, payload = nil)
+    headers ||= create_headers
+    response = {response: nil, error: nil}
+    begin
+      resp = RestClient::Request.new(method: method,
+                                     url: url,
+                                     headers: headers,
+                                     payload: payload).execute
+
+
+      if resp.code == 404
+        raise RestClient::ExceptionWithResponse
+      elsif (resp.code >= 200) && (resp.code < 204)
+        response[:response] = JSON.parse(resp.body.to_s)
+      elsif resp.code == 204
+        response[:response] = {'success': true}
+      end
+
+    rescue RestClient::ExceptionWithResponse => err
+      err.http_code == 404 ? response[:error] = {'message': err.response.to_s} : JSON.parse(err.response)
+    end
+    response
+  end
+end

data/lib/imagekit/sdk/version.rb

@@ -0,0 +1,5 @@
+module Imagekit
+  module Sdk
+    VERSION = '1.0.2'
+  end
+end

data/lib/imagekit/url.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+# Url holds url generation method
+
+require "cgi"
+require "openssl"
+require_relative "./utils/formatter"
+require_relative "./constants/defaults"
+require_relative "./constants/supported_transformation"
+require_relative "./sdk/version.rb"
+
+class Url
+  def initialize(request_obj)
+    @req_obj = request_obj
+  end
+
+  def generate_url(options)
+    if options.key? :src
+      options[:transformation_position] = Default::TRANSFORMATION_POSITION
+    end
+    extended_options = extend_url_options(options)
+    build_url(extended_options)
+  end
+
+  def build_url(options)
+    # build url from all options
+
+    path = options.fetch(:path, "")
+    src = options.fetch(:src, "")
+    url_endpoint = options.fetch(:url_endpoint, "")
+    transformation_position = options[:transformation_position]
+
+    unless Default::VALID_TRANSFORMATION_POSITION.include? transformation_position
+      raise ArgumentError, INVALID_TRANSFORMATION_POS
+    end
+
+    src_param_used_for_url = false
+    if (src != "") || (transformation_position == Default::QUERY_TRANSFORMATION_POSITION)
+      src_param_used_for_url = true
+    end
+
+    if path == "" && src == ""
+      return ""
+    end
+
+    result_url_hash = {'host': "", 'path': "", 'query': ""}
+    existing_query=nil
+    if path != ""
+      parsed_url = URI.parse(path)
+      existing_query=parsed_url.query
+      parsed_host = URI(url_endpoint)
+      result_url_hash[:scheme] = parsed_host.scheme
+
+      # making sure single '/' at end
+      result_url_hash[:host] = parsed_host.host.to_s.chomp("/") + parsed_host.path.chomp("/") + "/"
+      result_url_hash[:path] = trim_slash(parsed_url.path)
+    else
+      parsed_url = URI.parse(src)
+      existing_query=parsed_url.query
+      host = parsed_url.host
+      result_url_hash[:userinfo] = parsed_url.userinfo if parsed_url.userinfo
+      result_url_hash[:host] = host
+      result_url_hash[:scheme] = parsed_url.scheme
+      result_url_hash[:path] = parsed_url.path
+      src_param_used_for_url = true
+    end
+    query_params = {}
+    if existing_query!=nil
+      existing_query.split("&").each do |part|
+        parts=part.split("=")
+        if parts.length==2
+          query_params[parts[0]]=parts[1]
+        else
+          query_params[parts[0]]=""
+        end
+      end
+    end
+    options.fetch(:query_parameters, {}).each do |key, value|
+      query_params[key]=value
+    end
+    transformation_str = transformation_to_str(options[:transformation]).chomp("/")
+
+    if transformation_str
+      if (transformation_position == Default::QUERY_TRANSFORMATION_POSITION) || src_param_used_for_url == true
+        result_url_hash[:query] = "#{Default::TRANSFORMATION_PARAMETER}=#{transformation_str}"
+        query_params[:tr]=transformation_str
+      else
+        result_url_hash[:path] = "#{Default::TRANSFORMATION_PARAMETER}:#{transformation_str}/#{result_url_hash[:path]}"
+      end
+
+    end
+
+    result_url_hash[:host] = result_url_hash[:host].to_s.reverse.chomp("/").reverse
+    result_url_hash[:path] = result_url_hash[:path].chomp("/")
+    result_url_hash[:scheme] ||= "https"
+
+
+    # Signature String and Timestamp
+    # We can do this only for URLs that are created using urlEndpoint and path parameter
+    # because we need to know the endpoint to be able to remove it from the URL to create a signature
+    # for the remaining. With the src parameter, we would not know the "pattern" in the URL
+    query_param_arr = []
+    query_param_arr.push("ik-sdk-version=ruby-"+Imagekit::Sdk::VERSION)
+    if options[:signed] && !(options[:src])
+      intermediate_url = result_url_hash.fetch(:scheme, "") + "://" + result_url_hash.fetch(:host, "") + result_url_hash.fetch(:path, "")
+      if result_url_hash[:query]!=nil && result_url_hash[:query]!=""
+        intermediate_url += result_url_hash.fetch(:query, "")
+      end
+    end
+    query_params.each do |key, value|
+      query_param_arr.push(key.to_s + "=" + value.to_s)
+    end
+
+    query_param_str = query_param_arr.join("&")
+    result_url_hash[:query] = query_param_str
+    url=hash_to_url(result_url_hash)
+    if options[:signed]
+      private_key = options[:private_key]
+      expire_seconds = options[:expire_seconds]
+      expire_timestamp = get_signature_timestamp(expire_seconds)
+      url_signature = get_signature(private_key, url, url_endpoint, expire_timestamp)
+      query_param_arr.push(Default::SIGNATURE_PARAMETER + "=" + url_signature)
+
+      if expire_timestamp && (expire_timestamp != Default::TIMESTAMP)
+        query_param_arr.push(Default::TIMESTAMP_PARAMETER + "=" + expire_timestamp.to_s)
+      end
+    
+      query_param_str = query_param_arr.join("&")
+      result_url_hash[:query] = query_param_str
+      
+      url=hash_to_url(result_url_hash)
+    end
+    url
+  end
+
+  def transformation_to_str(transformation)
+    # creates transformation_position string for url
+    # from transformation dictionary
+
+    unless transformation.is_a?(Array)
+      return ""
+    end
+
+    parsed_transforms = []
+    (0..(transformation.length - 1)).each do |i|
+      parsed_transform_step = []
+
+      transformation[i].keys.each do |key|
+        transform_key = SUPPORTED_TRANS.fetch(key, nil)
+        transform_key ||= key
+
+        if transformation[i][key] == "-"
+          parsed_transform_step.push(transform_key)
+        else
+          parsed_transform_step.push("#{transform_key}#{Default::TRANSFORM_KEY_VALUE_DELIMITER}#{transformation[i][key]}")
+        end
+      end
+      parsed_transforms.push(parsed_transform_step.join(Default::TRANSFORM_DELIMITER))
+    end
+    parsed_transforms.join(Default::CHAIN_TRANSFORM_DELIMITER)
+  end
+
+  def get_signature_timestamp(seconds)
+    # this function returns either default time stamp
+    # or current unix time and expiry seconds to get
+    # signature time stamp
+
+    if seconds.to_i == 0
+      Default::DEFAULT_TIMESTAMP
+    else
+      DateTime.now.strftime("%s").to_i + seconds.to_i
+    end
+  end
+
+  def get_signature(private_key, url, url_endpoint, expiry_timestamp)
+    # creates signature(hashed hex key) and returns from
+    # private_key, url, url_endpoint and expiry_timestamp
+    if expiry_timestamp==0
+      expiry_timestamp=Default::DEFAULT_TIMESTAMP
+    end
+    if url_endpoint[url_endpoint.length-1]!="/"
+      url_endpoint+="/"
+    end
+    replaced_url=url.gsub(url_endpoint, "")
+    replaced_url =  replaced_url + expiry_timestamp.to_s
+    OpenSSL::HMAC.hexdigest("SHA1", private_key, replaced_url)
+  end
+
+  def extend_url_options(options)
+    attr_dict = {"public_key": @req_obj.public_key,
+                 "private_key": @req_obj.private_key,
+                 "url_endpoint": @req_obj.url_endpoint,
+                 "transformation_position": @req_obj.transformation_position, }
+    # extending  url options
+    attr_dict.merge(options)
+  end
+
+  def hash_to_url(url_hash)
+    generated_url = url_hash.fetch(:scheme, "") + "://" + url_hash.fetch(:host, "") + url_hash.fetch(:path, "")
+    if url_hash[:query] != ""
+      generated_url = generated_url + "?" + url_hash.fetch(:query, "")
+      return generated_url
+    end
+    generated_url
+  end
+
+  def trim_slash(str, both = true)
+    if str == ""
+      return ""
+    end
+    # remove slash from a string
+    # if both is not provide trims both slash
+    # example - '/abc/' returns 'abc'
+    # if both=false it will only trim end slash
+    # example - '/abc/' returns '/abc'
+    # NOTE: IT'S RECOMMENDED TO USE inbuilt .chomp('string you want to remove')
+    # FOR REMOVING ONLY TRAILING SLASh
+    if both
+      str[0].chomp("/") + str[1..-2] + str[-1].chomp("/")
+    else
+      str.chomp("/")
+    end
+  end
+
+  # class Imagekit
+
+  # end
+end

data/lib/imagekit/utils/calculation.rb

@@ -0,0 +1,36 @@
+require "date"
+require "securerandom"
+
+DEFAULT_TIME_DIFF = 60 * 30
+
+def is_valid_hex(hex_string)
+  # checks if hexadecimal value is valid or not
+  /^[[:xdigit:]]+$/ === hex_string
+end
+
+def hamming_distance(first, second)
+  # Calculate Hamming distance between to hex string
+  unless is_valid_hex(first) && is_valid_hex(second)
+    raise ArgumentError, "Both argument should be hexadecimal"
+  end
+  a = first.to_i(16)
+  b = second.to_i(16)
+  (a ^ b).to_s(2).count("1")
+end
+
+def get_authenticated_params(token, expire, private_key)
+  # return authenticated param
+  default_expire = DateTime.now.strftime("%s").to_i + DEFAULT_TIME_DIFF
+  token ||= SecureRandom.uuid
+
+  auth_params = {'token': token, 'expire': expire, 'signature': ""}
+  unless private_key
+    return nil
+  end
+
+  signature = OpenSSL::HMAC.hexdigest("SHA1", private_key, token.to_s + expire.to_s)
+  auth_params[:token] = token
+  auth_params[:expire] = expire || default_expire
+  auth_params[:signature] = signature
+  auth_params
+end

data/lib/imagekit/utils/formatter.rb

@@ -0,0 +1,29 @@
+def snake_to_camel(word)
+  word_list = word.split("_")
+  result = []
+  word_list&.each { |i|
+    if i == word_list[0]
+      result.push(i)
+    else
+      result.push(i.capitalize)
+    end
+  }
+  result.join
+end
+
+def camel_to_snake(camel_word)
+  # convert camel case to snake case
+  camel_word.to_s.gsub(/::/, "/")
+    .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+    .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+    .tr("-", "_")
+    .downcase
+end
+
+def request_formatter(data)
+  result = {}
+  data.each do |key, val|
+    result[snake_to_camel(key.to_s)] = val
+  end
+  result
+end