gluttonberg-core 2.5.5 → 2.5.6

data/lib/gluttonberg/library/attachment_mixin.rb

@@ -6,35 +6,38 @@ module Gluttonberg
     # Asset class for each major category of assets e.g. ImageAsset,
     # DocumentAsset.
 
-    require "mp3info"
-
     module AttachmentMixin
 
-      # Default sizes used when thumbnailing an image.
-      DEFAULT_THUMBNAILS = {
-        :small_thumb => {:label => "Small Thumb", :filename => "_thumb_small", :geometry => "360x268#" },
-        :large_thumb => {:label => "Large Thumb", :filename => "_thumb_large", :geometry => "360x268>"},
-        :backend_logo => {:label => "Backend Logo", :filename => "_backend_logo", :geometry => "1000x30"}
-      }
-
-      # The default max image size. This can be overwritten on a per project
-      # basis via the rails configuration.
-      MAX_IMAGE_SIZE = "2000x2000>" #Resize image to have specified area in pixels. Aspect ratio is preserved.
-
       def self.included(klass)
         klass.class_eval do
-
-          after_destroy  :remove_file_from_disk
+          after_destroy  :remove_file_from_storage
           before_save    :generate_reference_hash
+          after_save     :update_file_on_storage
+          attr_accessor  :file_dirty
 
           extend ClassMethods
           include InstanceMethods
+          extend Library::Config::ImageSizes::ClassMethods
+          include Library::Config::ImageSizes::InstanceMethods
 
+          initialize_storage()
         end
       end
 
+
       module ClassMethods
 
+        def initialize_storage
+          storage_class_name = Rails.configuration.asset_storage.to_s.downcase.camelize
+          begin
+            storage_module = Gluttonberg::Library::Storage.const_get(storage_class_name)
+          rescue NameError
+            raise Exception, "Cannot load storage module '#{storage_class_name}'"
+          end
+          include(storage_module.const_get("InstanceMethods"))
+          extend(storage_module.const_get("ClassMethods"))
+        end
+
 
         # Generate auto titles for those assets without name
         def generate_name
@@ -47,24 +50,6 @@ module Gluttonberg
           'done' # this just makes the output nicer when running from slice -i
         end
 
-        # Returns a collection of thumbnail definitions — sizes, filename etc. —
-        # which is a merge of defaults and any custom thumbnails defined by the
-        # user.
-        def sizes
-          @thumbnail_sizes ||= if Rails.configuration.thumbnails
-            Rails.configuration.thumbnails.merge(DEFAULT_THUMBNAILS)
-          else
-            DEFAULT_THUMBNAILS
-          end
-        end
-
-        # Returns the max image size as a hash containing :width and :height.
-        # May be the default, or the value configured for a particular project.
-        def max_image_size
-          Rails.configuration.max_image_size || MAX_IMAGE_SIZE
-        end
-
-
       end #ClassMethods
 
 
@@ -86,11 +71,11 @@ module Gluttonberg
               clean_filename = 'thumb.#{file_extension}'
             end
 
-
             self.mime_type = new_file.content_type
             self.file_name = clean_filename
             self.size = new_file.size
             @file = new_file
+            self.file_dirty = true
           end
         end
 
@@ -103,34 +88,18 @@ module Gluttonberg
           file_name.split(".").last
         end
 
-        # Returns the public URL to this asset, relative to the domain.
-        def url
-          "/user_assets/#{asset_hash}/#{file_name}"
-        end
-
         def asset_folder_path
-          "/user_assets/#{asset_hash}"
+          # "/user_assets/#{asset_hash}"
+          directory
         end
 
-        # Returns the URL for the specified image size.
-
-        def url_for(name)
-          if self.class.sizes.has_key? name
-            filename = self.class.sizes[name][:filename]
-            "/user_assets/#{asset_hash}/#{filename}.#{file_extension}"
-          end
+        def asset_directory_public_url
+          "#{assets_directory_public_url}/#{asset_hash}"
         end
 
