refile 0.5.5 → 0.6.0

data/lib/refile/attacher.rb

@@ -1,27 +1,32 @@
 module Refile
   # @api private
   class Attacher
-    attr_reader :record, :name, :cache, :store, :options, :errors, :type, :valid_extensions, :valid_content_types
+    attr_reader :definition, :record, :errors
     attr_accessor :remove
 
     Presence = ->(val) { val if val != "" }
 
-    def initialize(record, name, cache:, store:, raise_errors: true, type: nil, extension: nil, content_type: nil)
+    def initialize(definition, record)
+      @definition = definition
       @record = record
-      @name = name
-      @raise_errors = raise_errors
-      @cache = Refile.backends.fetch(cache.to_s)
-      @store = Refile.backends.fetch(store.to_s)
-      @type = type
-      @valid_extensions = [extension].flatten if extension
-      @valid_content_types = [content_type].flatten if content_type
-      @valid_content_types ||= Refile.types.fetch(type).content_type if type
       @errors = []
       @metadata = {}
     end
 
+    def name
+      @definition.name
+    end
+
+    def cache
+      @definition.cache
+    end
+
+    def store
+      @definition.store
+    end
+
     def id
-      Presence[read(:id)]
+      Presence[read(:id, true)]
     end
 
     def size
@@ -66,7 +71,7 @@ module Refile
     end
 
     def set(value)
-      if value.is_a?(String)
+      if value.is_a?(String) or value.is_a?(Hash)
         retrieve!(value)
       else
         cache!(value)
@@ -74,9 +79,12 @@ module Refile
     end
 
     def retrieve!(value)
-      @metadata = JSON.parse(value, symbolize_names: true) || {}
+      if value.is_a?(String)
+        @metadata = Refile.parse_json(value, symbolize_names: true) || {}
+      elsif value.is_a?(Hash)
+        @metadata = value
+      end
       write_metadata if cache_id
-    rescue JSON::ParserError
     end
 
     def cache!(uploadable)
@@ -88,7 +96,7 @@ module Refile
       if valid?
         @metadata[:id] = cache.upload(uploadable).id
         write_metadata
-      elsif @raise_errors
+      elsif @definition.raise_errors?
         raise Refile::Invalid, @errors.join(", ")
       end
     end
@@ -98,29 +106,30 @@ module Refile
         response = RestClient::Request.new(method: :get, url: url, raw_response: true).execute
         @metadata = {
           size: response.file.size,
-          filename: ::File.basename(url),
+          filename: URI.parse(url).path.split("/").last,
           content_type: response.headers[:content_type]
         }
         if valid?
+          response.file.open if response.file.closed? # https://github.com/refile/refile/pull/210
           @metadata[:id] = cache.upload(response.file).id
           write_metadata
-        elsif @raise_errors
+        elsif @definition.raise_errors?
           raise Refile::Invalid, @errors.join(", ")
         end
       end
     rescue RestClient::Exception
       @errors = [:download_failed]
-      raise if @raise_errors
+      raise if @definition.raise_errors?
     end
 
     def store!
       if remove?
         delete!
-        write(:id, nil)
+        write(:id, nil, true)
       elsif cache_id
         file = store.upload(get)
         delete!
-        write(:id, file.id)
+        write(:id, file.id, true)
       end
       write_metadata
       @metadata = {}
@@ -132,14 +141,6 @@ module Refile
       @metadata = {}
     end
 
-    def accept
-      if valid_content_types
-        valid_content_types.join(",")
-      elsif valid_extensions
-        valid_extensions.map { |e| ".#{e}" }.join(",")
-      end
-    end
-
     def remove?
       remove and remove != "" and remove !~ /\A0|false$\z/
     end
@@ -148,29 +149,27 @@ module Refile
       not @metadata.empty?
     end
 
-    def valid?
-      @errors = []
-      @errors << :invalid_extension if valid_extensions and not valid_extensions.include?(extension)
-      @errors << :invalid_content_type if valid_content_types and not valid_content_types.include?(content_type)
-      @errors << :too_large if cache.max_size and size and size >= cache.max_size
-      @errors.empty?
-    end
-
     def data
       @metadata if valid?
     end
 
+    def valid?
+      @errors = @definition.validate(self)
+      @errors.empty?
+    end
+
   private
 
-    def read(column)
+    def read(column, strict = false)
       m = "#{name}_#{column}"
