card 1.19.0 → 1.19.1

data/mod/carrierwave/lib/carrier_wave/file_card_uploader.rb

@@ -1,30 +1,13 @@
-# *DATABASE_CONTENT*
-# if in mod:
-#   :codename/modname.ext
-# else
-#   ~card_id/action_id.ext
-#
-# *FILE SYSTEM*
-# if in mod
-#   (mod_dir)/files/codename/type_code-variant.ext  (no colon on codename!)
-# else
-#   (files_dir)/id/action_id-variant.ext            (no tilde on id!)
-#
-# variant = icon|small|medium|large|original  (only for images)
-#
-# *URLS*
-# mark.ext
-# mark/revision.ext
-# mark/revision-variant.ext
-#
-# revision = modname or action_id
-#
-# Examples:
-# ~22/33-medium.png
-# :yeti_skin/standard-large.png
-
 module CarrierWave
+  class << self
+    def tmp_path
+      @tmp_path ||= Card.paths["tmp"].existent.first
+    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
 
@@ -38,14 +21,146 @@ module CarrierWave
     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_attributes 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 wagn 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 wagn
+  #      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,
+  #      }
+  #   }
+  #
+  #   # wagn console or rake task:
+  #   card.update_attributes 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 :file
+    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 filename
-      if mod_file?
+      if model.coded?
         "#{model.type_code}#{extension}"
       else
         "#{action_id}#{extension}"
@@ -62,43 +177,55 @@ module CarrierWave
     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={}
