resizing 0.1.0

data/lib/resizing/carrier_wave/storage/file.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Resizing
+  module CarrierWave
+    module Storage
+      class File
+        include ::CarrierWave::Utilities::Uri
+
+        def initialize(uploader, identifier = nil)
+          @uploader = uploader
+          @content_type = nil
+          @identifier = identifier
+        end
+
+        def attributes
+          file.attributes
+        end
+
+        def authenticated_url(_options = {})
+          nil
+        end
+
+        def content_type
+          @content_type || file.try(:content_type)
+        end
+
+        attr_writer :content_type
+
+        def delete
+          public_id = model.send :read_attribute, serialization_column
+          # TODO:
+          # refactoring
+          separted = Resizing.separate_public_id(public_id)
+          image_id = separted[:image_id]
+          resp = client.delete(image_id)
+          if resp.nil? # 404 not found
+            model.send :write_attribute, serialization_column, nil
+            return
+          end
+
+          if public_id == resp['public_id']
+            model.send :write_attribute, serialization_column, nil
+            return
+          end
+
+          raise APIError, "raise someone error:#{resp.inspect}"
+        end
+
+        def extension
+          raise NotImplementedError, 'this method is do not used. maybe'
+        end
+
+        ##
+        # Read content of file from service
+        #
+        # === Returns
+        #
+        # [String] contents of file
+        def read
+          file_body = file.body
+
+          return if file_body.nil?
+          return file_body unless file_body.is_a?(::File)
+
+          # Fog::Storage::XXX::File#body could return the source file which was upoloaded to the remote server.
+          read_source_file(file_body) if ::File.exist?(file_body.path)
+
+          # If the source file doesn't exist, the remote content is read
+          @file = nil
+          file.body
+        end
+
+        def size
+          file.nil? ? 0 : file.content_length
+        end
+
+        def exists?
+          !!file
+        end
+
+        def store(new_file)
+          if new_file.is_a?(self.class)
+            # new_file.copy_to(path)
+            raise NotImplementedError, 'new file is required duplicating'
+          end
+
+          @content_type ||= new_file.content_type
+          @response = Resizing.put(identifier, new_file.read, { content_type: @content_type })
+          @public_id = @response['public_id']
+
+          # force update column
+          # model_class
+          #   .where(primary_key_name => model.send(primary_key_name))
+          #   .update_all(serialization_column=>@public_id)
+
+          # save new value to model class
+          model.send :write_attribute, serialization_column, @public_id
+
+          true
+        end
+
+        attr_reader :public_id
+
+        def identifier
+          if public_id.present?
+            public_id
+          else
+            @identifier = SecureRandom.uuid
+          end
+        end
+
+        def filename(options = {})
+          file_url = url(options)
+          return unless file_url
+
+          CGI.unescape(file_url.split('?').first).gsub(%r{.*/(.*?$)}, '\1')
+        end
+
+        # def copy_to(new_path)
+        #   CarrierWave::Storage::Fog::File.new(@uploader, @base, new_path)
+        # end
+
+        private
+
+        attr_reader :uploader
+
+        def model
+          @model ||= uploader.model
+        end
+
+        def model_class
+          @model_class ||= model.class
+        end
+
+        def primary_key_name
+          @primary_key_name ||= model_class.primary_key.to_sym
+        end
+
+        def serialization_column
+          @serialization_column ||= model.send(:_mounter, uploader.mounted_as).send(:serialization_column)
+        end
+
+        ##
+        # client of Resizing
+        def client
+          @client ||= if Resizing.configure.enable_mock
+                        Resizing::MockClient.new
+                      else
+                        Resizing::Client.new
+                      end
+        end
+
+        ##
+        # lookup file
+        #
+        # === Returns
+        #
+        # [Fog::#{provider}::File] file data from remote service
+        #
+        # def file
+        #   @file ||= directory.files.head(path)
+        # end
+
+        def read_source_file(file_body)
+          return unless ::File.exist?(file_body.path)
+
+          begin
+            file_body = ::File.open(file_body.path) if file_body.closed? # Reopen if it's already closed
+            file_body.read
+          ensure
+            file_body.close
+          end
+        end
+
+        def url_options_supported?(local_file)
+          parameters = local_file.method(:url).parameters
+          parameters.count == 2 && parameters[1].include?(:options)
+        end
+
+        # def store! sanitized_file
+        #   puts sanitized_file.inspect
+        #   client = Resizing::Client.new
+        #   @store_response = client.post(sanitized_file.to_file, {content_type: sanitized_file.content_type})
+        # end
+
+        def retrieve!(identifier)
+          raise NotImplementedError, "retrieve! #{identifier}"
+        end
+
+        # def cache!(new_file)
+        #   raise NotImplementedError,
+        #     "Need to implement #cache! if you want to use #{self.class.name} as a cache storage."
+        # end
+
+        # def retrieve_from_cache!(identifier)
+        #   raise NotImplementedError,
+        #     "Need to implement #retrieve_from_cache! if you want to use #{self.class.name} as a cache storage."
+        # end
+
+        # def delete_dir!(path)
+        #   raise NotImplementedError,
+        #     "Need to implement #delete_dir! if you want to use #{self.class.name} as a cache storage."
+        # end
+
+        # def clean_cache!(seconds)
+        #   raise NotImplementedError,
+        #     "Need to implement #clean_cache! if you want to use #{self.class.name} as a cache storage."
+        # end
+      end
+    end
+  end
+end