-      value ||= record.send(m) if record.respond_to?(m)
+      value ||= record.send(m) if strict or record.respond_to?(m)
       value
     end
 
-    def write(column, value)
+    def write(column, value, strict = false)
+      return if record.frozen?
       m = "#{name}_#{column}="
-      record.send(m, value) if record.respond_to?(m) and not record.frozen?
+      record.send(m, value) if strict or record.respond_to?(m)
     end
 
     def write_metadata

data/lib/refile/attachment.rb

@@ -17,10 +17,11 @@ module Refile
     # - `remove_image=`
     # - `remote_image_url`
     # - `remote_image_url=`
+    # - `image_url`
     #
     # @example
     #   class User
-    #     extends Refile::Attachment
+    #     extend Refile::Attachment
     #
     #     attachment :image
     #     attr_accessor :image_id
@@ -34,24 +35,30 @@ module Refile
     # @param [String, Array<String>, nil] extension     Limit the uploaded file to the given extension or list of extensions
     # @param [String, Array<String>, nil] content_type  Limit the uploaded file to the given content type or list of content types
     # @return [void]
-    # @ignore
-    #   rubocop:disable Metrics/MethodLength
     def attachment(name, cache: :cache, store: :store, raise_errors: true, type: nil, extension: nil, content_type: nil)
+      definition = AttachmentDefinition.new(name,
+        cache: cache,
+        store: store,
+        raise_errors: raise_errors,
+        type: type,
+        extension: extension,
+        content_type: content_type
+      )
+
+      define_singleton_method :"#{name}_attachment_definition" do
+        definition
+      end
+
       mod = Module.new do
         attacher = :"#{name}_attacher"
 
+        define_method :"#{name}_attachment_definition" do
+          definition
+        end
+
         define_method attacher do
           ivar = :"@#{attacher}"
-          instance_variable_get(ivar) or begin
-            instance_variable_set(ivar, Attacher.new(self, name,
-              cache: cache,
-              store: store,
-              raise_errors: raise_errors,
-              type: type,
-              extension: extension,
-              content_type: content_type
-            ))
-          end
+          instance_variable_get(ivar) or instance_variable_set(ivar, Attacher.new(definition, self))
         end
 
         define_method "#{name}=" do |value|
@@ -77,6 +84,14 @@ module Refile
         define_method "remote_#{name}_url" do
         end
 
+        define_method "#{name}_url" do |*args|
+          Refile.attachment_url(self, name, *args)
+        end
+
+        define_method "#{name}_data" do
+          send(attacher).data
+        end
+
         define_singleton_method("to_s")    { "Refile::Attachment(#{name})" }
         define_singleton_method("inspect") { "Refile::Attachment(#{name})" }
       end

data/lib/refile/attachment/active_record.rb

@@ -5,6 +5,7 @@ module Refile
 
       # Attachment method which hooks into ActiveRecord models
       #
+      # @return [void]
       # @see Refile::Attachment#attachment
       def attachment(name, raise_errors: false, **options)
         super
@@ -15,10 +16,27 @@ module Refile
           if send(attacher).present?
             send(attacher).valid?
             errors = send(attacher).errors
-            self.errors.add(name, *errors) unless errors.empty?
+            errors.each do |error|
+              self.errors.add(name, error)
+            end
           end
         end
 
+        define_method "#{name}=" do |value|
+          send("#{name}_id_will_change!")
+          super(value)
+        end
+
+        define_method "remove_#{name}=" do |value|
+          send("#{name}_id_will_change!")
+          super(value)
+        end
+
+        define_method "remote_#{name}_url=" do |value|
+          send("#{name}_id_will_change!")
+          super(value)
+        end
+
         before_save do
           send(attacher).store!
         end
@@ -27,6 +45,77 @@ module Refile
           send(attacher).delete!
         end
       end
