carrierwave-meta 0.0.4 → 0.0.5

data/lib/carrierwave-meta/model_delegate_attribute.rb

@@ -1,7 +1,7 @@
 module CarrierWave
   module ModelDelegateAttribute
     extend ::ActiveSupport::Concern
-    
+
     module ClassMethods
       def model_delegate_attribute(attribute, default = nil)
         attr_accessor attribute
@@ -10,29 +10,39 @@ module CarrierWave
 
         var_name = :"@#{attribute}"
 
+        define_getter(attribute, var_name, default)
+        define_setter(attribute, var_name, default)
+        define_reset(attribute, default)
+      end
+
+      private
+      def define_getter(attribute, var_name, default)
         define_method :"#{attribute}" do
           model_accessor = model_getter_name(attribute)
           value = instance_variable_get(var_name)
-          value ||= self.model.send(model_accessor) if self.model.present? && self.model.respond_to?(model_accessor)
+          value ||= model.send(model_accessor) if model.present? && model.respond_to?(model_accessor)
           value ||= default
           instance_variable_set(var_name, value)
         end
+      end
 
+      def define_setter(attribute, var_name, default)
         define_method :"#{attribute}=" do |value|
           model_accessor = model_getter_name(attribute)
           instance_variable_set(var_name, value)
-          if self.model.present? && self.model.respond_to?(:"#{model_accessor}=") && !self.model.destroyed?
-            self.model.send(:"#{model_accessor}=", value) 
+          if model.present? && model.respond_to?(:"#{model_accessor}=") && !model.destroyed?
+            model.send(:"#{model_accessor}=", value)
           end
         end
+      end
 
+      def define_reset(attribute, default)
         define_method :"reset_#{attribute}" do
-          self.send(:"#{attribute}=", default)
           send(:"#{attribute}=", default)
         end
       end
     end
-    
+
     private
     def model_getter_name(attribute)
       name = []

data/lib/carrierwave-meta/version.rb

@@ -1,5 +1,5 @@
 module Carrierwave
   module Meta
-    VERSION = "0.0.4"
+    VERSION = "0.0.5"
   end
 end

data/spec/modules/active_record_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe CarrierWave::Meta::ActiveRecord do
+  let(:model) { TestComposedModel.new }
+  let(:model_with_image) do
+    model.tap do |m|
+      m.image = File.open('spec/fixtures/big.jpg')
+      m.save!
+    end
+  end
+
+  it "model's virtual meta attributes must exists" do
+    subject::ALLOWED.each do |name|
+      model.should respond_to(:"image_#{name}")
+    end
+  end
+
+  it "must assign model's virtual attributes and save meta column" do
+    subject::ALLOWED.each do |name|
+      model_with_image.send(:"image_#{name}").should_not be_blank
+    end
+
+    model_with_image.image_version_width.should_not be_blank
+    model_with_image.image_version_height.should_not be_blank
+
+    model_with_image.reload
+
+    model_with_image.image_version_width.should_not be_blank
+    model_with_image.image_version_height.should_not be_blank
+  end
+end

data/spec/modules/meta_spec.rb

@@ -2,118 +2,150 @@ require 'spec_helper'
 require 'mime/types'
 
 describe TestUploader do
-  ORIGINAL_SIZE = [600, 277]
-  VERSION_SIZE = [200, 200]
-
-  let(:file) { File.open("spec/fixtures/big.jpg") }
-  let(:corrupted_file) { File.open("spec/fixtures/corrupted.bmp") }
-  let(:file_name) { File.basename(file.path) }
   let(:obj) { TestModel.new }
 