data/lib/resizing/carrier_wave/storage/remote.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Resizing
+  module CarrierWave
+    module Storage
+      # ref.
+      # https://github.com/carrierwaveuploader/carrierwave/blob/master/lib/carrierwave/storage/abstract.rb
+      class Remote < ::CarrierWave::Storage::Abstract
+        def store!(file)
+          f = Resizing::CarrierWave::Storage::File.new(uploader)
+          f.store(file)
+          @filename = f.public_id
+          f
+        end
+
+        def retrieve!(identifier)
+          Resizing::CarrierWave::Storage::File.new(uploader, identifier)
+        end
+
+        def cache!(new_file)
+          f = Resizing::CarrierWave::Storage::File.new(uploader)
+          f.store(new_file)
+          f
+        end
+
+        def retrieve_from_cache!(identifier)
+          # NOP
+          # Resizing::CarrierWave::Storage::File..new(uploader, uploader.cache_path(identifier))
+        end
+
+        def delete_dir!(path)
+          # do nothing, because there's no such things as 'empty directory'
+        end
+
+        def clean_cache!(seconds)
+          # do nothing
+          #
+          # connection.directories.new(
+          #   :key    => uploader.fog_directory,
+          #   :public => uploader.fog_public
+          # ).files.all(:prefix => uploader.cache_dir).each do |file|
+          #   # generate_cache_id returns key formated TIMEINT-PID(-COUNTER)-RND
+          #   time = file.key.scan(/(\d+)-\d+-\d+(?:-\d+)?/).first.map { |t| t.to_i }
+          #   time = Time.at(*time)
+          #   file.destroy if time < (Time.now.utc - seconds)
+          # end
+        end
+      end
+    end
+  end
+end

data/lib/resizing/client.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Resizing
+  #= Client class for Resizing
+  #--
+  # usage.
+  #   options = {
+  #     host: 'https://www.resizing.net',
+  #     project_id: '098a2a0d-0000-0000-0000-000000000000',
+  #     secret_token: '4g1cshg......rbs6'
+  #   }
+  #   client = Resizing::Client.new(options)
+  #   file = File.open('sample.jpg', 'r')
+  #   response = client.post(file)
+  #   {
+  #     "id"=>"fde443bb-0b29-4be2-a04e-2da8f19716ac",
+  #     "project_id"=>"098a2a0d-0000-0000-0000-000000000000",
+  #     "content_type"=>"image/jpeg",
+  #     "latest_version_id"=>"Ot0NL4rptk6XxQNFP2kVojn5yKG44cYH",
+  #     "latest_etag"=>"\"069ec178a367089c3f0306dd716facf2\"",
+  #     "created_at"=>"2020-05-17T15:02:30.548Z",
+  #     "updated_at"=>"2020-05-17T15:02:30.548Z"
+  #   }
+  #
+  #++
+  class Client
+    # TODO
+    # to use standard constants
+    HTTP_STATUS_OK = 200
+    HTTP_STATUS_CREATED = 201
+
+    attr_reader :config
+    def initialize(*attrs)
+      @config = if attrs.first.is_a? Configuration
+                  attrs.first
+                elsif attrs.first.nil?
+                  Resizing.configure
+                else
+                  Configuration.new(*attrs)
+                end
+    end
+
+    def get(name)
+      raise NotImplementedError
+    end
+
+    def post(file_or_binary, options = {})
+      ensure_content_type(options)
+
+      url = build_post_url
+
+      body = to_io(file_or_binary)
+      params = {
+        image: Faraday::UploadIO.new(body, options[:content_type])
+      }
+
+      response = http_client.post(url, params) do |request|
+        request.headers['X-ResizingToken'] = config.generate_auth_header
+      end
+
+      result = handle_response(response)
+      result
+    end
+
+    def put(name, file_or_binary, options)
+      ensure_content_type(options)
+
+      url = build_put_url(name)
+
+      body = to_io(file_or_binary)
+      params = {
+        image: Faraday::UploadIO.new(body, options[:content_type])
+      }
+
+      response = http_client.put(url, params) do |request|
+        request.headers['X-ResizingToken'] = config.generate_auth_header
+      end
+
+      result = handle_response(response)
+      result
+    end
+
+    def delete(name)
+      url = build_delete_url(name)
+
+      response = http_client.delete(url) do |request|
+        request.headers['X-ResizingToken'] = config.generate_auth_header
+      end
+
+      result = handle_response(response)
+      result
+    end
+
+    private
+
+    def build_get_url(name)
+      "#{config.host}/projects/#{config.project_id}/upload/images/#{name}"
+    end
+
+    def build_post_url
+      "#{config.host}/projects/#{config.project_id}/upload/images/"
+    end
+
+    def build_put_url(name)
+      "#{config.host}/projects/#{config.project_id}/upload/images/#{name}"
+    end
+
+    def build_delete_url(name)
+      "#{config.host}/projects/#{config.project_id}/upload/images/#{name}"
+    end
+
+    def http_client
+      @http_client ||= Faraday.new(url: config.host) do |builder|
+        builder.options[:open_timeout] = config.open_timeout
+        builder.options[:timeout] = config.response_timeout
+        builder.request :multipart
+        builder.request :url_encoded
+        builder.adapter Faraday.default_adapter
+      end
+    end
+
+    def to_io(data)
+      case data
+      when IO
+        data
+      when String
+        StringIO.new(data)
+      else
+        raise ArgumentError, 'file_or_binary is required IO class or String'
+      end
+    end
+
+    def ensure_content_type(options)
+      raise ArgumentError, "need options[:content_type] for #{options.inspect}" unless options[:content_type]
+    end
+
+    def handle_response(response)
+      raise APIError, "no response is returned" if response.nil?
+
+      case response.status
+      when HTTP_STATUS_OK, HTTP_STATUS_CREATED
+        JSON.parse(response.body)
+      else
+        raise APIError, "invalid http status code #{resp.status}"
+      end
+    end
+  end
+end