-      return "" unless file.present?
-      model.load_from_mod = opts[:mod] if opts[:mod] && !model.load_from_mod
-      "%s/%s" % [file_dir, url_filename(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.load_from_mod = opts[:mod] if opts[:mod] && !model.load_from_mod
-
-      basename = if (mod = mod_file?)
-                   "#{mod}#{extension}"
-                 else
-                   "#{action_id}#{extension}"
-                 end
+      model.with_storage_options opts do
+        if model.coded?
+          "#{model.mod}#{extension}"
+        else
+          "#{action_id}#{extension}"
+        end
+      end
     end
 
     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" % [card_path(Card.config.files_web_path), file_dir,
                     full_filename(url_filename(opts))]
     end
 
-    def file_dir
-      if mod_file?
-        ":#{model.codename}"
-      elsif model.id
-        "~#{model.id}"
-      else
-        "~#{model.upload_cache_card.id}"
-      end
+    def public_path
+      File.join Cardio.paths["public"].existent.first, url
     end
 
     def cache_dir
-      Cardio.paths["files"].existent.first + "/cache"
+      @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
+    # 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.
@@ -133,20 +260,25 @@ module CarrierWave
                              model.selected_action.comment
     end
 
-    def store_dir
-      model.store_dir
+    def action_id
+      model.selected_content_action_id
     end
 
-    def retrieve_dir
-      model.retrieve_dir
+    # delegate carrierwave's fog config methods to cardio's config methods
+    ::CarrierWave::FileCardUploader::CONFIG_OPTIONS.each do |name|
+      define_method("fog_#{name}") { @model.bucket_config[name] }
     end
 
-    def mod_file?
-      model.mod_file?
-    end
+    private
 
-    def action_id
-      model.selected_content_action_id
+    def storage
+      case @model.storage_type
+      when :cloud
+        require "carrierwave/storage/fog"
+        require "fog"
+        ::CarrierWave::Storage::Fog.new(self)
+      else ::CarrierWave::Storage::File.new(self)
+      end
     end
   end
-end
+end

data/mod/carrierwave/lib/carrier_wave/image_card_uploader.rb

@@ -1,6 +1,11 @@
 require "mini_magick"
 
 module CarrierWave
+  # Adds image specific version handling to {FileCardUploader}.
+  # The ImageCardUploader creates five versions of different sizes when it
+  # uploads an imagae file:
+  # icon (16x16), small (75x75), medium (200X200), large (500x500) and
+  # the original size.
   class ImageCardUploader < FileCardUploader
     include CarrierWave::MiniMagick
 

data/mod/carrierwave/set/abstract/attachment.rb

@@ -1,5 +1,7 @@
 require "carrier_wave/cardmount"
 
+attr_writer :empty_ok
+
 def self.included host_class
   host_class.extend CarrierWave::CardMount
 end
@@ -8,98 +10,39 @@ event :select_file_revision, after: :select_action do
   attachment.retrieve_from_store!(attachment.identifier)
 end
 
-event :upload_attachment, :prepare_to_validate,
-      on: :save, when: proc { |c| c.preliminary_upload? } do
-  save_original_filename  # save original filename as comment in action
-  write_identifier        # set db_content
-  # (needs original filename to determine extension)
-  store_attachment!
-  finalize_action         # create Card::Change entry for db_content
-
-  card_id = new_card? ? upload_cache_card.id : id
-  @current_action.update_attributes! draft: true, card_id: card_id
-  success << {
-    target: (new_card? ? upload_cache_card : self),
-    type: type_name,
-    view: "preview_editor",
-    rev_id: current_action.id
-  }
-  abort :success
-end
-
-event :assign_attachment_on_create, :initialize,
-      after: :assign_action, on: :create,
-      when: proc { |c| c.save_preliminary_upload? } do
-  if (action = Card::Action.fetch(@action_id_of_cached_upload))
-    upload_cache_card.selected_action_id = action.id
-    upload_cache_card.select_file_revision
-    assign_attachment upload_cache_card.attachment.file, action.comment
-  end
-end
-
-event :assign_attachment_on_update, :initialize,
-      after: :assign_action, on: :update,
-      when:  proc { |c| c.save_preliminary_upload? } do
-  if (action = Card::Action.fetch(@action_id_of_cached_upload))
-    uploaded_file =
-      with_selected_action_id(action.id) do
-        attachment.file
-      end
-    assign_attachment uploaded_file, action.comment
-  end
-end
-
-def assign_attachment file, original_filename
-  send "#{attachment_name}=", file
-  write_identifier
-  @current_action.update_attributes! comment: original_filename
-end
-
 # we need a card id for the path so we have to update db_content when we have
 # an id
-event :correct_identifier, :finalize, on: :create do
-  update_column(:db_content, attachment.db_content(mod: load_from_mod))
+event :correct_identifier, :finalize,
+      on: :create, when: proc { |c| !c.web? } do
+  update_column(:db_content, attachment.db_content)
   expire
 end
 
-def file_ready_to_save?
-  attachment.file.present? &&
-    !preliminary_upload? &&
-    !save_preliminary_upload? &&
-    attachment_changed?
-end
-
 event :save_original_filename, :prepare_to_store,
       when: proc { |c| c.file_ready_to_save? } do
   return unless @current_action
   @current_action.update_attributes! comment: original_filename
 end
 
-event :delete_cached_upload_file_on_create, :integrate,
-      on: :create, when: proc { |c| c.save_preliminary_upload? } do
-  if (action = Card::Action.fetch(@action_id_of_cached_upload))
-    upload_cache_card.delete_files_for_action action
-    action.delete
-  end
-  clear_upload_cache_dir_for_new_cards
-end
-
-event :delete_cached_upload_file_on_update, :integrate,
-      on: :update, when: proc { |c| c.save_preliminary_upload? } do
-  if (action = Card::Action.fetch(@action_id_of_cached_upload))
-    delete_files_for_action action
-    action.delete
+event :validate_file_exist, :validate, on: :save do
+  return if empty_ok?
+  if will_be_stored_as == :web
+    errors.add "url is missing" if content.blank?
+  elsif !attachment.file.present?
+    errors.add attachment_name, "is missing"
   end
 end
 
-event :validate_file_exist, :validate, on: :create do
-  unless attachment.file.present? || empty_ok?
-    errors.add attachment_name, "is missing"
-  end
+event :write_identifier, after: :save_original_filename,
+                         when: proc { |c| !c.web? } do
+  self.content = attachment.db_content
 end
 
-event :write_identifier, after: :save_original_filename do
-  self.content = attachment.db_content(mod: load_from_mod)
+def file_ready_to_save?
+  attachment.file.present? &&
+    !preliminary_upload? &&
+    !save_preliminary_upload? &&
+    attachment_changed?
 end
 
 def item_names _args={} # needed for flexmail attachments.  hacky.
@@ -107,19 +50,13 @@ def item_names _args={} # needed for flexmail attachments.  hacky.
 end
 
 def original_filename
+  return content.split("/").last if web?
   attachment.original_filename
 end
 
 def unfilled?
-  !attachment.present? && !save_preliminary_upload? && !subcards.present?
-end
-
-def preliminary_upload?
-  Card::Env && Card::Env.params[:attachment_upload]
-end
-
-def save_preliminary_upload?
-  @action_id_of_cached_upload.present?
+  !attachment.present? && !save_preliminary_upload? && !subcards.present? &&
+    !content.present?
 end
 
 def attachment_changed?
@@ -130,86 +67,10 @@ def create_versions?
   true
 end
 
-# used for uploads for new cards until the new card is created
-def upload_cache_card
-  @upload_cache_card ||= Card["new_#{attachment_name}".to_sym]
-end
-
-# action id of the cached upload
-attr_writer :action_id_of_cached_upload
-
-attr_reader :action_id_of_cached_upload
-
-attr_writer :empty_ok
-
 def empty_ok?
   @empty_ok
 end
 
-def load_from_mod= value
-  @mod = value
-  write_identifier
-  @store_in_mod = true if value
-end
-
-def load_from_mod
-  @mod
-end
-
-def store_dir
-  if @store_in_mod
-    mod_dir
-  else
-    upload_dir
-  end
-end
-
-def retrieve_dir
-  if mod_file?
-    mod_dir
-  else
-    upload_dir
-  end
-end
-
-# place for files of regular file cards
-def upload_dir
-  if id
-    "#{Card.paths['files'].existent.first}/#{id}"
-  else
-    tmp_upload_dir
-  end
-end
-
-# place for files if card doesn't have an id yet
-def tmp_upload_dir _action_id=nil
-  "#{Card.paths['files'].existent.first}/#{upload_cache_card.id}"
-end
-
-# place for files of mod file cards
-def mod_dir
-  mod = @mod || mod_file?
-  Card.paths["mod"].to_a.each do |mod_path|
-    dir = File.join(mod_path, mod, "file", codename)
-    return dir if Dir.exist? dir
-  end
-end
-
-def mod_file?
-  return @mod if @store_in_mod
-  # when db_content was changed assume that it's no longer a mod file
-  return if db_content_changed? || !content.present?
-  case content
-  when %r{^:[^/]+/([^.]+)} then Regexp.last_match(1) # current mod_file format
-  when /^\~/               then false  # current id file format
-  else
-    if (lines = content.split("\n")) && (lines.size == 4)
-      # old format, still used in card_changes.
-      lines.last
-    end
-  end
-end
-
 def assign_set_specific_attributes
   # reset content if we really have something to upload
   if @set_specific.present? && @set_specific[attachment_name.to_s].present?
@@ -218,43 +79,18 @@ def assign_set_specific_attributes
   super
 end
 
-def clear_upload_cache_dir_for_new_cards
-  Dir.entries(tmp_upload_dir).each do |filename|
-    if filename =~ /^\d+/
-      path = File.join(tmp_upload_dir, filename)
-      FileUtils.rm path if Card.older_than_five_days? File.ctime(path)
-    end
-  end
-end
-
 def delete_files_for_action action
   with_selected_action_id(action.id) do
-    FileUtils.rm attachment.file.path
+    attachment.file.delete
     attachment.versions.each_value do |version|
-      FileUtils.rm version.path
+      version.file.delete
     end
   end
 end
 
 # create filesystem links to files from prior action
-def symlink_to prior_action_id
-  return unless prior_action_id != last_action_id
-  save_action_id = selected_action_id
-  links = {}
-
-  self.selected_action_id = prior_action_id
-  attachment.versions.each do |name, version|
-    links[name] = version.store_path
-  end
-  original = attachment.store_path
-
-  self.selected_action_id = last_action_id
-  attachment.versions.each do |name, version|
-    ::File.symlink links[name], version.store_path
-  end
-  ::File.symlink original, attachment.store_path
-
-  self.selected_action_id = save_action_id
+def rollback_to action
+  update_attributes! revision(action).merge(empty_ok: true)
 end
 
 def attachment_format ext