activestorage 7.0.8.1 → 7.1.0.beta1

data/app/models/active_storage/variation.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-require "mini_mime"
+require "marcel"
 
+# = Active Storage \Variation
+#
 # A set of transformations that can be applied to a blob to create a variant. This class is exposed via
 # the ActiveStorage::Blob#variant method and should rarely be used directly.
 #
@@ -59,14 +61,14 @@ class ActiveStorage::Variation
 
   def format
     transformations.fetch(:format, :png).tap do |format|
-      if MiniMime.lookup_by_extension(format.to_s).nil?
+      if Marcel::Magic.by_extension(format.to_s).nil?
         raise ArgumentError, "Invalid variant format (#{format.inspect})"
       end
     end
   end
 
   def content_type
-    MiniMime.lookup_by_extension(format.to_s).content_type
+    Marcel::MimeType.for(extension: format.to_s)
   end
 
   # Returns a signed key for all the +transformations+ that this variation was instantiated with.

data/db/migrate/20170806125915_create_active_storage_tables.rb

@@ -1,4 +1,4 @@
-class CreateActiveStorageTables < ActiveRecord::Migration[5.2]
+class CreateActiveStorageTables < ActiveRecord::Migration[7.0]
   def change
     # Use Active Record's configured type for primary and foreign keys
     primary_key_type, foreign_key_type = primary_and_foreign_key_types

data/lib/active_storage/analyzer/audio_analyzer.rb

@@ -1,21 +1,23 @@
 # frozen_string_literal: true
 
 module ActiveStorage
-  # Extracts duration (seconds) and bit_rate (bits/s) from an audio blob.
+  # = Active Storage Audio \Analyzer
+  #
+  # Extracts duration (seconds), bit_rate (bits/s), sample_rate (hertz) and tags (internal metadata) from an audio blob.
   #
   # Example:
   #
   #   ActiveStorage::Analyzer::AudioAnalyzer.new(blob).metadata
-  #   # => { duration: 5.0, bit_rate: 320340 }
+  #   # => { duration: 5.0, bit_rate: 320340, sample_rate: 44100, tags: { encoder: "Lavc57.64", ... } }
   #
-  # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by Rails.
+  # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by \Rails.
   class Analyzer::AudioAnalyzer < Analyzer
     def self.accept?(blob)
       blob.audio?
     end
 
     def metadata
-      { duration: duration, bit_rate: bit_rate }.compact
+      { duration: duration, bit_rate: bit_rate, sample_rate: sample_rate, tags: tags }.compact
     end
 
     private
@@ -29,6 +31,16 @@ module ActiveStorage
         Integer(bit_rate) if bit_rate
       end
 
+      def sample_rate
+        sample_rate = audio_stream["sample_rate"]
+        Integer(sample_rate) if sample_rate
+      end
+
+      def tags
+        tags = audio_stream["tags"]
+        Hash(tags) if tags
+      end
+
       def audio_stream
         @audio_stream ||= streams.detect { |stream| stream["codec_type"] == "audio" } || {}
       end

data/lib/active_storage/analyzer/image_analyzer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveStorage
+  # = Active Storage Image \Analyzer
+  #
   # This is an abstract base class for image analyzers, which extract width and height from an image blob.
   #
   # If the image contains EXIF data indicating its angle is 90 or 270 degrees, its width and height are swapped for convenience.

data/lib/active_storage/analyzer/video_analyzer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveStorage
+  # = Active Storage Video \Analyzer
+  #
   # Extracts the following from a video blob:
   #
   # * Width (pixels)
@@ -18,7 +20,7 @@ module ActiveStorage
   #
   # When a video's angle is 90, -90, 270 or -270 degrees, its width and height are automatically swapped for convenience.
   #
-  # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by Rails.
+  # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by \Rails.
   class Analyzer::VideoAnalyzer < Analyzer
     def self.accept?(blob)
       blob.video?