+
+      # Macro which generates accessors for assigning multiple attachments at
+      # once. This is primarily useful together with multiple file uploads.
+      #
+      # The name of the generated accessors will be the name of the association
+      # and the name of the attachment in the associated model. So if a `Post`
+      # accepts attachments for `images`, and the attachment in the `Image`
+      # model is named `file`, then the accessors will be named `images_files`.
+      #
+      # @example in model
+      #   class Post
+      #     has_many :images, dependent: :destroy
+      #     accepts_attachments_for :images
+      #   end
+      #
+      # @example in associated model
+      #   class Image
+      #     attachment :image
+      #   end
+      #
+      # @example in form
+      #   <%= form_for @post do |form| %>
+      #     <%= form.attachment_field :images_files, multiple: true %>
+      #   <% end %>
+      #
+      # @param [Symbol] association_name     Name of the association
+      # @param [Symbol] attachment           Name of the attachment in the associated model
+      # @param [Symbol] append               If true, new files are appended instead of replacing the entire list of associated models.
+      # @return [void]
+      def accepts_attachments_for(association_name, attachment: :file, append: false)
+        association = reflect_on_association(association_name)
+        name = "#{association_name}_#{attachment.to_s.pluralize}"
+
+        mod = Module.new do
+          define_method :"#{name}_attachment_definition" do
+            association.klass.send("#{attachment}_attachment_definition")
+          end
+
+          define_method :"#{name}_data" do
+            if send(association_name).all? { |record| record.send("#{attachment}_attacher").valid? }
+              send(association_name).map(&:"#{attachment}_data").select(&:present?)
+            end
+          end
+
+          define_method :"#{name}" do
+            send(association_name).map(&attachment)
+          end
+
+          define_method :"#{name}=" do |files|
+            cache, files = files.partition { |file| file.is_a?(String) }
+
+            cache = Refile.parse_json(cache.first)
+
+            if not append and (files.present? or cache.present?)
+              send("#{association_name}=", [])
+            end
+
+            if files.empty? and cache.present?
+              cache.select(&:present?).each do |file|
+                send(association_name).build(attachment => file.to_json)
+              end
+            else
+              files.select(&:present?).each do |file|
+                send(association_name).build(attachment => file)
+              end
+            end
+          end
+        end
+
+        include mod
+      end
     end
   end
 end

data/lib/refile/attachment_definition.rb

@@ -0,0 +1,47 @@
+module Refile
+  # @api private
+  class AttachmentDefinition
+    attr_reader :record, :name, :cache, :store, :options, :type, :valid_extensions, :valid_content_types
+    attr_accessor :remove
+
+    def initialize(name, cache:, store:, raise_errors: true, type: nil, extension: nil, content_type: nil)
+      @name = name
+      @raise_errors = raise_errors
+      @cache_name = cache
+      @store_name = store
+      @type = type
+      @valid_extensions = [extension].flatten if extension
+      @valid_content_types = [content_type].flatten if content_type
+      @valid_content_types ||= Refile.types.fetch(type).content_type if type
+    end
+
+    def cache
+      Refile.backends.fetch(@cache_name.to_s)
+    end
+
+    def store
+      Refile.backends.fetch(@store_name.to_s)
+    end
+
+    def accept
+      if valid_content_types
+        valid_content_types.join(",")
+      elsif valid_extensions
+        valid_extensions.map { |e| ".#{e}" }.join(",")
+      end
+    end
+
+    def raise_errors?
+      @raise_errors
+    end
+
+    def validate(attacher)
+      errors = []
+      extension_included = valid_extensions && valid_extensions.map(&:downcase).include?(attacher.extension.to_s.downcase)
+      errors << :invalid_extension if valid_extensions and not extension_included
+      errors << :invalid_content_type if valid_content_types and not valid_content_types.include?(attacher.content_type)
+      errors << :too_large if cache.max_size and attacher.size and attacher.size >= cache.max_size
+      errors
+    end
+  end
+end

data/lib/refile/backend/s3.rb