-        # Returns the public URL to the asset’s small thumbnail — relative
-        # to the domain.
-        def thumb_small_url
-          url_for(:small_thumb) if category.downcase == "image"
-        end
-
-        # Returns the public URL to the asset’s large thumbnail — relative
-        # to the domain.
-        def thumb_large_url
-          url_for(:large_thumb) if category.downcase == "image"
+        # Returns the public URL to this asset, relative to the domain.
+        def url
+          "#{asset_directory_public_url}/#{file_name}"
         end
 
         # Returns the full path to the file’s location on disk.
@@ -138,242 +107,56 @@ module Gluttonberg
           directory + "/" + file_name
         end
 
-        # In the case where an uploaded image has been larger that the
-        # specified max-size and consequently resized, this method will provide
-        # the path to the original, un-altered file.
+        # asset  path in actual assets directory
         def original_file_on_disk
           directory + "/original_" + file_name
         end
 
-        # The generated directory where this file is located. If it is an image
-        # it’s thumbnails will be stored here as well.
-        def directory
-          Library.setup
-          Library.root + "/" + self.asset_hash
+        # Returns the full path to the file's location on disk in tmp directory.
+        def tmp_location_on_disk
+          tmp_directory + "/" + file_name
         end
 
-        def suggested_measures(object , required_geometry)
-            required_geometry = required_geometry.delete("#")
-            required_geometry_tokens = required_geometry.split("x")
-            actual_width = object.width.to_i
-            actual_height = object.height.to_i
-            required_width = required_geometry_tokens.first.to_i
-            required_height = required_geometry_tokens.last.to_i
-
-            ratio_required = required_width.to_f / required_height
-            ratio_actual = actual_width.to_f / actual_height
-
-            crossover_ratio = required_height.to_f / actual_height
-            crossover_ratio2 = required_width.to_f / actual_width
-
-            if(crossover_ratio < crossover_ratio2 )
-              crossover_ratio = crossover_ratio2
-            end
-
-            projected_height = actual_height * crossover_ratio
-
-            if(projected_height < required_height )
-              required_width = required_width * (1 + (ratio_actual -  ratio_required ) )
-            end
-      			projected_width = actual_width * crossover_ratio
-
-            "#{(projected_width).ceil}x#{(projected_width/ratio_actual).ceil}"
-         end
-
-        def generate_cropped_image(x , y , w , h, image_type)
-
-          asset_thumb = self.asset_thumbnails.find(:first , :conditions => {:thumbnail_type => image_type.to_s })
-          if asset_thumb.blank?
-            asset_thumb = self.asset_thumbnails.create({:thumbnail_type => image_type.to_s , :user_generated => true })
-          else
-            asset_thumb.update_attributes(:user_generated => true)
-          end
-
-          path = original_file_on_disk
-          original_ext = original_file_on_disk.split(".").last
-          path = File.join(directory, "#{self.class.sizes[image_type.to_sym][:filename]}.#{file_extension}") unless image_type.blank?
-          begin
-            image = QuickMagick::Image.read(original_file_on_disk).first
-          rescue
-            image = QuickMagick::Image.read(original_file_on_disk).first
-          end
-          begin
-            thumb_defined_width = self.class.sizes[image_type.to_sym][:geometry].split('x').first#.to_i
-            scaling_percent = (thumb_defined_width.to_i/(w.to_i*1.0))*100
-            image.arguments << " -crop #{w}x#{h}+#{x}+#{y} +repage"
-            if scaling_percent != 1.0
-              image.arguments << " -resize #{scaling_percent}%"
-            end
-          rescue => e
-            puts e
-          end
-          image.save path
+        # asset full path in tmp directory
+        def tmp_original_file_on_disk
+          tmp_directory + "/original_" + file_name
         end
 
