resizing 1.2.1 → 1.3.1

data/Rakefile

@@ -2,7 +2,7 @@
 
 require 'bundler/gem_tasks'
 require 'rake/testtask'
-require 'github_changelog_generator/task'
+require 'rubocop/rake_task'
 
 Rake::TestTask.new(:test) do |t|
   t.libs << 'test'
@@ -10,11 +10,9 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-GitHubChangelogGenerator::RakeTask.new :changelog do |config|
-  config.user = 'jksy'
-  config.project = 'resizing-gem'
-  config.since_tag = 'v0.1.0'
-  config.future_release = Resizing::VERSION
-end
+RuboCop::RakeTask.new
+
+desc 'Run the same checks as CI (RuboCop and the tests)'
+task ci: %i[rubocop test]
 
 task default: :test

data/bin/setup

@@ -5,4 +5,7 @@ set -vx
 
 bundle install
 
+# Run the CI checks before every push (see git-hooks/pre-push)
+git config core.hooksPath git-hooks
+
 # Do any other automated setup that you need to do here

data/git-hooks/pre-push

@@ -0,0 +1,6 @@
+#!/bin/sh
+# Entry point for the pre-push hook. Enabled by bin/setup, which points
+# core.hooksPath at this directory.
+HOOKS_DIR="$(git rev-parse --show-toplevel)/git-hooks"
+
+"$HOOKS_DIR/pre-push-ruby.sh" || exit 1

data/git-hooks/pre-push-ruby.sh

@@ -0,0 +1,48 @@
+#!/bin/sh
+# pre-push-ruby.sh
+# Runs the same checks as CI (RuboCop and the test suite) before pushing.
+# Called from git-hooks/pre-push. Aborts the push if any check fails.
+#
+# The checks run wherever the gems are installed: the current shell when it
+# already has them (inside the devcontainer, or a host with `bundle install`
+# done), otherwise the devcontainer via its CLI or docker compose.
+#
+#   PRE_PUSH_SKIP_TESTS=1 git push   # lint only, skip the test suite
+#   git push --no-verify             # skip every check (not recommended)
+ROOT="$(git rev-parse --show-toplevel)"
+cd "$ROOT" || exit 1
+
+if bundle check >/dev/null 2>&1; then
+  MODE=local
+elif command -v devcontainer >/dev/null 2>&1; then
+  MODE=devcontainer
+elif docker compose -f .devcontainer/compose.yaml ps --status running --quiet app 2>/dev/null | grep -q .; then
+  MODE=compose
+else
+  echo "No environment with the gems installed was found."
+  echo "Run 'devcontainer up --workspace-folder .' (or 'bundle install') first."
+  echo "To skip this check (not recommended): git push --no-verify"
+  exit 1
+fi
+
+run() {
+  case "$MODE" in
+    local)        bundle exec "$@" ;;
+    devcontainer) devcontainer exec --workspace-folder "$ROOT" bundle exec "$@" ;;
+    compose)      docker compose -f .devcontainer/compose.yaml exec -T app bundle exec "$@" ;;
+  esac
+}
+
+if [ -n "${PRE_PUSH_SKIP_TESTS:-}" ]; then
+  echo "Running RuboCop ($MODE)..."
+  run rake rubocop
+else
+  echo "Running RuboCop and tests ($MODE)..."
+  run rake ci
+fi
+
+if [ $? -ne 0 ]; then
+  echo "Pre-push checks failed. Push aborted."
+  echo "To skip this check (not recommended): git push --no-verify"
+  exit 1
+fi

