card-mod-carrierwave 0.11.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 29840e46e626a7121a84faa9b4b0f9889694ab7653031bd9cf97ccb896d46263
+  data.tar.gz: 503d37c6471c6fd8d0e6cba3c94c65097663ab0854fc24861673c80f913e1e86
+SHA512:
+  metadata.gz: 65f55c9a919ea38e364f5863030d35b5674569dab60454ee157c3e78c762afbc427b3e258246d8389714e00eb752bf8076b948e8a5c70b4d202a2dd63ff01695
+  data.tar.gz: 69c7e3184ca375b4342ad3a4f5dd2ae9f8654666e0e6cefded79f5b3c2823dfd8a074ad906acdb28b749f51413c49ebba315c7a790aa17907b1da063baf07791

data/config/core_initializers/carrierwave.rb

@@ -0,0 +1,5 @@
+require "carrierwave"
+
+ActiveSupport.on_load :card do
+  Card.extend CarrierWave::Mount
+end

data/lib/carrier_wave/card_mount.rb

@@ -0,0 +1,134 @@
+require "carrierwave"
+
+module CarrierWave
+  # adapt carrierwave mount to cards
+  module CardMount
+    include CarrierWave::Mount
+
+    def uploaders
+      Card.uploaders ||= {}
+    end
+
+    def uploader_options
+      Card.uploader_options ||= {}
+    end
+
+    def mount_uploader column, uploader=nil, options={}, &block
+      options[:mount_on] ||= :db_content
+      super
+
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        event :store_#{column}_event, :finalize,
+              on: :save, when: :store_#{column}_event? do
+          store_#{column}!
+        end
+
+        # remove files only if card has no history
+        event :remove_#{column}_event, :finalize,
+              on: :delete, when: proc { |c| !c.history? } do
+          remove_#{column}!
+        end
+        event :mark_remove_#{column}_false_event, :finalize,
+              on: :update do
+          mark_remove_#{column}_false
+        end
+        event :store_previous_changes_for_#{column}_event, :store,
+              on: :update, when: proc { |c| !c.history? } do
+          store_previous_changes_for_#{column}
+        end
+        event :remove_previously_stored_#{column}_event, :finalize,
+              on: :update, when: proc { |c| !c.history?} do
+          remove_previously_stored_#{column}
+        end
+
+        # don't attempt to store coded images unless ENV specifies it
+        def store_#{column}_event?
+          !coded? || ENV["STORE_CODED_FILES"]
+        end
+
+        def attachment
+          #{column}
+        end
+
+        def store_attachment!
+          store_#{column}!
+        end
+
+        def attachment_name
+          "#{column}".to_sym
+        end
+
+        def read_uploader *args
+          read_attribute *args
+        end
+
+        def write_uploader *args
+          write_attribute *args
+        end
+
+        def #{column}=(new_file)
+          return if new_file.blank?
+          assign_file(new_file) { super }
+        end
+
+        def remote_#{column}_url=(url)
+          assign_file(url) { super }
+        end
+
+        def assign_file file
+          db_column = _mounter(:#{column}).serialization_column
+          send(:"\#{db_column}_will_change!") # unless attribute_is_changing? db_column
+          if web?
+            self.content = file
+          else
+            send(:"#{column}_will_change!")
+            yield
+          end
+        end
+
+        def remove_#{column}=(value)
+          column = _mounter(:#{column}).serialization_column
+          send(:"\#{column}_will_change!")
+          super
+        end
+
+        def remove_#{column}!
+          self.remove_#{column} = true
+          write_#{column}_identifier
+          self.remove_#{column} = false
+          super
+        end
+
+        def #{column}_will_change!
+          @#{column}_changed = true
+          @#{column}_is_changing = true
+        end
+
+        def #{column}_is_changing?
+          @#{column}_is_changing
+        end
+
+        def #{column}_changed?
+          @#{column}_changed
+        end
+
+        def serializable_hash(options=nil)
+          hash = {}
+
+          except = options && options[:except] &&
+                   Array.wrap(options[:except]).map(&:to_s)
+          only   = options && options[:only]   &&
+                   Array.wrap(options[:only]).map(&:to_s)
+
+          self.class.uploaders.each do |column, uploader|
+            if (!only && !except) || (only && only.include?(column.to_s)) ||
+               (!only && except && !except.include?(column.to_s))
+              hash[column.to_s] = _mounter(column).uploader.serializable_hash
+            end
+          end
+          super(options).merge(hash)
+        end
+      RUBY
+    end
+  end
+end

data/lib/carrier_wave/file_card_uploader.rb

@@ -0,0 +1,320 @@
+module CarrierWave
+  class << self
+    def tmp_path
+      @tmp_path ||= Card.paths["tmp"].existent.first
+    end
+  end
+
+  class SanitizedFile
+    def content_type
+      # the original content_type method doesn't seem to be very reliable
+      # It uses mime_magic_content_type  - which returns invalid/invalid for css files
+      # that start with a comment - as the second option.  (we switch the order and
+      # use it as the third option)
+      @content_type ||=
+        existing_content_type ||
+        mini_mime_content_type ||
+        mime_magic_content_type
+    end
+  end
+
+  module Uploader
+    # Implements a different name pattern for versions than CarrierWave's
+    # default: we expect the version name at the end of the filename separated
+    # by a dash
+    module Versions
+      private
+
+      # put version at the end of the filename
+      def full_filename for_file
+        name = super(for_file)
+        parts = name.split "."
+        basename = [parts.shift, version_name].compact.join("-")
+        "#{basename}.#{parts.join('.')}"
+      end
+    end
+  end
+
+  # Takes care of the file upload for cards with attached files.
+  # Most of the upload behaviour depends on the card itself.
+  # (e.g. card type and storage option chosen for the card). So in contrary
+  # to CarrierWave's default uploader we depend very much on the model
+  # (= card object) to get the correct paths for retrieving and storing
+  # the file.
+  #
+  # Cards that support attachments (by default those are cards of type "file"
+  # and "image") accept a file handle as a card attribute.
+  #
+  # @example Attaching a file to a file card
+  #   Card.create name: "file card", type: :file,
+  #               file: File.new(path_to_file)
+  #
+  # @example Attaching a image to a image card
+  #   Card.create name: "file card", type: :image,
+  #               image: File.new(path_to_image)
+  #
+  # It's possible to upload files using a url. The card attribute for that is
+  # remote_<attachment_type>_url
+  #
+  # @example Create a file card using a remote url
+  #   Card.create name: "file_card", type: :file,
+  #               remote_file_url: "http://a.file.in/the.web"
+  #
+  # @example Updating a image card using a remote url
+  #   card.update remote_image_url: "http://a.image/somewhere.png"
+  #
+  # ## Storage types
+  # You can choose between four different storage options
+  #  - coded: These files are in the codebase, like the default logo.
+  #      Every view is a decko request.
+  #  - local: Uploaded files which are stored in a local upload directory
+  #      (upload path is configurable via config.paths["files"]).
+  #      If read permissions are set such that "Anyone" can read, then there is
+  #      a symlink from the public directory.  Otherwise every view is a decko
+  #      request.
+  #  - cloud: You can configure buckets that refer to an external storage
+  #      service. Link is rendered as absolute url
+  #  - web: A fixed url (to external source). No upload or other file
+  #      processing. Link is just the saved url.
+  #
+  # Currently, there is no web interface that let's a user or administrator
+  # choose a storage option for a specific card or set of cards.
+  # There is only a global config option to set the storage type for all new
+  # uploads (config.storage_type). On the *admin card it's possible to
+  # update all existing file cards according to the current global config.
+  #
+  # Storage types for single cards can be changed by developers using
+  # the card attributes "storage_type", "bucket", and "mod".
+  #
+  # @example Creating a hard-coded file
+  #   Card.create name: "file card", type_id: Card::FileID,
+  #               file: File.new(path),
+  #               storage_type: :coded, mod: "account"
+  #
+  # @example Moving a file to a cloud service
+  #   # my_deck/config/application.rb:
+  #   config.file_buckets = {
+  #     aws_bucket: {
+  #       provider: "fog/aws",
+  #       directory: "bucket-name",
+  #       subdirectory: "files",
+  #       credentials: {
+  #          provider: 'AWS'                         # required
+  #          aws_access_key_id: 'key'                # required
+  #          aws_secret_access_key: 'secret-key'     # required
+  #       public: true,
+  #      }
+  #   }
+  #
+  #   # decko console or rake task:
+  #   card.update storage_type: :cloud, bucket: :aws_bucket
+  #
+  # @example Creating a file card with fixed external link
+  #   Card.create name: "file card", type_id: Card::FileID,
+  #               content: "http://animals.org/cat.png"
+  #               storage_type: :web
+  #
+  #   Card.create name: "file card", type_id: Card::FileID,
+  #               file: "http://animals.org/cat.png"
+  #               storage_type: :web
+  #
+  # Depending on the storage type the uploader uses the following paths
+  # and identifiers.
+  # ### Identifier (stored in the database as db_content)
+  #  - coded: :codename/mod_name.ext
+  #  - local: ~card_id/action_id.ext
+  #  - cloud: (bucket)/card_id/action_id.ext
+  #  - web: http://url
+  #
+  # ### Storage path
+  #  - coded:
+  #    mod_dir/file/codename/type_code(-variant).ext  (no colon on codename!)
+  #  - local:
+  #    files_dir/card_id/action_id(-variant).ext           (no tilde on id!)
+  #  - cloud:
+  #    bucket/bucket_subdir/id/action_id(-variant).ext
+  #  - web: no storage
+  #
+  # Variants are only used for images. Possible options are
+  # icon|small|medium|large|original.
+  # files_dir, bucket, and bucket_subdir can be changed via config options.
+  #
+  # ### Supported url patterns
+  # mark.ext
+  # mark/revision.ext
+  # mark/revision-variant.ext
+  # /files/mark/revision-variant.ext  # <- public symlink if readable by
+  #                                   #    "Anyone"
+  #
+  # <mark> can be one of the following options
+  # - <card name>
+  # - ~<card id>
+  # - :<code name>
+  #
+  # <revision> is the mod name if the file is coded or and action_id in any
+  # case
+  #
+  # Examples:
+  # *logo.png
+  # ~22/33-medium.png               # local
+  # :yeti_skin/standard-large.png   # coded
+  #
+  class FileCardUploader < Uploader::Base
+    attr_accessor :mod
+    include Card::Env::Location
+
+    STORAGE_TYPES = [:cloud, :web, :coded, :local].freeze
+    CONFIG_OPTIONS = [:provider, :attributes, :directory, :public, :credentials,
+                      :authenticated_url_expiration, :use_ssl_for_aws].freeze
+    CONFIG_CREDENTIAL_OPTIONS = [
+      :provider,
+      :aws_access_key_id, :aws_secret_access_key, :region, :host, :endpoint,
+      :google_access_key_id, :google_secret_access_key
+    ].freeze
+    delegate :store_dir, :retrieve_dir, :file_dir, :mod, :bucket, to: :model
+
+    def valid?
+      extension.present?
+    end
+
+    def filename
+      if model.coded?
+        "#{model.type_code}#{extension}"
+      else
+        "#{action_id}#{extension}"
+      end
+    end
+
+    def extension
+      case
+      when file&.extension.present?     then ".#{file.extension}"
+      when card_content = model.content then File.extname(card_content)
+      when orig = original_filename     then File.extname(orig)
+      else                              ""
+      end.downcase
+    end
+
+    # generate identifier that gets stored in the card's db_content field
+    # @param opts [Hash] generate an identifier using the given storage options
+    #   instead of the storage options derived from the model and
+    #   the global configuration
+    # @option opts [Symbol] storage_type
+    # @option opts [String] mod
+    # @option opts [Symbol] bucket
+    def db_content opts={}
+      model.with_storage_options opts do
+        return model.content if model.web?
+        return "" unless file.present?
+        "%s/%s" % [file_dir, url_filename]
+      end
+    end
+
+    def url_filename opts={}
+      model.with_storage_options opts do
+        if model.coded?
+          "#{model.mod}#{extension}"
+        else
+          "#{action_id}#{extension}"
+        end
+      end
+    end
+
+    # @option opts [Symbol] :absolute - return absolute url
+    def url opts={}
+      if model.cloud?
+        file&.url
+      elsif model.web?
+        model.content
+      else
+        local_url opts
+      end
+    end
+
+    def local_url opts={}
+      "%s/%s/%s" % [local_url_base(opts), file_dir, full_filename(url_filename(opts))]
+    end
+
+    def local_url_base opts={}
+      web_path = Card.config.files_web_path
+      opts.delete(:absolute) ? card_url(web_path) : card_path(web_path)
+    end
+
+    def public_path
+      File.join Cardio.paths["public"].existent.first, url
+    end
+
+    def cache_dir
+      @model.files_base_dir + "/cache"
+    end
+
+    # Carrierwave calls store_path without argument when it stores the file
+    # and with the identifier from the db when it retrieves the file.
+    # In our case the first part of our identifier is not part of the path
+    # but we can construct the filename from db data. So we don't need the
+    # identifier.
+    def store_path for_file=nil
+      if for_file
+        retrieve_path
+      else
+        File.join([store_dir, full_filename(filename)].compact)
+      end
+    end
+
+    def retrieve_path
+      File.join([retrieve_dir, full_filename(filename)].compact)
+    end
+
+    def tmp_path
+      Dir.mkdir model.tmp_upload_dir unless Dir.exist? model.tmp_upload_dir
+      File.join model.tmp_upload_dir, filename
+    end
+
+    def create_versions? new_file
+      model.create_versions? new_file
+    end
+
+    # paperclip compatibility used in type/file.rb#core (base format)
+    def path version=nil
+      version ? versions[version].path : super()
+    end
+
+    def original_filename
+      @original_filename ||= model.selected_action &&
+                             model.selected_action.comment
+    end
+
+    def action_id
+      model.selected_content_action_id || action_id_stand_in
+    end
+
+    # delegate carrierwave's fog config methods to bucket configuration
+    ::CarrierWave::FileCardUploader::CONFIG_OPTIONS.each do |name|
+      define_method("fog_#{name}") { bucket_config name }
+    end
+
+    def bucket_config option
+      @model.bucket_config[option]
+    end
+
+    def asset_host
+      bucket_config(:asset_host) || super
+    end
+
+    private
+
+    # used as action_id in the filename
+    # if card is not #actionable?
+    def action_id_stand_in
+      Time.now.to_i
+    end
+
+    def storage
+      case @model.storage_type
+      when :cloud
+        ::CarrierWave::Storage::Fog.new(self)
+      else
+        ::CarrierWave::Storage::File.new(self)
+      end
+    end
+  end
+end