-        # Create thumbnailed versions of image attachements.
-        # TODO: generate thumbnails with the correct extension
-        def generate_image_thumb
-
-          begin
-
-            self.class.sizes.each_pair do |name, config|
-
-              asset_thumb = self.asset_thumbnails.find(:first , :conditions => {:thumbnail_type => name.to_s, :user_generated => true })
-
-              if asset_thumb.blank?
-                  #image = QuickMagick::Image.read(location_on_disk).first
-                  begin
-                    image = QuickMagick::Image.read(original_file_on_disk).first
-                  rescue
-                    image = QuickMagick::Image.read(location_on_disk).first
-                  end
-
-                  original_ext = original_file_on_disk.split(".").last
-
-                  path = File.join(directory, "#{config[:filename]}.#{file_extension}")
-                  if config[:geometry].include?("#")
-                    #todo
-                    begin
-                      image.resize suggested_measures(image, config[:geometry])
-                      image.arguments << " -gravity Center  -crop #{config[:geometry].delete("#")}+0+0 +repage"
-                    rescue => e
-                      puts e
-                    end
-                  else
-                    image.resize config[:geometry]
-                  end
-                  image.save path
-              end
-            end
 
-            update_attribute( :custom_thumbnail , true)
-          rescue => e
-            update_attribute( :custom_thumbnail , false)
+        def generate_cropped_image(x , y , w , h, image_type)
+          if !File.exist?(self.tmp_location_on_disk) && !File.exist?(self.tmp_original_file_on_disk)
+            self.download_asset_to_tmp_file
           end
-
+          processor = Library::Processor::Image.new
+          processor.asset = self
+          processor.generate_cropped_image(x , y , w , h, image_type)
+          self.remove_file_from_tmp_storage
         end
 
-        def generate_proper_resolution
-
-            begin
-              make_backup
-              begin
-                image = QuickMagick::Image.read(original_file_on_disk).first
-              rescue => e
-                image = QuickMagick::Image.read(location_on_disk).first
-              end
-
-              actual_width = image.width.to_i
-              actual_height = image.height.to_i
-
-              update_attributes( :width => actual_width ,:height => actual_height)
-
-              image.resize self.class.max_image_size
-              image.save File.join(directory, file_name)
-              # remove mp3 info if any image have. it may happen in the case of updating asset from mp3 to image
-                audio = AudioAssetAttribute.find( :first , :conditions => {:asset_id => asset.id})
-                audio.destroy
-            rescue #TypeError => error
-              # ignore TypeErrors, just means it wasn't a supported image
-              update_attribute( :custom_thumbnail , false)
-            end
-        end
-
-
-        # Generates thumbnails for images, but also additionally checks to see
-        #TODO if the uploaded image exceeds the specified maximum, in which case it will resize it down.
-        def generate_thumb_and_proper_resolution(asset)
-              asset.generate_proper_resolution
-              asset.generate_image_thumb
-        end
-
-
-        #TODO Collect mp3 files info using Mp3Info gem
-        def collect_mp3_info(asset)
-          audio = AudioAssetAttribute.find( :first , :conditions => {:asset_id => asset.id})
-
-          begin
-              #open mp3 file
-              Mp3Info.open(location_on_disk) do |mp3|
-                if audio.blank?
-                  #, :genre => mp3.genre
-                  AudioAssetAttribute.create( :asset_id => asset.id , :length => mp3.length , :title => mp3.tag.title , :artist => mp3.tag.artist , :album => mp3.tag.album , :tracknum => mp3.tag.tracknum)
-                else
-                  audio.update_attributes( {:length => mp3.length, :genre =>"" , :title => mp3.tag.title , :artist => mp3.tag.artist , :album => mp3.tag.album , :tracknum => mp3.tag.tracknum })
-                end
-
-              end
-              if Gluttonberg::Setting.get_setting("audio_assets") == "Enable"
-                Delayed::Job.enqueue AudioJob.new(asset.id)
-              end
-          rescue => detail
-            # if exception occurs and asset has some attributes, then remove them.
-            unless audio.blank?
-              audio.update_attributes( {:length => nil , :title => nil , :artist => nil , :album => nil , :tracknum => nil })
-            end
-          end
-
-        end
 
         def asset_processing
           asset_id_to_process = self.id
           asset = Asset.find(:first , :conditions => { :id => asset_id_to_process } )
           if asset