data/lib/resizing/carrier_wave/callback_file.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Resizing
+  module CarrierWave
+    # The file handed to CarrierWave's :cache callbacks (extension_allowlist /
+    # extension_denylist / content_type_allowlist / content_type_denylist / size_range).
+    #
+    # The extension used by the callbacks is derived from the content type whenever the
+    # content type is known, instead of being taken from the file name as plain
+    # CarrierWave does.
+    #
+    # A file downloaded from a Resizing URL (e.g. when it is assigned through
+    # `remote_<column>_url=`) is the typical case: the last segment of the URL is the
+    # version string (`.../images/<image_id>/v<version>`), which contains dots, so the
+    # "extension" CarrierWave finds in the file name is a meaningless part of the version
+    # (`Fv_Q` for `/v0cRq7Yb2mZt9LxA3wN8eKd5pHs1.Fv_Q`), and extension_allowlist would
+    # reject every such file. The HTTP response carries the real content type, so it is
+    # the reliable source.
+    #
+    # When the content type is unknown (`application/octet-stream`, or a type that no
+    # extension is registered for), the file name is used as is, as in plain CarrierWave.
+    class CallbackFile < ::CarrierWave::SanitizedFile
+      # Content type given to files whose real type could not be determined.
+      # Carries no information about the extension, so it is treated as unknown.
+      UNKNOWN_CONTENT_TYPE = 'application/octet-stream'
+
+      def original_filename
+        name = super
+        return name if name.nil?
+
+        extension = extension_for_content_type
+        return name if extension.nil?
+
+        basename, current_extension = split_extension(name)
+        return name if extensions_for_content_type.include?(current_extension.downcase)
+
+        "#{basename}.#{extension}"
+      end
+
+      private
+
+      # The preferred extension of the content type, or nil when the content type is unknown.
+      def extension_for_content_type
+        extensions_for_content_type.first
+      end
+
+      # Every extension registered for the content type (lower case), or [] when unknown.
+      # Neither library raises on an unregistered or malformed content type: MIME::Types
+      # returns an empty list and MiniMime returns nil.
+      #
+      # MIME::Types (a dependency of CarrierWave 1.x and of fog) is preferred because it
+      # knows every alias of an extension (jpeg / jpg / jpe for image/jpeg); MiniMime
+      # (a dependency of CarrierWave 2.x+) knows only one extension per content type.
+      def extensions_for_content_type
+        @extensions_for_content_type ||= begin
+          # Drop the parameters (`image/jpeg; charset=binary`), which MiniMime cannot handle
+          type = content_type.to_s.split(';').first.to_s.strip.downcase
+          if type.empty? || type == UNKNOWN_CONTENT_TYPE
+            []
+          else
+            lookup_extensions(type)
+          end
+        end
+      end
+
+      def lookup_extensions(type)
+        if mime_types_available?
+          ::MIME::Types[type].flat_map(&:extensions).map(&:downcase).uniq
+        elsif mini_mime_available?
+          extension = ::MiniMime.lookup_by_content_type(type)&.extension
+          extension.nil? ? [] : [extension.downcase]
+        else
+          []
+        end
+      end
+
+      # Which lookup library is loaded depends on the application (CarrierWave 1.x loads
+      # MIME::Types, 2.x+ loads MiniMime); the tests stub these to exercise each path.
+      def mime_types_available?
+        !defined?(::MIME::Types).nil?
+      end
+
+      def mini_mime_available?
+        !defined?(::MiniMime).nil?
+      end
+    end
+  end
+end

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

@@ -7,29 +7,40 @@ module Resizing
       class File
         include ::CarrierWave::Utilities::Uri
 
+        # Fallback content type used when the type cannot be determined from the file name.
+        DEFAULT_CONTENT_TYPE = 'application/octet-stream'
+
         attr_reader :public_id
 
         def initialize(uploader, identifier = nil)
           @uploader = uploader
           @content_type = nil
           @public_id = Resizing::PublicId.new(identifier)
-          @file = nil
           @metadata = nil
+          @metadata_fetched = false
         end
 
+        # Metadata of the stored image, as returned by the Resizing metadata API.
+        #
+        # === Returns
+        #
+        # [Hash, nil] metadata hash, or nil when the image is unknown/unreachable
         def attributes
-          file.attributes
+          metadata
         end
 
         def authenticated_url(_options = {})
           nil
         end
 
+        # NOTE: Called through CarrierWave's Uploader::Proxy#content_type, so it must not
+        # raise. Falls back to the metadata API when the content type is not known locally
+        # (e.g. the model was reloaded from the DB), and returns nil if it cannot be fetched.
         def content_type
-          @content_type || file.try(:content_type)
+          @content_type ||= metadata && metadata['content_type']
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize
         def delete
           # Use the identifier from constructor if available, otherwise try to get from model
           if @public_id.present?
