imagekitio 1.0.3

data/Rakefile

@@ -0,0 +1,27 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Imagekit::Sdk'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/carrierwave/storage/ik_file.rb

@@ -0,0 +1,50 @@
+module CarrierWave
+    module Storage
+      class IKFile
+        # Initialize as required.
+        
+        def initialize(identifier)
+          @identifier=JSON.parse(identifier)
+          ik_config=Rails.application.config.imagekit
+          @imagekit=ImageKit::ImageKitClient.new(ik_config[:private_key],ik_config[:public_key],ik_config[:url_endpoint])
+        end
+
+        # Duck-type methods for CarrierWave::SanitizedFile. 
+        def content_type
+            "image/jpg"
+        end
+        def public_url
+          @identifier['url']
+        end
+        def url(options = {})
+          @identifier['url']
+        end
+
+        def fileId
+          @identifier['fileId']
+        end
+        def filename(options = {})
+          @identifier['name']
+        end
+        def read
+        end
+        def size
+        end
+        def delete
+          # file_id=@identifier['fileId']
+          begin
+            @imagekit.delete_file(fileId)
+          rescue
+            fileId
+          end
+          # binding.pry
+          # return nil
+        end
+        def exists?
+        end
+        # Others... ?
+      end
+
+    end
+
+end

data/lib/carrierwave/storage/imagekit_store.rb

@@ -0,0 +1,68 @@
+require 'uri'
+require 'net/http'
+require 'base64'
+module CarrierWave
+    module Storage
+        class ImageKitStore < Abstract
+
+          def initialize(*)
+              super
+              @cache_called = nil
+          end
+          
+          def store!(file)
+            file.delete
+          end
+
+          def retrieve!(identifier)
+            
+            IKFile.new(identifier)
+          end
+
+          def cache!(new_file)
+            new_file.move_to(::File.expand_path(uploader.cache_path, uploader.root), uploader.permissions, uploader.directory_permissions, true)
+            rescue Errno::EMLINK, Errno::ENOSPC => e
+              raise(e) if @cache_called
+              @cache_called = true
+      
+              # NOTE: Remove cached files older than 10 minutes
+              clean_cache!(600)
+      
+              cache!(new_file)
+          end
+
+          def retrieve_from_cache!(identifier)
+              CarrierWave::SanitizedFile.new(::File.expand_path(uploader.cache_path(identifier), uploader.root))
+              resp=@client.get(identifier)
+            # binding.pry
+              IKFile.new(resp)
+          end
+
+          def delete_dir!(path)
+              if path
+                begin
+                  Dir.rmdir(::File.expand_path(path, uploader.root))
+                rescue Errno::ENOENT
+                  # Ignore: path does not exist
+                rescue Errno::ENOTDIR
+                  # Ignore: path is not a dir
+                rescue Errno::ENOTEMPTY, Errno::EEXIST
+                  # Ignore: dir is not empty
+                end
+              end
+          end
+
+          def clean_cache!(seconds)
+              Dir.glob(::File.expand_path(::File.join(uploader.cache_dir, '*'), CarrierWave.root)).each do |dir|
+                # generate_cache_id returns key formated TIMEINT-PID(-COUNTER)-RND
+                time = dir.scan(/(\d+)-\d+-\d+(?:-\d+)?/).first.map(&:to_i)
+                time = Time.at(*time)
+                if time < (Time.now.utc - seconds)
+                  FileUtils.rm_rf(dir)
+                end
+              end
+          end
+            
+        end
+    end
+end

data/lib/carrierwave/support/uri_filename.rb

@@ -0,0 +1,10 @@
+module CarrierWave
+    module Support
+        module UriFilename
+            def self.filename(url)
+                path = url.split('?').first
+                URI.decode(path).gsub(%r{.*/(.*?$)}, '\1')
+            end
+        end
+    end
+end

data/lib/imagekit/constants/defaults.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Enum for defaults
+
+class Default
+  TRANSFORMATION_POSITION = "path"
+  QUERY_TRANSFORMATION_POSITION = "query"
+  VALID_TRANSFORMATION_POSITION = [TRANSFORMATION_POSITION,
+                                   QUERY_TRANSFORMATION_POSITION,].freeze
+  DEFAULT_TIMESTAMP = "9999999999"
+  TRANSFORMATION_PARAMETER = "tr"
+  CHAIN_TRANSFORM_DELIMITER = ":"
+  TRANSFORM_DELIMITER = ","
+  TRANSFORM_KEY_VALUE_DELIMITER = "-"
+
+  SIGNATURE_PARAMETER = "ik-s"
+  TIMESTAMP_PARAMETER = "ik-t"
+  TIMESTAMP = "9999999999"
+
+end

data/lib/imagekit/constants/errors.rb