-              #if it is an image, then create a thumbnail
-              if asset.asset_type.asset_category.name == "image"
-
-                generate_thumb_and_proper_resolution(asset)
-              elsif asset.asset_type.asset_category.name == "audio"
-                # If its mp3 file, collect its sound info
-                puts "==========step1 - audio"
-                collect_mp3_info(asset)
-                puts "==========step last - audio"
-              end
-              #additional processing
-              asset_processors = Rails.configuration.asset_processors
-              unless asset_processors.blank?
-                asset_processors.each do |processor|
-                  processor.process(asset)
-                end
+            asset_processors = [Library::Processor::Image , Library::Processor::Audio] #Core processors
+            asset_processors << Rails.configuration.asset_processors unless Rails.configuration.asset_processors.blank? #additional processors
+            asset_processors = asset_processors.flatten
+            unless asset_processors.blank?
+              asset_processors.each do |processor|
+                processor.process(asset)
               end
-
+            end
           end
-
-        end
+        end # asset_processing
 
 
         private
 
-        def make_backup
-          unless File.exist?(original_file_on_disk)
-            FileUtils.cp location_on_disk, original_file_on_disk
-            FileUtils.chmod(0755,original_file_on_disk)
-          end
-        end
-
-
-        def remove_file_from_disk
-          if File.exists?(directory)
-            FileUtils.rm_r(directory)
-          end
-        end
-
-        def update_file_on_disk
-          if file
-            FileUtils.mkdir(directory) unless File.exists?(directory)
-            FileUtils.cp file.tempfile.path, location_on_disk
-            FileUtils.chmod(0755, location_on_disk)
-
-            #  new file has been upload, if its image generate thumbnails, if mp3 collect sound info.
-            asset_processing
-          end
-        end
-
-        def generate_reference_hash
-          unless self.asset_hash
-            self.asset_hash = Digest::SHA1.hexdigest(Time.now.to_s + file_name)
+          def generate_reference_hash
+            unless self.asset_hash
+              self.asset_hash = Digest::SHA1.hexdigest(Time.now.to_s + file_name)
+            end
           end
-        end
       end
     end # AttachmentMixin
   end #Library

data/lib/gluttonberg/library/config/image_sizes.rb

@@ -0,0 +1,61 @@
+module Gluttonberg
+  module Library
+    module Config
+      module ImageSizes
+
+        # Default sizes used when thumbnailing an image.
+        DEFAULT_THUMBNAILS = {
+          :small_thumb => {:label => "Small Thumb", :filename => "_thumb_small", :geometry => "360x268#" },
+          :large_thumb => {:label => "Large Thumb", :filename => "_thumb_large", :geometry => "360x268>"},
+          :backend_logo => {:label => "Backend Logo", :filename => "_backend_logo", :geometry => "1000x30"}
+        }
+
+        # The default max image size. This can be overwritten on a per project
+        # basis via the rails configuration.
+        MAX_IMAGE_SIZE = "2000x2000>" #Resize image to have specified area in pixels. Aspect ratio is preserved.
+
+        module ClassMethods
+          # Returns a collection of thumbnail definitions — sizes, filename etc. —
+          # which is a merge of defaults and any custom thumbnails defined by the
+          # user.
+          def sizes
+            @thumbnail_sizes ||= if Rails.configuration.thumbnails
+              Rails.configuration.thumbnails.merge(DEFAULT_THUMBNAILS)
+            else
+              DEFAULT_THUMBNAILS
+            end
+          end
+
+          # Returns the max image size as a hash containing :width and :height.
+          # May be the default, or the value configured for a particular project.
+          def max_image_size
+            Rails.configuration.max_image_size || MAX_IMAGE_SIZE
+          end
+
+        end #ClassMethods
+
+        module InstanceMethods
+          # Returns the URL for the specified image size.
+          def url_for(name)
+            if self.class.sizes.has_key? name
+              filename = self.class.sizes[name][:filename]
+              "#{asset_directory_public_url}/#{filename}.#{file_extension}"
+            end
+          end
+
+          # Returns the public URL to the asset’s small thumbnail — relative
+          # to the domain.
+          def thumb_small_url
+            url_for(:small_thumb) if category.downcase == "image"
+          end
+
+          # Returns the public URL to the asset’s large thumbnail — relative
+          # to the domain.
+          def thumb_large_url
+            url_for(:large_thumb) if category.downcase == "image"
+          end
+        end #InstanceMethods
+      end
+    end
+  end
+end