data/lib/active_storage/analyzer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveStorage
+  # = Active Storage \Analyzer
+  #
   # This is an abstract base class for analyzers, which extract metadata from blobs. See
   # ActiveStorage::Analyzer::VideoAnalyzer for an example of a concrete subclass.
   class Analyzer

data/lib/active_storage/attached/changes/create_many.rb

@@ -2,11 +2,12 @@
 
 module ActiveStorage
   class Attached::Changes::CreateMany # :nodoc:
-    attr_reader :name, :record, :attachables
+    attr_reader :name, :record, :attachables, :pending_uploads
 
-    def initialize(name, record, attachables)
+    def initialize(name, record, attachables, pending_uploads: [])
       @name, @record, @attachables = name, record, Array(attachables)
       blobs.each(&:identify_without_saving)
+      @pending_uploads = Array(pending_uploads) + subchanges_without_blobs
       attachments
     end
 
@@ -19,7 +20,7 @@ module ActiveStorage
     end
 
     def upload
-      subchanges.each(&:upload)
+      pending_uploads.each(&:upload)
     end
 
     def save
@@ -36,6 +37,10 @@ module ActiveStorage
         ActiveStorage::Attached::Changes::CreateOneOfMany.new(name, record, attachable)
       end
 
+      def subchanges_without_blobs
+        subchanges.reject { |subchange| subchange.attachable.is_a?(ActiveStorage::Blob) }
+      end
+
       def assign_associated_attachments
         record.public_send("#{name}_attachments=", persisted_or_new_attachments)
       end

data/lib/active_storage/attached/changes/create_one.rb

@@ -22,8 +22,12 @@ module ActiveStorage
 
     def upload
       case attachable
-      when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
+      when ActionDispatch::Http::UploadedFile
         blob.upload_without_unfurling(attachable.open)
+      when Rack::Test::UploadedFile
+        blob.upload_without_unfurling(
+          attachable.respond_to?(:open) ? attachable.open : attachable
+        )
       when Hash
         blob.upload_without_unfurling(attachable.fetch(:io))
       end
@@ -53,7 +57,7 @@ module ActiveStorage
         case attachable
         when ActiveStorage::Blob
           attachable
-        when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
+        when ActionDispatch::Http::UploadedFile
           ActiveStorage::Blob.build_after_unfurling(
             io: attachable.open,
             filename: attachable.original_filename,
@@ -61,6 +65,14 @@ module ActiveStorage
             record: record,
             service_name: attachment_service_name
           )