@@ -0,0 +1,71 @@
+MANDATORY_INIT_MISSING = {
+  'message': "Missing public_key or private_key or url_endpoint during ImageKit initialization",
+  help: "",
+}
+INVALID_TRANSFORMATION_POS = {'message': "Invalid transformationPosition parameter",
+                              help: "",}
+INVALID_URL_GENERATION_PARAM = {'message': "Invalid url parameter", help: ""}
+INVALID_TRANSFORMATION_OPTIONS = {
+  'message': "Invalid transformation parameter options",
+  help: "",
+}
+CACHE_PURGE_URL_MISSING = {'message': "Missing URL parameter for this request",
+                           help: "",}
+CACHE_PURGE_STATUS_ID_MISSING = {'message': "Missing Request ID parameter for this request",
+                                 help: "",}
+FILE_ID_MISSING = {'message': "Missing File ID parameter for this request",
+                   help: "",}
+UPDATE_DATA_MISSING = {'message': "Missing file update data for this request",
+                       help: "",}
+
+UPDATE_DATA_TAGS_INVALID = {'message': "Invalid tags parameter for this request",
+                            help: "tags should be passed as null or an array like ['tag1', 'tag2']",}.freeze
+
+UPDATE_DATA_COORDS_INVALID =
+  {'message': "Invalid custom_coordinates parameter for this request",
+   help: "custom_coordinates should be passed as null or a string like 'x,y,width,height'",}
+
+LIST_FILES_INPUT_MISSING = {
+  'message': "Missing options for list files",
+  help: "If you do not want to pass any parameter for listing, pass an empty object",
+}
+MISSING_FILE_URL = {'message': "Missing file_url for purge_cache", help: ""}
+MISSING_UPLOAD_DATA = {'message': "Missing data for upload", help: ""}
+MISSING_UPLOAD_FILE_PARAMETER = {
+  'message': "Missing file parameter for upload",
+  help: "",
+}
+MISSING_UPLOAD_FILENAME_PARAM = {
+  'message': "Missing fileName parameter for upload",
+  help: "",
+}
+
+INVALID_PHASH_VALUE =
+  {
+    'message': "Invalid pHash value",
+    help: "Both pHash strings must be valid hexadecimal numbers",
+  }
+
+MISSING_PHASH_VALUE = {
+  'message': "Missing pHash value",
+  help: "Please pass two pHash values",
+}
+UNEQUAL_STRING_LENGTH = {
+  '': "Unequal pHash string length",
+  help: "For distance calculation, the two pHash strings must have equal length",
+}
+
+MISSING_UPLOAD_FILE_PARAMETER = {'message': "Missing file parameter for upload",
+                                 'help': "",}
+MISSING_UPLOAD_FILENAME_PARAM = {
+  'message': "Missing fileName parameter for upload",
+  'help': "",
+}
+
+INVALID_PHASH_VALUE = {'message': "Invalid pHash value",
+                       'help': "Both pHash strings must be valid hexadecimal numbers",}
+
+MISSING_PHASH_VALUE = {'message': "Missing pHash value",
+                       'help': "Please pass two pHash values",}
+UNEQUAL_STRING_LENGTH = {'message': "Unequal pHash string length",
+                         'help': "For distance calculation, the two pHash strings must have equal length",}

data/lib/imagekit/constants/file.rb

@@ -0,0 +1,5 @@
+VALID_FILE_OPTIONS = %w[path fileType tags includeFolder name limit skip]
+
+VALID_FILE_DETAIL_OPTIONS = ["fileID"]
+
+VALID_UPLOAD_OPTIONS = %w[file file_name use_unique_file_name tags folder is_private_file custom_coordinates response_fields]

data/lib/imagekit/constants/supported_transformation.rb

@@ -0,0 +1,44 @@
+SUPPORTED_TRANS = {
+  'height': "h",
+  'width': "w",
+  'aspect_ratio': "ar",
+  'quality': "q",
+  'crop': "c",
+  'crop_mode': "cm",
+  'x': "x",
+  'y': "y",
+  'focus': "fo",
+  'format': "f",
+  'radius': "r",
+  'background': "bg",
+  'border': "bo",
+  'rotation': "rt",
+  'blur': "bl",
+  'named': "n",
+  'overlay_image': "oi",
+  'overlay_x': "ox",
+  'overlay_y': "oy",
+  'overlay_focus': "ofo",
+  'overlay_height': "oh",
+  'overlay_width': "ow",
+  'overlay_text': "ot",
+  'overlay_text_font_size': "ots",
+  'overlay_text_font_family': "otf",
+  'overlay_text_color': "otc",
+  'overlay_alpha': "oa",
+  'overlay_text_typography': "ott",
+  'overlay_background': "obg",
+  'overlay_image_trim': "oit",
+  'progressive': "pr",
+  'lossless': "lo",
+  'trim': "t",
+  'metadata': "md",
+  'color_profile': "cp",
+  'default_image': "di",
+  'dpr': "dpr",
+  'effect_sharpen': "e-sharpen",
+  'effect_usm': "e-usm",
+  'effect_contrast': "e-contrast",
+  'effect_gray': "e-grayscale",
+  'original': "orig",
+}

data/lib/imagekit/constants/url.rb