@@ -44,23 +55,27 @@ module Resizing
             @public_id = Resizing::PublicId.new(column_value)
           end
 
-          return if @public_id.empty? # do nothing
+          return if @public_id.empty?
 
-          # 以下、既存のコード（変更なし）
           resp = client.delete(@public_id.image_id)
+
+          # NOTE: 削除時のカラムクリアは以下の理由で必要:
+          # - 画像更新時: 古い画像IDと新しい画像IDが異なるため、古い画像削除時に新しいIDを消さないようにする
+          # - 明示的なremove!時: カラムをnilにする必要がある
+          # - clear_column_if_current_imageは削除される画像IDと現在のカラム値を比較して判断
           if resp['error'] == 'ActiveRecord::RecordNotFound' # 404 not found
-            model.send :write_attribute, serialization_column, nil unless model.destroyed?
+            clear_column_if_current_image
             return
           end
 
           if @public_id.image_id == resp['id']
-            model.send :write_attribute, serialization_column, nil unless model.destroyed?
+            clear_column_if_current_image
             return
           end
 
           raise APIError, "raise someone error:#{resp.inspect}"
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize
 
         def extension
           raise NotImplementedError, 'this method is do not used. maybe'
@@ -69,32 +84,32 @@ module Resizing
         ##
         # Read content of file from service
         #
-        # === Returns
-        #
-        # [String] contents of file
+        # NOTE: Resizing keeps no local copy of the stored image and this gem has no API to
+        # download the binary (Resizing::Client#get is not implemented either), so reading the
+        # content would require a new download API. It is not called by the regular CarrierWave
+        # flow (only through Uploader::Proxy#read, i.e. explicitly by the application), so it
+        # raises instead of silently returning nil.
         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
+          raise NotImplementedError, 'Resizing does not support reading the stored image content'
         end
 
+        # NOTE: Called through CarrierWave's Uploader::Proxy#size, so it must not raise.
+        # The size is only known to the Resizing service, so it comes from the metadata API.
+        # Returns 0 when it cannot be fetched, following Uploader::Proxy#size, which itself
+        # falls back to 0, so that the return value is always an Integer.
         def size
-          file.nil? ? 0 : file.content_length
+          (metadata && metadata['size']) || 0
         end
 
         def exists?
-          !!file
+          !metadata.nil?
         end
 
         def current_path
+          # Return the path from @public_id if set (for retrieve scenarios),
+          # otherwise fall back to reading from model
+          return @public_id.to_s if @public_id.present?
+
           @current_path = model.send :read_attribute, serialization_column
         end
         alias path current_path
@@ -110,8 +125,10 @@ module Resizing
           @content_type ||= if new_file.respond_to? :content_type
                               new_file.content_type
                             else
-                              # guess content-type from extension
-                              MIME::Types.type_for(new_file.path).first.content_type
+                              # Guess content-type from extension. MIME::Types returns an empty
+                              # list for extensions it does not know (e.g. `.url`), so fall back
+                              # to the generic binary type instead of raising NoMethodError.
+                              guess_content_type(new_file.path)
                             end
 
           original_filename = new_file.try(:original_filename) || new_file.try(:filename) || new_file.try(:path)
@@ -131,11 +148,14 @@ module Resizing
           @public_id = Resizing::PublicId.new(@response['public_id'])
           @content_type = @response['content_type']
 
-          # force update column
-          # model_class
-          #   .where(primary_key_name => model.send(primary_key_name))
-          #   .update_all(serialization_column=>@public_id)
-
+          # NOTE: 理想的にはStorage::File内でモデルのカラムをいじらず、CarrierWaveに任せるべきだが、
+          # 現在の実装では以下の理由で必要:
+          # - CarrierWaveは write_uploader(column, mounter.identifiers.first) でカラムを更新
+          # - mounter.identifiers -> uploaders.map(&:identifier) -> storage.identifier -> uploader.filename
+          # - resizing-gemの filenameメソッドは read_column を返す（既存のカラム値）
+          # - そのため、CarrierWaveに任せると旧い値が書き戻されてしまう
+          # TODO: これを修正するには、Remote#identifierをオーバーライドして@public_id.to_sを返すか、
+          #       uploader.filenameの実装を変更する必要がある
           # save new value to model class
           model.send :write_attribute, serialization_column, @public_id.to_s
 