data/lib/resizing/configuration.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'digest/sha2'
+require 'securerandom'
+module Resizing
+  #= Configuration class for Resizing client
+  #--
+  # usage.
+  #   options = {
+  #     host: 'https://www.resizing.net',
+  #     project_id: '098a2a0d-0000-0000-0000-000000000000',
+  #     secret_token: '4g1cshg......rbs6'
+  #   }
+  #   configuration = Resizing::Configuration.new(options)
+  #   Resizing::Client.new(configuration)
+  #++
+  class Configuration
+    attr_reader :host, :project_id, :secret_token, :open_timeout, :response_timeout, :enable_mock
+    DEFAULT_HOST = 'https://www.resizing.net'
+    DEFAULT_OPEN_TIMEOUT = 2
+    DEFAULT_RESPONSE_TIMEOUT = 10
+
+    TRANSFORM_OPTIONS = %i[w width h height f format c crop q quality].freeze
+
+    def initialize(*attrs)
+      case attr = attrs.first
+      when Hash
+        raise_configiration_error if attr[:project_id].nil? || attr[:secret_token].nil?
+
+        initialize_by_hash attr
+        return
+      end
+
+      raise_configiration_error
+    end
+
+    def generate_auth_header
+      current_timestamp = Time.now.to_i
+      data = [current_timestamp, secret_token].join('|')
+      token = Digest::SHA2.hexdigest(data)
+      version = 'v1'
+      [version, current_timestamp, token].join(',')
+    end
+
+    def generate_image_url(image_id, version_id = nil, transforms = [])
+      path = transformation_path(transforms)
+      version = if version_id.nil?
+                  nil
+                else
+                  "v#{version_id}"
+                end
+
+      parts = []
+      parts << image_id
+      parts << version if version
+      parts << path unless path.empty?
+      "#{host}/projects/#{project_id}/upload/images/#{parts.join('/')}"
+    end
+
+    # this method should be divided other class
+    def transformation_path(transformations)
+      transformations = [transformations] if transformations.is_a? Hash
+
+      transformations.map do |transform|
+        transform.slice(*TRANSFORM_OPTIONS).map { |key, value| [key, value].join('_') }.join(',')
+      end.join('/')
+    end
+
+    # たぶんここにおくものではない
+    # もしくはキャッシュしない
+    def generate_identifier
+      @image_id ||= ::SecureRandom.uuid
+
+      "/projects/#{project_id}/upload/images/#{@image_id}"
+    end
+
+    def ==(other)
+      return false unless self.class == other.class
+
+      %i[host project_id secret_token open_timeout response_timeout].all? do |name|
+        send(name) == other.send(name)
+      end
+    end
+
+    private
+
+    def raise_configiration_error
+      raise ConfigurationError, 'need hash and some keys like :host, :project_id, :secret_token'
+    end
+
+    def initialize_by_hash(attr)
+      @host = attr[:host].dup.freeze || DEFAULT_HOST
+      @project_id = attr[:project_id].dup.freeze
+      @secret_token = attr[:secret_token].dup.freeze
+      @open_timeout = attr[:open_timeout] || DEFAULT_OPEN_TIMEOUT
+      @response_timeout = attr[:response_timeout] || DEFAULT_RESPONSE_TIMEOUT
+      @enable_mock = attr[:enable_mock] || false
+    end
+  end
+end