-  def uploader_values_are_correct(uploader)
-    uploader.width.should eq(ORIGINAL_SIZE[0])
-    uploader.height.should eq(ORIGINAL_SIZE[1])
-    uploader.image_size.should eq(ORIGINAL_SIZE)
-    uploader.content_type.should eq(MIME::Types.type_for(file_name).first.to_s)
-    uploader.file_size.should_not be_blank
-    uploader.image_size_s.should eq(ORIGINAL_SIZE.join('x'))
-
-    uploader.version.width.should eq(VERSION_SIZE[0])
-    uploader.version.height.should eq(VERSION_SIZE[1])
-    uploader.version.image_size.should eq(VERSION_SIZE)
-    uploader.version.content_type.should eq(MIME::Types.type_for(file_name).first.to_s)
-    uploader.version.file_size.should_not be_blank
-    uploader.version.image_size_s.should eq(VERSION_SIZE.join('x'))
+  IMAGE_FILE_NAME = "spec/fixtures/big.jpg"
+  EPS_FILE_NAME = "spec/fixtures/sample.eps"
+  PDF_FILE_NAME = "spec/fixtures/sample.pdf"
+
+  FORMATS = {
+    image: {
+      original_size: [600, 277],
+      version_size: [200, 200],
+      file: File.open(IMAGE_FILE_NAME),
+      file_name: File.basename(IMAGE_FILE_NAME),
+      corrupted_file: File.open("spec/fixtures/corrupted.bmp"),
+      mime_type: MIME::Types.type_for(IMAGE_FILE_NAME).first.to_s
+    },
+    eps: {
+      original_size: [464, 205],
+      version_size: [200, 200],
+      file: File.open(EPS_FILE_NAME),
+      corrupted_file: File.open("spec/fixtures/corrupted.eps"),
+      file_name: File.basename(EPS_FILE_NAME),
+      mime_type: MIME::Types.type_for(EPS_FILE_NAME).first.to_s
+    },
+    pdf: {
+      original_size: [360, 360],
+      version_size: [200, 200],
+      file: File.open(PDF_FILE_NAME),
+      corrupted_file: File.open("spec/fixtures/corrupted.pdf"),
+      file_name: File.basename(PDF_FILE_NAME),
+      mime_type: MIME::Types.type_for(PDF_FILE_NAME).first.to_s
+    }
+  }
+
+  def obj_values_eq(obj, size_arg, args, prefix = nil)
+    size = args[size_arg]
+
+    obj.send(obj_value_name(:width, prefix)).should eq(size.first)
+    obj.send(obj_value_name(:height, prefix)).should eq(size.last)
+    obj.send(obj_value_name(:image_size, prefix)).should eq(size)
+    obj.send(obj_value_name(:content_type, prefix)).should eq(args[:mime_type])
+    obj.send(obj_value_name(:file_size, prefix)).should_not be_blank
+
+    if obj.is_a?(CarrierWave::Uploader::Base)
+      obj.send(obj_value_name(:image_size_s, prefix)).should eq(size.join('x'))
+    end
   end
 
-  def obj_values_are_correct(obj)
-    obj.image_width.should eq(ORIGINAL_SIZE[0])
-    obj.image_height.should eq(ORIGINAL_SIZE[1])
-    obj.image_image_size.should eq(ORIGINAL_SIZE)
-    obj.image_content_type.should eq(MIME::Types.type_for(file_name).first.to_s)
-    obj.image_file_size.should_not be_blank
-
-    obj.image_version_width.should eq(VERSION_SIZE[0])
-    obj.image_version_height.should eq(VERSION_SIZE[1])
-    obj.image_version_image_size.should eq(VERSION_SIZE)
-    obj.image_version_content_type.should eq(MIME::Types.type_for(file_name).first.to_s)
-    obj.image_version_file_size.should_not be_blank
+  def obj_value_name(name, prefix)
+    [prefix, name].compact.join('_')
   end
 
-  context "detached uploader" do
-    it "stores metadata after cache!" do
-      uploader = TestUploader.new
-      uploader.cache!(file)
-      uploader_values_are_correct(uploader)
-    end
-
-    it "stores metadata after store!" do
-      uploader = TestUploader.new
-      uploader.store!(file)
-      uploader_values_are_correct(uploader)
-    end
-
-    it "has metadata after cache!/retrieve_from_cache!" do
-      uploader = TestUploader.new
-      uploader.cache!(file)
-      cache_name = uploader.cache_name
-
-      uploader = TestUploader.new
-      uploader.retrieve_from_cache!(cache_name)
-      uploader_values_are_correct(uploader)
-    end
-
-    it "has metadata after store!/retrieve_from_store!" do
-      uploader = TestUploader.new
-      uploader.store!(file)
-      uploader_values_are_correct(uploader)
-
-      uploader = TestUploader.new
-      uploader.retrieve_from_store!(File.basename(file.path))
-      uploader_values_are_correct(uploader)
-    end
+  def uploader_values_eq(uploader, args)
+    obj_values_eq(uploader, :original_size, args)
+    obj_values_eq(uploader.version, :version_size, args)
+    uploader.md5sum.should_not be_blank
+    uploader.version.md5sum.should be_blank
   end
 