+        when Rack::Test::UploadedFile
+          ActiveStorage::Blob.build_after_unfurling(
+            io: attachable.respond_to?(:open) ? attachable.open : attachable,
+            filename: attachable.original_filename,
+            content_type: attachable.content_type,
+            record: record,
+            service_name: attachment_service_name
+          )
         when Hash
           ActiveStorage::Blob.build_after_unfurling(
             **attachable.reverse_merge(

data/lib/active_storage/attached/many.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveStorage
+  # = Active Storage \Attached \Many
+  #
   # Decorated proxy object representing of multiple attachments to a model.
   class Attached::Many < Attached
     ##
@@ -47,12 +49,11 @@ module ActiveStorage
     #   document.images.attach(io: File.open("/path/to/racecar.jpg"), filename: "racecar.jpg", content_type: "image/jpeg")
     #   document.images.attach([ first_blob, second_blob ])
     def attach(*attachables)
+      record.public_send("#{name}=", blobs + attachables.flatten)
       if record.persisted? && !record.changed?
-        record.public_send("#{name}=", blobs + attachables.flatten)
-        record.save
-      else
-        record.public_send("#{name}=", (change&.attachables || blobs) + attachables.flatten)
+        return if !record.save
       end
+      record.public_send("#{name}")
     end
 
     # Returns true if any attachments have been made.

data/lib/active_storage/attached/model.rb

@@ -3,10 +3,54 @@
 require "active_support/core_ext/object/try"
 
 module ActiveStorage
+  # = Active Storage \Attached \Model
+  #
   # Provides the class-level DSL for declaring an Active Record model's attachments.
   module Attached::Model
     extend ActiveSupport::Concern
 
+    ##
+    # :method: *_attachment
+    #
+    # Returns the attachment for the +has_one_attached+.
+    #
+    #   User.last.avatar_attachment
+
+    ##
+    # :method: *_attachments
+    #
+    # Returns the attachments for the +has_many_attached+.
+    #
+    #   Gallery.last.photos_attachments
+
+    ##
+    # :method: *_blob
+    #
+    # Returns the blob for the +has_one_attached+ attachment.
+    #
+    #   User.last.avatar_blob
+
+    ##
+    # :method: *_blobs
+    #
+    # Returns the blobs for the +has_many_attached+ attachments.
+    #
+    #   Gallery.last.photos_blobs
+
+    ##
+    # :method: with_attached_*
+    #
+    # Includes the attached blobs in your query to avoid N+1 queries.
+    #
+    # If +ActiveStorage.track_variants+ is enabled, it will also include the
+    # variants record and their attached blobs.
+    #
+    #   User.with_attached_avatar
+    #
+    # Use the plural form for +has_many_attached+:
+    #
+    #   Gallery.with_attached_photos
+
     class_methods do
       # Specifies the relation between a single attachment and the model.
       #
@@ -59,7 +103,7 @@ module ActiveStorage
 
           def #{name}=(attachable)
             attachment_changes["#{name}"] =
-              if attachable.nil?
+              if attachable.nil? || attachable == ""
                 ActiveStorage::Attached::Changes::DeleteOne.new("#{name}", self)
               else
                 ActiveStorage::Attached::Changes::CreateOne.new("#{name}", self, attachable)
@@ -70,7 +114,13 @@ module ActiveStorage
         has_one :"#{name}_attachment", -> { where(name: name) }, class_name: "ActiveStorage::Attachment", as: :record, inverse_of: :record, dependent: :destroy, strict_loading: strict_loading
         has_one :"#{name}_blob", through: :"#{name}_attachment", class_name: "ActiveStorage::Blob", source: :blob, strict_loading: strict_loading
 
-        scope :"with_attached_#{name}", -> { includes("#{name}_attachment": :blob) }
+        scope :"with_attached_#{name}", -> {
+          if ActiveStorage.track_variants
+            includes("#{name}_attachment": { blob: { variant_records: { image_attachment: :blob } } })
+          else
+            includes("#{name}_attachment": :blob)
+          end
+        }
 
         after_save { attachment_changes[name.to_s]&.save }
 
@@ -138,57 +188,22 @@ module ActiveStorage
 
           def #{name}=(attachables)
             attachables = Array(attachables).compact_blank
+            pending_uploads = attachment_changes["#{name}"].try(:pending_uploads)
 
-            if ActiveStorage.replace_on_assign_to_many
-              attachment_changes["#{name}"] =
-                if attachables.none?
-                  ActiveStorage::Attached::Changes::DeleteMany.new("#{name}", self)
-                else
-                  ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, attachables)
-                end
+            attachment_changes["#{name}"] = if attachables.none?
+              ActiveStorage::Attached::Changes::DeleteMany.new("#{name}", self)
             else
-              ActiveSupport::Deprecation.warn \
-                "config.active_storage.replace_on_assign_to_many is deprecated and will be removed in Rails 7.1. " \
-                "Make sure that your code works well with config.active_storage.replace_on_assign_to_many set to true before upgrading. " \
-                "To append new attachables to the Active Storage association, prefer using `attach`. " \
-                "Using association setter would result in purging the existing attached attachments and replacing them with new ones."
-
-              if attachables.any?
-                attachment_changes["#{name}"] =
-                  ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, #{name}.blobs + attachables)
-              end
+              ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, attachables, pending_uploads: pending_uploads)
             end
           end
         CODE
 