@@ -1,147 +1 @@
-require "aws-sdk"
-require "open-uri"
-
-module Refile
-  module Backend
-    # A refile backend which stores files in Amazon S3
-    #
-    # @example
-    #   backend = Refile::Backend::S3.new(
-    #     access_key_id: "xyz",
-    #     secret_access_key: "abcd1234",
-    #     bucket: "my-bucket",
-    #     prefix: "files"
-    #   )
-    #   file = backend.upload(StringIO.new("hello"))
-    #   backend.read(file.id) # => "hello"
-    class S3
-      extend Refile::BackendMacros
-
-      attr_reader :access_key_id, :max_size
-
-      # Sets up an S3 backend with the given credentials.
-      #
-      # @param [String] access_key_id
-      # @param [String] secret_access_key
-      # @param [String] bucket            The name of the bucket where files will be stored
-      # @param [String] prefix            A prefix to add to all files. Prefixes on S3 are kind of like folders.
-      # @param [Integer, nil] max_size    The maximum size of an uploaded file
-      # @param [#hash] hasher             A hasher which is used to generate ids from files
-      # @param [Hash] s3_options          Additional options to initialize S3 with
-      # @see http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/Core/Configuration.html
-      # @see http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/S3.html
-      def initialize(access_key_id:, secret_access_key:, bucket:, max_size: nil, prefix: nil, hasher: Refile::RandomHasher.new, **s3_options)
-        @access_key_id = access_key_id
-        @secret_access_key = secret_access_key
-        @s3_options = { access_key_id: access_key_id, secret_access_key: secret_access_key }.merge s3_options
-        @s3 = AWS::S3.new @s3_options
-        @bucket_name = bucket
-        @bucket = @s3.buckets[@bucket_name]
-        @hasher = hasher
-        @prefix = prefix
-        @max_size = max_size
-      end
-
-      # Upload a file into this backend
-      #
-      # @param [IO] uploadable      An uploadable IO-like object.
-      # @return [Refile::File]      The uploaded file
-      verify_uploadable def upload(uploadable)
-        id = @hasher.hash(uploadable)
-
-        if uploadable.is_a?(Refile::File) and uploadable.backend.is_a?(S3) and uploadable.backend.access_key_id == access_key_id
-          uploadable.backend.object(uploadable.id).copy_to(object(id))
-        else
-          object(id).write(uploadable, content_length: uploadable.size)
-        end
-
-        Refile::File.new(self, id)
-      end
-
-      # Get a file from this backend.
-      #
-      # Note that this method will always return a {Refile::File} object, even
-      # if a file with the given id does not exist in this backend. Use
-      # {FileSystem#exists?} to check if the file actually exists.
-      #
-      # @param [Sring] id           The id of the file
-      # @return [Refile::File]      The retrieved file
-      verify_id def get(id)
-        Refile::File.new(self, id)
-      end
-
-      # Delete a file from this backend
-      #
-      # @param [Sring] id           The id of the file
-      # @return [void]
-      verify_id def delete(id)
-        object(id).delete
-      end
-
-      # Return an IO object for the uploaded file which can be used to read its
-      # content.
-      #
-      # @param [Sring] id           The id of the file
-      # @return [IO]                An IO object containing the file contents
-      verify_id def open(id)
-        Kernel.open(object(id).url_for(:read))
-      end
-
-      # Return the entire contents of the uploaded file as a String.
-      #
-      # @param [String] id           The id of the file
-      # @return [String]             The file's contents
-      verify_id def read(id)
-        object(id).read
-      rescue AWS::S3::Errors::NoSuchKey
-        nil
-      end
-
-      # Return the size in bytes of the uploaded file.
-      #
-      # @param [Sring] id           The id of the file
-      # @return [Integer]           The file's size
-      verify_id def size(id)
-        object(id).content_length
-      rescue AWS::S3::Errors::NoSuchKey
-        nil
-      end
-
-      # Return whether the file with the given id exists in this backend.
-      #
-      # @param [Sring] id           The id of the file
-      # @return [Boolean]
-      verify_id def exists?(id)
-        object(id).exists?
-      end
-
-      # Remove all files in this backend. You must confirm the deletion by
-      # passing the symbol `:confirm` as an argument to this method.
-      #
-      # @example
-      #   backend.clear!(:confirm)
-      # @raise [Refile::Confirm]     Unless the `:confirm` symbol has been passed.
-      # @param [:confirm] confirm    Pass the symbol `:confirm` to confirm deletion.
-      # @return [void]
-      def clear!(confirm = nil)
-        raise Refile::Confirm unless confirm == :confirm
-        @bucket.objects.with_prefix(@prefix).delete_all
-      end
-
-      # Return a presign signature which can be used to upload a file into this
-      # backend directly.
-      #
-      # @return [Refile::Signature]
-      def presign
-        id = RandomHasher.new.hash
-        signature = @bucket.presigned_post(key: [*@prefix, id].join("/"))
-        signature.where(content_length: @max_size) if @max_size
-        Signature.new(as: "file", id: id, url: signature.url.to_s, fields: signature.fields)
-      end
-
-      verify_id def object(id)
-        @bucket.objects[[*@prefix, id].join("/")]
-      end
-    end
-  end
-end
+raise "[Refile] the S3 backend has been extracted into a separate gem, see https://github.com/refile/refile-s3"