@@ -153,8 +173,12 @@ module Resizing
         #   CarrierWave::Storage::Fog::File.new(@uploader, @base, new_path)
         # end
 
+        # NOTE: Resizing::CarrierWave#file calls this on every access, so the cached metadata
+        # is only dropped when the identifier actually changes.
         def retrieve(identifier)
-          @public_id = Resizing::PublicId.new(identifier)
+          new_public_id = Resizing::PublicId.new(identifier)
+          reset_metadata unless new_public_id.to_s == @public_id.to_s
+          @public_id = new_public_id
         end
 
         private
@@ -177,6 +201,20 @@ module Resizing
           @serialization_column ||= model.send(:_mounter, uploader.mounted_as).send(:serialization_column)
         end
 
+        # Only clear the column if the deleted image is the current one
+        # (not when deleting an old image during update)
+        def clear_column_if_current_image
+          return if model.destroyed?
+
+          current_value = model.send(:read_attribute, serialization_column)
+          current_public_id = Resizing::PublicId.new(current_value)
+
+          # Only clear if the deleted image is the same as the current one
+          return unless current_public_id.image_id == @public_id.image_id
+
+          model.send :write_attribute, serialization_column, nil
+        end
+
         ##
         # client of Resizing
         def client
@@ -188,25 +226,60 @@ module Resizing
         end
 
         ##
-        # lookup file
+        # Metadata of the stored image, fetched lazily from the Resizing metadata API
+        # and memoized (including a failed lookup, so it is fetched at most once).
         #
-        # === Returns
+        # This replaces the Fog-derived `file` method (`directory.files.head(path)`) that this
+        # class used to rely on: Resizing has no equivalent of a remote file handle, and the
+        # metadata endpoint is the only source of size / content_type / filename.
         #
-        # [Fog::#{provider}::File] file data from remote service
+        # === Returns
         #
-        # def file
-        #   @file ||= directory.files.head(path)
-        # end
+        # [Hash, nil] metadata hash, or nil when there is no image or it cannot be fetched
+        def metadata
+          return @metadata if @metadata_fetched
 
-        def read_source_file(file_body)
-          return unless ::File.exist?(file_body.path)
+          @metadata_fetched = true
+          @metadata = fetch_metadata
+        end
 
-          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
+        def reset_metadata
+          @metadata = nil
+          @metadata_fetched = false
+        end
+
+        # NOTE: Never raises. These values are read on ordinary code paths (CarrierWave's
+        # Uploader::Proxy delegates size / content_type to this object), so a transient API
+        # failure must not break the caller; the absence of metadata is reported as nil.
+        def fetch_metadata
+          image_id = metadata_image_id
+          return nil if image_id.nil? || image_id.empty?
+
+          result = Resizing.metadata(image_id, {})
+          return nil if !result.is_a?(Hash) || result['error']
+
+          result
+        rescue StandardError
+          nil
+        end
+
+        # The image to look up: the identifier this instance was built with/retrieved,
+        # falling back to the value currently stored in the model column.
+        def metadata_image_id
+          return @public_id.image_id if @public_id.present?
+
+          Resizing::PublicId.new(model.send(:read_attribute, serialization_column)).image_id
+        rescue StandardError
+          nil
+        end
+
+        # Guess the content type from a file name/path.
+        # Returns DEFAULT_CONTENT_TYPE when the extension is unknown to MIME::Types,
+        # which is the same convention CarrierWave/Rack use for unidentifiable files.
+        def guess_content_type(path)
+          return DEFAULT_CONTENT_TYPE if path.nil?
+
+          MIME::Types.type_for(path.to_s).first&.content_type || DEFAULT_CONTENT_TYPE
         end
 
         def url_options_supported?(local_file)

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

@@ -12,9 +12,13 @@ module Resizing
           f
         end
 