-  context "attached uploader" do
-    it "stores metadata after cache!" do
-      uploader = TestUploader.new(obj, :image)
-      uploader.cache!(file)
-      uploader_values_are_correct(uploader)
-      obj_values_are_correct(obj)
-    end
-
-    it "stores metadata after store!" do
-      uploader = TestUploader.new(obj, :image)
-      uploader.store!(file)
-      uploader_values_are_correct(uploader)
-      obj_values_are_correct(obj)
-    end
-
-    it "has metadata after cache!/retrieve_from_cache!" do
-      uploader = TestUploader.new(obj, :image)
-      uploader.cache!(file)
-      cache_name = uploader.cache_name
+  def model_values_eq(model, args)
+    obj_values_eq(model, :original_size, args, 'image')
+    obj_values_eq(model, :version_size, args, 'image_version')
+    model.image_md5sum.should_not be_blank
+  end
 
-      uploader = TestUploader.new(obj, :image)
-      uploader.retrieve_from_cache!(cache_name)
-      uploader_values_are_correct(uploader)
+  FORMATS.each do |format, args|
+    next if not(CarrierWave::Meta.ghostscript_enabled) and [:pdf, :eps].include?(format)
+    context "detached uploader for #{format}" do
+      it "stores metadata after cache!" do
+        uploader = TestUploader.new
+        uploader.cache!(args[:file])
+        uploader_values_eq(uploader, args)
+      end
+
+      it "stores metadata after store!" do
+        uploader = TestUploader.new
+        uploader.store!(args[:file])
+        uploader_values_eq(uploader, args)
+      end
+
+      it "has metadata after cache!/retrieve_from_cache!" do
+        uploader = TestUploader.new
+        uploader.cache!(args[:file])
+        cache_name = uploader.cache_name
+        uploader = TestUploader.new
+        uploader.retrieve_from_cache!(cache_name)
+
+        uploader_values_eq(uploader, args)
+      end
+
+      it "has metadata after store!/retrieve_from_store!" do
+        uploader = TestUploader.new
+        uploader.store!(args[:file])
+        uploader_values_eq(uploader, args)
+
+        uploader = TestUploader.new
+        uploader.retrieve_from_store!(args[:file_name])
+        uploader_values_eq(uploader, args)
+      end
     end
 
-    it "has metadata after store!/retrieve_from_store!" do
-      uploader = TestUploader.new(obj, :image)
-      uploader.store!(file)
-      uploader_values_are_correct(uploader)
-
-      uploader = TestUploader.new(obj, :image)
-      uploader.retrieve_from_store!(File.basename(file.path))
-      uploader_values_are_correct(uploader)
+    context "attached uploader for #{format}" do
+      it "stores metadata after cache!" do
+        uploader = TestUploader.new(obj, :image)
+        uploader.cache!(args[:file])
+        uploader_values_eq(uploader, args)
+        model_values_eq(obj, args)
+      end
+
+      it "stores metadata after store!" do
+        uploader = TestUploader.new(obj, :image)
+        uploader.store!(args[:file])
+        uploader_values_eq(uploader, args)
+        model_values_eq(obj, args)
+      end
+
+      it "has metadata after cache!/retrieve_from_cache!" do
+        uploader = TestUploader.new(obj, :image)
+        uploader.cache!(args[:file])
+        cache_name = uploader.cache_name
+
+        uploader = TestUploader.new(obj, :image)
+        uploader.retrieve_from_cache!(cache_name)
+        uploader_values_eq(uploader, args)
+        model_values_eq(obj, args)
+      end
+
+      it "has metadata after store!/retrieve_from_store!" do
+        uploader = TestUploader.new(obj, :image)
+        uploader.store!(args[:file])
+        uploader_values_eq(uploader, args)
+        model_values_eq(obj, args)
+
+        uploader = TestUploader.new(obj, :image)
+        uploader.retrieve_from_store!(args[:file_name])
+        uploader_values_eq(uploader, args)
+        model_values_eq(obj, args)
+      end
     end
-  end
 
-  context "when file is corrupted/can not be processed" do
-    it "passes without exceptions" do
-      uploader = TestBlankUploader.new(obj, :image)
-      proc { uploader.store!(corrupted_file) }.should_not raise_error
+    context "when file is corrupted/can not be processed" do
+      it "passes without exceptions" do
+        uploader = TestBlankUploader.new(obj, :image)
+        proc { uploader.store!(args[:corrupted_file]) }.should_not raise_error
+      end
     end
   end
 end