data/lib/gluttonberg/library/config.rb

@@ -0,0 +1,10 @@
+library = Pathname(__FILE__).dirname.expand_path
+require File.join(library, "config", "image_sizes")
+
+
+module Gluttonberg
+  module Library
+    module Config
+    end
+  end
+end

data/lib/gluttonberg/library/processor/audio.rb

@@ -0,0 +1,42 @@
+module Gluttonberg
+  module Library
+    module Processor
+      require "mp3info"
+      class Audio
+        attr_accessor :asset
+
+        def self.process(asset_obj)
+          if asset_obj.asset_type.asset_category.name == "audio"
+            collect_mp3_info(asset)
+          end
+        end
+
+        # Collect mp3 files info using Mp3Info gem
+        def collect_mp3_info(asset)
+          audio = AudioAssetAttribute.find( :first , :conditions => {:asset_id => asset.id})
+
+          begin
+            #open mp3 file
+            Mp3Info.open(location_on_disk) do |mp3|
+              if audio.blank?
+                AudioAssetAttribute.create( :asset_id => asset.id , :length => mp3.length , :title => mp3.tag.title , :artist => mp3.tag.artist , :album => mp3.tag.album , :tracknum => mp3.tag.tracknum)
+              else
+                audio.update_attributes( {:length => mp3.length, :genre =>"" , :title => mp3.tag.title , :artist => mp3.tag.artist , :album => mp3.tag.album , :tracknum => mp3.tag.tracknum })
+              end
+            end
+            if Gluttonberg::Setting.get_setting("audio_assets") == "Enable"
+              Delayed::Job.enqueue AudioJob.new(asset.id)
+            end
+          rescue => detail
+            # if exception occurs and asset has some attributes, then remove them.
+            unless audio.blank?
+              audio.update_attributes( {:length => nil , :title => nil , :artist => nil , :album => nil , :tracknum => nil })
+            end
+          end
+
+        end #collect_mp3_info
+
+      end
+    end
+  end
+end

data/lib/gluttonberg/library/processor/image.rb