@@ -0,0 +1,9 @@
+class URL
+  # Default URL Constants
+  BASE_URL = "https://api.imagekit.io/v1/files"
+  PURGE_CACHE = "/purge"
+  BULK_FILE_DELETE = "/batch/deleteByFileIds"
+  UPLOAD = "/upload"
+  REMOTE_METADATA_FULL_URL = "https://api.imagekit.io/v1/metadata"
+
+end

data/lib/imagekit/file.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "./constants/errors"
+require_relative "./constants/file"
+require_relative "./constants/url"
+
+require_relative "./utils/formatter"
+
+class ImageKitFile
+  # This File class holds file related operations like
+  # upload, list etc
+  def initialize(req_obj)
+    @req_obj = req_obj
+  end
+
+  def upload(file, file_name, options)
+    # uploads files with required arguments
+    # supports bot url and binary
+    raise ArgumentError, MISSING_UPLOAD_FILE_PARAMETER unless file
+    raise ArgumentError, MISSING_UPLOAD_FILE_PARAMETER unless file_name
+    options = validate_upload_options(options || {})
+    if options.is_a?(FalseClass)
+      raise ArgumentError, "Invalid Upload option"
+    else
+      headers = @req_obj.create_headers
+      payload = {multipart: true, file: file, fileName: file_name}.merge(options)
+
+      url = "#{URL::BASE_URL}#{URL::UPLOAD}"
+      @req_obj.request("post", url, headers, payload)
+    end
+  end
+
+  def update_details(file_id, options)
+    # Update file detail by file_id and options
+
+    unless (options.key? :tags) || (options.key? :custom_coordinates)
+      raise ArgumentError, UPDATE_DATA_MISSING
+    end
+    unless options.fetch(:tags, []).is_a?(Array)
+      raise ArgumentError, UPDATE_DATA_TAGS_INVALID
+    end
+    unless options.fetch(:custom_coordinates, "").is_a?(String)
+      raise ArgumentError, UPDATE_DATA_COORDS_INVALID
+    end
+    url = "#{URL::BASE_URL}/#{file_id}/details/"
+    headers = @req_obj.create_headers
+    payload = request_formatter(options)
+    @req_obj.request("patch", url, headers, payload.to_json)
+  end
+
+  def list(options)
+    #  returns list of files on ImageKit Server
+    #  :options dictionary of options
+    formatted_options = request_formatter(options)
+    raise KeyError(LIST_FILES_INPUT_MISSING) unless formatted_options.is_a?(Hash)
+    url = URL::BASE_URL
+    headers = @req_obj.create_headers.update({params: options})
+    @req_obj.request("get", url, headers, options)
+  end
+
+  def details(file_identifier)
+    # Get detail of file by file_identifier
+    url = "#{URL::BASE_URL}/#{file_identifier}/details/"
+    headers = @req_obj.create_headers
+    @req_obj.request("get", url, headers)
+  end
+
+  def get_metadata(file_id)
+    # Get metadata of a file by file_id
+    url = "#{URL::BASE_URL}/#{file_id}/metadata"
+    @req_obj.request("get", url, @req_obj.create_headers)
+  end
+
+  def delete(file_id)
+    # Delete a file_id by file_id
+    url = "#{URL::BASE_URL}/#{file_id}"
+    headers = @req_obj.create_headers
+    @req_obj.request("delete", url, headers)
+  end
+
+  def batch_delete(file_ids)
+    url = "#{URL::BASE_URL}#{URL::BULK_FILE_DELETE}"
+    payload = {'fileIds': file_ids}
+    @req_obj.request("post", url, @req_obj.create_headers, payload.to_json)
+  end
+
+  def purge_cache(file_url)
+
+    # purges cache from server by file_url
+
+    url = "#{URL::BASE_URL}/purge"
+    payload = {'url': file_url}
+    @req_obj.request("post", url, @req_obj.create_headers, payload)
+  end
+
+  def purge_cache_status(request_id)
+    # This function is to get cache_status
+    url = "#{URL::BASE_URL}/purge/#{request_id}"
+    @req_obj.request("get", url, @req_obj.create_headers)
+  end
+
+  def get_metadata_from_remote_url(remote_file_url)
+    if remote_file_url == ""
+      raise ArgumentError, "remote_file_url is required"
+    end
+    url = "#{URL::REMOTE_METADATA_FULL_URL}?url=#{remote_file_url}"
+    @req_obj.request("get", url, @req_obj.create_headers)
+  end
+
+  def validate_upload_options(options)
+
+    #  Validates upload value, checks if params are valid,
+    #  changes snake to camel case which is supported by
+    #  ImageKit server
+
+
+    response_list = []
+    options.each do |key, val|
+      if VALID_UPLOAD_OPTIONS.include?(key.to_s)
+        if val.is_a?(Array)
+          val = val.join(",")
+        end
+        if val.is_a?(TrueClass) || val.is_a?(FalseClass)
+          val = val.to_s
+        end
+        options[key] = val
+      else
+        return false
+      end
+    end
+    request_formatter(options)
+  end
+end