-        def remove!(file)
-          f = Resizing::CarrierWave::Storage::File.new(uploader)
-          f.delete(file)
+        # NOTE: CarrierWave 2.2.x never reaches here (Uploader::Remove#remove! calls
+        # @file.delete directly), but newer versions may remove through the storage.
+        # File#delete takes no argument and resolves the image to delete by itself, so
+        # reuse the given file when it is already ours instead of building a new one.
+        def remove!(file = nil)
+          f = file.is_a?(Resizing::CarrierWave::Storage::File) ? file : Resizing::CarrierWave::Storage::File.new(uploader)
+          f.delete
           f
         end
 

data/lib/resizing/carrier_wave.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'resizing/carrier_wave/callback_file'
 require 'resizing/carrier_wave/storage/file'
 require 'resizing/carrier_wave/storage/remote'
 
@@ -29,11 +30,20 @@ module Resizing
     def initialize(*args)
       @requested_format = nil
       @default_format = nil
+      @retrieved_identifier = nil
       super
     end
 
+    # Override to store the identifier and set up @file for later use
+    def retrieve_from_store!(identifier)
+      @retrieved_identifier = identifier
+      super
+      # Ensure @file is set up so that remove! can call @file.delete
+      file
+    end
+
     def file
-      file_identifier = identifier || read_column
+      file_identifier = @retrieved_identifier || identifier || read_column
 
       return nil if file_identifier.blank?
 
@@ -95,16 +105,50 @@ module Resizing
       @transform.push(:resize_to_fit, *args)
     end
 
+    # Resizing has no cache storage, so the file is uploaded to Resizing directly here
+    # instead of being copied to a local workfile and handed to cache_storage.
+    #
+    # The :cache callbacks are still run, so that the uploader settings hooked on them
+    # (extension_allowlist / extension_denylist / content_type_allowlist /
+    # content_type_denylist / size_range) are honoured before the upload happens.
+    # The callbacks that do not fit the Resizing flow (process! and cache_versions!)
+    # are disabled below.
     def cache!(new_file)
       return if new_file.nil?
 
-      file = storage.store!(new_file)
-      # do not assign @cache_id, bacause resizing do not support cache
-      # save to resizing directly
-      # @cache_id = file.public_id
+      # CallbackFile responds to #extension / #content_type / #size, which the
+      # before :cache callbacks need, with the extension derived from the content type
+      # (see CallbackFile). The original object is handed to the storage, because it
+      # carries the original filename sent to Resizing.
+      sanitized = CallbackFile.new(new_file)
+      return if sanitized.empty?
+
+      with_callbacks(:cache, sanitized) do
+        file = storage.store!(new_file)
+        # do not assign @cache_id, bacause resizing do not support cache
+        # save to resizing directly
+        # @cache_id = file.public_id
+
+        @filename = file.public_id.to_s
+        @file = file
+      end
+    end
 
-      @filename = file.public_id.to_s
-      @file = file
+    # process! is called before :cache
+    # Disable on Resizing, because `process` is repurposed as a definition of the
+    # transformation applied when the browser fetches the image URL (see #transform_string),
+    # so the processors must not be run as actual image processing on upload.
+    # https://github.com/carrierwaveuploader/carrierwave/blob/28190e99299a6131c0424a5d10205f471e39f3cd/lib/carrierwave/uploader/processing.rb#L12
+    def process!(*args)
+      # NOP
+    end
+
+    # cache_versions! is called after :cache
+    # Disable on Resizing, because each version would upload the same image again and
+    # the resulting public_id would be stored nowhere, leaving orphan images behind.
+    # https://github.com/carrierwaveuploader/carrierwave/blob/28190e99299a6131c0424a5d10205f471e39f3cd/lib/carrierwave/uploader/versions.rb#L17
+    def cache_versions!(*args)
+      # NOP
     end
 
     def filename

data/lib/resizing/client.rb

@@ -6,7 +6,6 @@ module Resizing
   # usage.
   #   options = {
   #     image_host: 'https://img.resizing.net',
-  #     video_host: 'https://video.resizing.net',
   #     project_id: '098a2a0d-0000-0000-0000-000000000000',
   #     secret_token: '4g1cshg......rbs6'
   #   }

data/lib/resizing/configurable.rb

