Module: Uploadbox::ImageUploader

Defined in:
lib/uploadbox/image_uploader.rb

Instance Method Summary collapse

Instance Method Details

#uploads_one(upload_name, options = {}) ⇒ Object 



3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/uploadbox/image_uploader.rb', line 3

def uploads_one(upload_name, options={})
  default_options = {
    default: false,
    removable: true,
    retina: Uploadbox.retina,
    quality: Uploadbox.retina ? (Uploadbox.retina_quality || 40) : (Uploadbox.image_quality || 80)
  }
  options = options.reverse_merge(default_options)
  upload_versions = options.select{ |key| default_options.keys.exclude? key }
  options = options.select{ |key| default_options.keys.include? key }

  imageable_type = self.to_s
  upload_class_name = imageable_type + upload_name.to_s.camelize
  upload_class = Class.new(Image)
  Uploadbox.const_set(upload_class_name, upload_class)

  # @post.picture?
  define_method("#{upload_name}?") { send(upload_name) and send(upload_name).file? }

  # @post.attach_picture
  define_method("attach_#{upload_name}") do |upload_id|
    if upload_id.present?
      self.send("attach_#{upload_name}!", upload_id)
    end
  end

  # @post.remote_picture_url=('http://exemple.com/image.jpg')
  define_method("remote_#{upload_name}_url=") do |url|
    upload = Uploadbox.const_get(upload_class_name).create!(remote_file_url: url)
    self.send("#{upload_name}=", upload)
  end

  # @post.attach_picture!
  define_method("attach_#{upload_name}!") do |upload_id|
    self.send("#{upload_name}=", upload_class.find(upload_id))
  end

  # Post.update_picture_versions!
  self.define_singleton_method "update_#{upload_name}_versions!" do
    Uploadbox.const_get(upload_class_name).find_each{|upload| upload.file.recreate_versions!}
  end

  # Uploadbox::PostPicture < Image
  upload_class.define_singleton_method :versions do
    upload_versions
  end

  upload_class.define_singleton_method :removable? do
    options[:removable]
  end

  upload_class.instance_eval do
    delegate *upload_versions.keys, to: :file

    default_scope -> { where(imageable_type: imageable_type).where(upload_name: upload_name.to_s) }

    # Uploabox::PostPictureUploader < UploadBox::ImgProcessing < CarrierWave
    dynamic_uploader = Class.new(Uploadbox::ImageProcessingUploader)
    Uploadbox.const_set(self.name.demodulize + 'Uploader', dynamic_uploader)
    dynamic_uploader.class_eval do
      upload_versions.each do |version_name, dimensions|
        if options[:retina]
          dimensions = dimensions.map{ |d| d * 2 }
        end

        version version_name do
          process resize_to_fill: dimensions
          process quality: quality = options[:quality]
        end

        def dimensions
          model.class.versions[version_name]
        end

        def width
          dimensions[0]
        end

        def height
          dimensions[1]
        end
      end
    end
    mount_uploader :file, dynamic_uploader
  end

  has_one upload_name, as: :imageable, dependent: :destroy, class_name: "Uploadbox::#{self.to_s + upload_name.to_s.camelize}"
end