@@ -0,0 +1,134 @@
+module Gluttonberg
+  module Library
+    module Processor
+      class Image
+
+        attr_accessor :asset
+
+        def self.process(asset_obj)
+          if asset_obj.asset_type.asset_category.name == "image"
+            processor = self.new
+            processor.asset = asset_obj
+            processor.generate_thumb_and_proper_resolution
+          end
+        end
+
+        # Generates thumbnails for images, but also additionally checks to see
+        # if the uploaded image exceeds the specified maximum, in which case it will resize it down.
+        def generate_thumb_and_proper_resolution
+          generate_proper_resolution
+          generate_image_thumb
+        end
+
+        def suggested_measures(object , required_geometry)
+          required_geometry = required_geometry.delete("#")
+          required_geometry_tokens = required_geometry.split("x")
+          actual_width = object.width.to_i
+          actual_height = object.height.to_i
+          required_width = required_geometry_tokens.first.to_i
+          required_height = required_geometry_tokens.last.to_i
+
+          ratio_required = required_width.to_f / required_height
+          ratio_actual = actual_width.to_f / actual_height
+
+          crossover_ratio = required_height.to_f / actual_height
+          crossover_ratio2 = required_width.to_f / actual_width
+
+          if(crossover_ratio < crossover_ratio2 )
+            crossover_ratio = crossover_ratio2
+          end
+
+          projected_height = actual_height * crossover_ratio
+
+          if(projected_height < required_height )
+            required_width = required_width * (1 + (ratio_actual -  ratio_required ) )
+          end
+          projected_width = actual_width * crossover_ratio
+
+          "#{(projected_width).ceil}x#{(projected_width/ratio_actual).ceil}"
+        end
+
+        def generate_cropped_image(x , y , w , h, image_type)
+          asset_thumb = asset.asset_thumbnails.find(:first , :conditions => {:thumbnail_type => image_type.to_s })
+          if asset_thumb.blank?
+            asset_thumb = asset.asset_thumbnails.create({:thumbnail_type => image_type.to_s , :user_generated => true })
+          else
+            asset_thumb.update_attributes(:user_generated => true)
+          end
+
+          file_name = "#{asset.class.sizes[image_type.to_sym][:filename]}.#{asset.file_extension}"
+          begin
+            image = QuickMagick::Image.read(asset.tmp_original_file_on_disk).first
+          rescue
+            image = QuickMagick::Image.read(asset.tmp_original_file_on_disk).first
+          end
+          thumb_defined_width = asset.class.sizes[image_type.to_sym][:geometry].split('x').first#.to_i
+          scaling_percent = (thumb_defined_width.to_i/(w.to_i*1.0))*100
+          image.arguments << " -crop #{w}x#{h}+#{x}+#{y} +repage"
+          if scaling_percent != 1.0
+            image.arguments << " -resize #{scaling_percent}%"
+          end
+          image.save File.join(asset.tmp_directory, file_name)
+          asset.move_tmp_file_to_actual_directory(file_name , true)
+        end
+
+        # Create thumbnailed versions of image attachements.
+        # TODO: generate thumbnails with the correct extension
+        def generate_image_thumb
+          asset.class.sizes.each_pair do |name, config|
+            asset_thumb = asset.asset_thumbnails.find(:first , :conditions => {:thumbnail_type => name.to_s, :user_generated => true })
+            if asset_thumb.blank?
+              begin
+                image = QuickMagick::Image.read(asset.tmp_original_file_on_disk).first
+              rescue
+                image = QuickMagick::Image.read(asset.tmp_location_on_disk).first
+              end
+
+              file_name = "#{config[:filename]}.#{asset.file_extension}"
+
+              if config[:geometry].include?("#")
+                #todo
+                begin
+                  image.resize(suggested_measures(image, config[:geometry]))
+                  image.arguments << " -gravity Center  -crop #{config[:geometry].delete("#")}+0+0 +repage"
+                rescue => e
+                  puts e
+                end
+              else
+                image.resize config[:geometry]
+              end
+              image.save File.join(asset.tmp_directory, file_name)
+              asset.move_tmp_file_to_actual_directory(file_name, true)
+            end # asset_thumb.blank?
+          end # sizes loop
+
+          asset.update_attribute(:custom_thumbnail , true)
+        end
+
+        def generate_proper_resolution
+          asset.make_backup
+          begin
+            image = QuickMagick::Image.read(asset.tmp_original_file_on_disk).first
+          rescue => e
+            image = QuickMagick::Image.read(asset.tmp_location_on_disk).first
+          end
+
+          actual_width = image.width.to_i
+          actual_height = image.height.to_i
+
+          asset.update_attributes( :width => actual_width ,:height => actual_height)
+
+          image.resize asset.class.max_image_size
+          image.save File.join(asset.tmp_directory, asset.file_name)
+          asset.move_tmp_file_to_actual_directory(asset.file_name , true)
+          # remove mp3 info if any image have. it may happen in the case of updating asset from mp3 to image
+          audio = AudioAssetAttribute.find( :first , :conditions => {:asset_id => asset.id})
+          audio.destroy unless audio.blank?
+        end
+
+
+
+      end
+    end
+  end
+end

data/lib/gluttonberg/library/processor.rb

@@ -0,0 +1,11 @@
+library = Pathname(__FILE__).dirname.expand_path
+require File.join(library, "processor", "image")
+require File.join(library, "processor", "audio")
+
+
+module Gluttonberg
+  module Library
+    module Processor
+    end
+  end
+end