@@ -6,7 +6,7 @@ module Resizing
       mod.send(:attr_reader, :config)
     end
 
-    def initialize_config *attrs
+    def initialize_config(*attrs)
       config = if attrs.first.is_a? Configuration
                  attrs.first
                elsif attrs.first.nil?

data/lib/resizing/configuration.rb

@@ -15,10 +15,17 @@ module Resizing
   #   Resizing::Client.new(configuration)
   #++
   class Configuration
-    attr_reader :image_host, :video_host, :project_id, :secret_token, :open_timeout, :response_timeout, :enable_mock
+    attr_reader :image_host, :project_id, :secret_token, :open_timeout, :response_timeout, :enable_mock
     DEFAULT_HOST = 'https://img.resizing.net'
     DEFAULT_IMAGE_HOST = 'https://img.resizing.net'
-    DEFAULT_VIDEO_HOST = 'https://video.resizing.net'
+    VIDEO_HOST_FALLBACK = 'https://video.resizing.net'
+    private_constant :VIDEO_HOST_FALLBACK
+    # 動画 API はサービス側で廃止されたため非推奨。将来のバージョンで削除する
+    DEFAULT_VIDEO_HOST = VIDEO_HOST_FALLBACK
+    deprecate_constant :DEFAULT_VIDEO_HOST
+    DEPRECATED_VIDEO_HOST_MESSAGE = '[resizing] video_host is deprecated: ' \
+                                    'the video API has been removed from Resizing and this value is no longer used. ' \
+                                    'It will be deleted in a future version.'
     DEFAULT_OPEN_TIMEOUT = 2
     DEFAULT_RESPONSE_TIMEOUT = 10
 
@@ -28,7 +35,7 @@ module Resizing
       case attr = attrs.first
       when Hash
         raise_configiration_error if attr[:project_id].nil? || attr[:secret_token].nil?
-        raise_configiration_error if attr[:host].present?
+        raise_deprecated_host_error unless blank_value?(attr[:host])
 
         initialize_by_hash attr
         return
@@ -79,32 +86,55 @@ module Resizing
       ::SecureRandom.uuid
     end
 
+    # 動画 API の廃止により非推奨。値は保持するが利用されない
+    def video_host
+      warn_video_host_deprecation
+      @video_host
+    end
+
     def ==(other)
       return false unless self.class == other.class
 
-      %i[image_host video_host project_id secret_token open_timeout response_timeout].all? do |name|
+      return false unless @video_host == other.instance_variable_get(:@video_host)
+
+      %i[image_host project_id secret_token open_timeout response_timeout].all? do |name|
         send(name) == other.send(name)
       end
     end
 
     private
 
+    # ActiveSupport の Object#present? / #blank? に依存しないための素の Ruby 実装。
+    # このgemはRails外からも利用されるため、activesupportがロードされていない前提で動作する必要がある。
+    def blank_value?(value)
+      value.nil? || value.to_s.strip.empty?
+    end
+
+    def raise_deprecated_host_error
+      raise ConfigurationError, 'The host on configuration is deprecated. Use image_host'
+    end
+
+    def deprecated_video_host(value)
+      warn_video_host_deprecation unless value.nil?
+      value.dup.freeze || VIDEO_HOST_FALLBACK
+    end
+
+    def warn_video_host_deprecation
+      warn DEPRECATED_VIDEO_HOST_MESSAGE
+    end
+
     def raise_configiration_error
-      raise ConfigurationError, 'need hash and some keys like :image_host, video_host, :project_id, :secret_token'
+      raise ConfigurationError, 'need hash and some keys like :image_host, :project_id, :secret_token'
     end
 
-    # rubocop:disable Metrics/AbcSize
     def initialize_by_hash(attr)
-      raise 'The host on configuration is deprecated. Use image_host, video_host' if attr[:host].present?
-
       @image_host = attr[:image_host].dup.freeze || DEFAULT_IMAGE_HOST
-      @video_host = attr[:video_host].dup.freeze || DEFAULT_VIDEO_HOST
+      @video_host = deprecated_video_host(attr[:video_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
-    # rubocop:enable Metrics/AbcSize
   end
 end