-        has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "ActiveStorage::Attachment", inverse_of: :record, dependent: :destroy, strict_loading: strict_loading do
-          def purge
-            deprecate(:purge)
-            each(&:purge)
-            reset
-          end
-
-          def purge_later
-            deprecate(:purge_later)
-            each(&:purge_later)
-            reset
-          end
-
-          private
-          def deprecate(action)
-            reflection_name = proxy_association.reflection.name
-            attached_name = reflection_name.to_s.partition("_").first
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Calling `#{action}` from `#{reflection_name}` is deprecated and will be removed in Rails 7.1.
-              To migrate to Rails 7.1's behavior call `#{action}` from `#{attached_name}` instead: `#{attached_name}.#{action}`.
-            MSG
-          end
-        end
+        has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "ActiveStorage::Attachment", inverse_of: :record, dependent: :destroy, strict_loading: strict_loading
         has_many :"#{name}_blobs", through: :"#{name}_attachments", class_name: "ActiveStorage::Blob", source: :blob, strict_loading: strict_loading
 
         scope :"with_attached_#{name}", -> {
           if ActiveStorage.track_variants
-            includes("#{name}_attachments": { blob: :variant_records })
+            includes("#{name}_attachments": { blob: { variant_records: { image_attachment: :blob } } })
           else
             includes("#{name}_attachments": :blob)
           end
@@ -215,6 +230,14 @@ module ActiveStorage
             ActiveStorage::Blob.services.fetch(service) do
               raise ArgumentError, "Cannot configure service :#{service} for #{name}##{association_name}"
             end
+          else
+            validate_global_service_configuration
+          end
+        end
+
+        def validate_global_service_configuration
+          if connected? && ActiveStorage::Blob.table_exists? && Rails.configuration.active_storage.service.nil?
+            raise RuntimeError, "Missing Active Storage service name. Specify Active Storage service name for config.active_storage.service in config/environments/#{Rails.env}.rb"
           end
         end
     end

data/lib/active_storage/attached/one.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveStorage
+  # = Active Storage \Attached \One
+  #
   # Representation of a single attachment to a model.
   class Attached::One < Attached
     ##
@@ -54,12 +56,11 @@ module ActiveStorage
     #   person.avatar.attach(io: File.open("/path/to/face.jpg"), filename: "face.jpg", content_type: "image/jpeg")
     #   person.avatar.attach(avatar_blob) # ActiveStorage::Blob object
     def attach(attachable)
+      record.public_send("#{name}=", attachable)
       if record.persisted? && !record.changed?
-        record.public_send("#{name}=", attachable)
-        record.save
-      else
-        record.public_send("#{name}=", attachable)
+        return if !record.save
       end
+      record.public_send("#{name}")
     end
 
     # Returns +true+ if an attachment has been made.

data/lib/active_storage/attached.rb

@@ -3,6 +3,8 @@
 require "active_support/core_ext/module/delegation"
 
 module ActiveStorage
+  # = Active Storage \Attached
+  #
   # Abstract base class for the concrete ActiveStorage::Attached::One and ActiveStorage::Attached::Many
   # classes that both provide proxy access to the blob association for a record.
   class Attached

data/lib/active_storage/deprecator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end

data/lib/active_storage/engine.rb

@@ -35,9 +35,7 @@ module ActiveStorage
     config.active_storage.variable_content_types = %w(
       image/png
       image/gif
-      image/jpg
       image/jpeg
-      image/pjpeg
       image/tiff
       image/bmp
       image/vnd.adobe.photoshop
@@ -51,13 +49,11 @@ module ActiveStorage
     config.active_storage.web_image_content_types = %w(
       image/png
       image/jpeg
-      image/jpg
       image/gif
     )
 
     config.active_storage.content_types_to_serve_as_binary = %w(
       text/html
-      text/javascript
       image/svg+xml
       application/postscript
       application/x-shockwave-flash
@@ -71,7 +67,6 @@ module ActiveStorage
     config.active_storage.content_types_allowed_inline = %w(
       image/png
       image/gif
-      image/jpg
       image/jpeg
       image/tiff
       image/bmp
@@ -82,6 +77,10 @@ module ActiveStorage
 
     config.eager_load_namespaces << ActiveStorage
 
+    initializer "active_storage.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:active_storage] = ActiveStorage.deprecator
+    end
+
     initializer "active_storage.configs" do
       config.after_initialize do |app|
         ActiveStorage.logger            = app.config.active_storage.logger || Rails.logger
@@ -117,9 +116,14 @@ module ActiveStorage
         ActiveStorage.binary_content_type = app.config.active_storage.binary_content_type || "application/octet-stream"
         ActiveStorage.video_preview_arguments = app.config.active_storage.video_preview_arguments || "-y -vframes 1 -f image2"
 
-        ActiveStorage.silence_invalid_content_types_warning = app.config.active_storage.silence_invalid_content_types_warning || false
+        unless app.config.active_storage.silence_invalid_content_types_warning.nil?
+          ActiveStorage.silence_invalid_content_types_warning = app.config.active_storage.silence_invalid_content_types_warning
+        end
+
+        unless app.config.active_storage.replace_on_assign_to_many.nil?
+          ActiveStorage.replace_on_assign_to_many = app.config.active_storage.replace_on_assign_to_many
+        end
 
-        ActiveStorage.replace_on_assign_to_many = app.config.active_storage.replace_on_assign_to_many || false
         ActiveStorage.track_variants = app.config.active_storage.track_variants || false
       end
     end

data/lib/active_storage/fixture_set.rb

@@ -4,6 +4,8 @@ require "active_support/testing/file_fixtures"
 require "active_record/secure_token"
 
 module ActiveStorage
+  # = Active Storage \FixtureSet
+  #
   # Fixtures are a way of organizing data that you want to test against; in
   # short, sample data.
   #

data/lib/active_storage/gem_version.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 module ActiveStorage
-  # Returns the currently loaded version of Active Storage as a <tt>Gem::Version</tt>.
+  # Returns the currently loaded version of Active Storage as a +Gem::Version+.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
     MAJOR = 7
-    MINOR = 0
-    TINY  = 8
-    PRE   = "1"
+    MINOR = 1
+    TINY  = 0
+    PRE   = "beta1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_storage/log_subscriber.rb

@@ -9,34 +9,46 @@ module ActiveStorage
       message += " (checksum: #{event.payload[:checksum]})" if event.payload[:checksum]
       info event, color(message, GREEN)
     end
+    subscribe_log_level :service_upload, :info
 
     def service_download(event)
       info event, color("Downloaded file from key: #{key_in(event)}", BLUE)
     end
+    subscribe_log_level :service_download, :info
 
     alias_method :service_streaming_download, :service_download
 
+    def preview(event)
+      info event, color("Previewed file from key: #{key_in(event)}", BLUE)
+    end
+    subscribe_log_level :preview, :info
+
     def service_delete(event)
       info event, color("Deleted file from key: #{key_in(event)}", RED)
     end
+    subscribe_log_level :service_delete, :info
 
     def service_delete_prefixed(event)
       info event, color("Deleted files by key prefix: #{event.payload[:prefix]}", RED)
     end
+    subscribe_log_level :service_delete_prefixed, :info
 
     def service_exist(event)
       debug event, color("Checked if file exists at key: #{key_in(event)} (#{event.payload[:exist] ? "yes" : "no"})", BLUE)
     end
+    subscribe_log_level :service_exist, :debug
 
     def service_url(event)
       debug event, color("Generated URL for file at key: #{key_in(event)} (#{event.payload[:url]})", BLUE)
     end
+    subscribe_log_level :service_url, :debug
 
     def service_mirror(event)
       message = "Mirrored file at key: #{key_in(event)}"
       message += " (checksum: #{event.payload[:checksum]})" if event.payload[:checksum]
       debug event, color(message, GREEN)
     end
+    subscribe_log_level :service_mirror, :debug
 
     def logger
       ActiveStorage.logger

data/lib/active_storage/previewer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveStorage
+  # = Active Storage \Previewer
+  #
   # This is an abstract base class for previewers, which generate images from blobs. See
   # ActiveStorage::Previewer::MuPDFPreviewer and ActiveStorage::Previewer::VideoPreviewer for
   # examples of concrete subclasses.
@@ -65,7 +67,12 @@ module ActiveStorage
       end
 
       def instrument(operation, payload = {}, &block)
-        ActiveSupport::Notifications.instrument "#{operation}.active_storage", payload, &block
+        ActiveSupport::Notifications.instrument "#{operation}.active_storage", payload.merge(service: service_name), &block
+      end
+
+      def service_name
+        # ActiveStorage::Service::DiskService => Disk
+        blob.service.class.to_s.split("::").third.remove("Service")
       end
 
       def capture(*argv, to:)

data/lib/active_storage/reflection.rb

@@ -4,11 +4,11 @@ module ActiveStorage
   module Reflection
     class HasAttachedReflection < ActiveRecord::Reflection::MacroReflection # :nodoc:
       def variant(name, transformations)
-        variants[name] = transformations
+        named_variants[name] = NamedVariant.new(transformations)
       end
 
-      def variants
-        @variants ||= {}
+      def named_variants
+        @named_variants ||= {}
       end
     end
 

data/lib/active_storage/service/azure_storage_service.rb

@@ -7,6 +7,8 @@ require "azure/storage/blob"
 require "azure/storage/common/core/auth/shared_access_signature"
 
 module ActiveStorage
+  # = Active Storage \Azure Storage \Service
+  #
   # Wraps the Microsoft Azure Storage Blob Service as an Active Storage service.
   # See ActiveStorage::Service for the generic API documentation that applies to all services.
   class Service::AzureStorageService < Service

data/lib/active_storage/service/disk_service.rb

@@ -6,6 +6,8 @@ require "openssl"
 require "active_support/core_ext/numeric/bytes"
 
 module ActiveStorage
+  # = Active Storage \Disk \Service
+  #
   # Wraps a local disk path as an Active Storage service. See ActiveStorage::Service for the generic API
   # documentation that applies to all services.
   class Service::DiskService < Service

data/lib/active_storage/service/gcs_service.rb

@@ -5,6 +5,8 @@ require "google/apis/iamcredentials_v1"
 require "google/cloud/storage"
 
 module ActiveStorage
+  # = Active Storage \GCS \Service
+  #
   # Wraps the Google Cloud Storage as an Active Storage service. See ActiveStorage::Service for the generic API
   # documentation that applies to all services.
   class Service::GCSService < Service
@@ -195,26 +197,15 @@ module ActiveStorage
       end
 
       def issuer
-        @issuer ||= if @config[:gsa_email]
-          @config[:gsa_email]
-        else
-          uri = URI.parse("http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/email")
-          http = Net::HTTP.new(uri.host, uri.port)
-          request = Net::HTTP::Get.new(uri.request_uri)
-          request["Metadata-Flavor"] = "Google"
-
-          begin
-            response = http.request(request)
-          rescue SocketError
-            raise MetadataServerNotFoundError
-          end
-
-          if response.is_a?(Net::HTTPSuccess)
-            response.body
-          else
-            raise MetadataServerError
-          end
-        end
+        @issuer ||= @config[:gsa_email].presence || email_from_metadata_server
+      end
+
+      def email_from_metadata_server
+        env = Google::Cloud.env
+        raise MetadataServerNotFoundError if !env.metadata?
+
+        email = env.lookup_metadata("instance", "service-accounts/default/email")
+        email.presence or raise MetadataServerError
       end
 
       def signer