data/spec/modules/model_delegate_attribute_spec.rb

@@ -2,35 +2,35 @@ require 'spec_helper'
 
 describe TestDelegateUploader do
   let(:values) { subject.class::VALUES }
-  let(:default_values) { subject.class::DEFAULT_VALUES }  
+  let(:default_values) { subject.class::DEFAULT_VALUES }
   let(:file) { File.open("spec/fixtures/big.jpg") }
   let(:obj) { TestModel.new }
-  
+
   before do
     obj.destroyed = false
   end
 
   def uploader_values_are_correct(uploader)
     uploader.x.should eq(values[:x])
-    uploader.dimensions.should eq(values[:dimensions])    
+    uploader.dimensions.should eq(values[:dimensions])
     uploader.version.x.should eq(values[:version_x])
-    uploader.version.dimensions.should eq(values[:version_dimensions])    
+    uploader.version.dimensions.should eq(values[:version_dimensions])
   end
 
   def obj_values_are_correct(obj)
     obj.image_x.should eq(values[:x])
-    obj.image_dimensions.should eq(values[:dimensions])    
+    obj.image_dimensions.should eq(values[:dimensions])
     obj.image_version_x.should eq(values[:version_x])
-    obj.image_version_dimensions.should eq(values[:version_dimensions])      
+    obj.image_version_dimensions.should eq(values[:version_dimensions])
   end
 
   def uploader_values_are_default(obj)
     obj.x.should eq(default_values[:x])
-    obj.dimensions.should eq(default_values[:dimensions])    
+    obj.dimensions.should eq(default_values[:dimensions])
     obj.version.x.should eq(default_values[:x])
-    obj.version.dimensions.should eq(default_values[:dimensions])      
+    obj.version.dimensions.should eq(default_values[:dimensions])
   end
-  
+
   it "model receives values after process done" do
     uploader = TestDelegateUploader.new(obj, :image)
     uploader.cache!(file)
@@ -38,15 +38,15 @@ describe TestDelegateUploader do
     uploader_values_are_correct(uploader)
     obj_values_are_correct(obj)
   end
-  
+
   it "resets values to default after file is removed" do
     uploader = TestDelegateUploader.new(obj, :image)
     uploader.store!(file)
 
     uploader_values_are_correct(uploader)
 
-    # CarrierWave's file is removed in after_destroy callback. Model attributes are freezed after destroy. 
-    # Let mock this case.
+    # CarrierWave's file is removed in after_destroy callback.
+    # Model attributes are freezed after destroy. Let mock this case.
     obj.image_x.freeze
     obj.destroyed = true
     uploader.remove!
@@ -54,7 +54,7 @@ describe TestDelegateUploader do
     uploader_values_are_default(uploader)
     obj_values_are_correct(obj)
   end
-  
+
   it "tries to receive value from a model when file was not processed at this time" do
     uploader = TestDelegateUploader.new(obj, :image)
     uploader.store!(file)

data/spec/spec_helper.rb

@@ -1,23 +1,34 @@
 $LOAD_PATH << "." unless $LOAD_PATH.include?(".")
 
-begin
-  require "bundler"
-  Bundler.setup
-  Bundler.require
-rescue Bundler::GemNotFound
-  raise RuntimeError, "Bundler couldn't find some gems." +
-    "Did you run `bundle install`?"
-end
-
-PROCESSOR = (ENV["PROCESSOR"] || :rmagick).to_sym
-
+require 'rubygems'
+require 'bundler/setup'
+require 'simplecov'
 require 'mime/types'
 require 'carrierwave'
+require 'carrierwave/orm/activerecord'
+require 'support/remote'
+require 'support/current_processor'
+require 'active_record'
+require 'support/schema'
+
+SimpleCov.start
+
 require 'carrierwave-meta'
+
+PROCESSOR = (ENV["PROCESSOR"] || :rmagick).to_sym
+puts "Using #{PROCESSOR} processor"
+
+PDF_EPS = ENV['PDF_EPS']
+unless PDF_EPS == 'false' or [:vips, :image_sorcery].include?(PROCESSOR)
+  CarrierWave::Meta.ghostscript_enabled = true
+end
+
 require 'support/test_delegate_uploader'
 require 'support/test_blank_uploader'
 require 'support/test_uploader'
 require 'support/test_model'
+require 'support/test_composed_model'
+require 'fog'
 
 RSpec.configure do |config|
   config.before do