gluttonberg-core 2.6.4 → 3.0.0

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

@@ -1,7 +1,9 @@
 module Gluttonberg
   module Library
     module Config
+      # Mixin which provides image sizes functionality to asset model
       module ImageSizes
+        extend ActiveSupport::Concern
 
         # Default sizes used when thumbnailing an image.
         DEFAULT_THUMBNAILS = {
@@ -34,28 +36,29 @@ module Gluttonberg
 
         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
+        # InstanceMethods
+        # Returns the URL for the specified image size.
+        def url_for(name=nil)
+          if name.blank?
+            url
+          elsif self.class.sizes.has_key? name
+            filename = self.class.sizes[name.to_sym][: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 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
+        # 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
     end
   end
-end
+end

data/lib/gluttonberg/library/default_asset_types.rb

@@ -0,0 +1,104 @@
+module Gluttonberg
+  module Library
+    module DefaultAssetTypes
+      def self.build
+        self.build_unknown_types
+        self.build_image_types
+        self.build_audio_types
+        self.build_video_types
+        self.build_document_types
+      end
+
+      # Makes sure the specified type exists in the DB, if it doesn’t it creates
+      # a new record.
+      def self.ensure_type(name, mime_type, category)
+        asset_type = AssetType.where(:name => name).first
+        if asset_type then
+          asset_type.asset_category = category
+        else
+          asset_type = AssetType.new(:name => name, :asset_category => category)
+        end
+        mime_type.split(' ').each do |this_mime_type|
+          asset_mime_type = AssetMimeType.new(:mime_type => this_mime_type)
+          asset_type.asset_mime_types << asset_mime_type
+          asset_mime_type.save
+        end
+        asset_type.save
+      end
+
+      private
+        def self.build_unknown_types
+          ensure_type('Unknown Image', 'image', AssetCategory.image_category)
+          ensure_type('Unknown Video', 'video', AssetCategory.video_category)
+          ensure_type('Unknown Audio', 'audio', AssetCategory.audio_category)
+          ensure_type('Unknown File',   'multi-part model message unknown', AssetCategory.uncategorised_category)
+        end
+
+        def self.build_image_types
+          ensure_type('Jpeg Image', 'image/jpeg image/pjpeg', AssetCategory.image_category)
+          ensure_type('Gif Image', 'image/gif', AssetCategory.image_category)
+          ensure_type('Png Image', 'image/png', AssetCategory.image_category)
+          ensure_type('Tiff Image', 'image/tiff', AssetCategory.image_category)
+          ensure_type('Adobe Photoshop Image', 'image/vnd.adobe.photoshop', AssetCategory.image_category)
+          ensure_type('Autocad Image', 'image/vnd.dwg', AssetCategory.image_category)
+          ensure_type('Autocad Image', 'image/vnd.dxf', AssetCategory.image_category)
+          ensure_type('Icon Image', 'image/vnd.microsoft.icon', AssetCategory.image_category)
+          ensure_type('Bitmap Image', 'image/x-bmp image/bmp image/x-win-bmp', AssetCategory.image_category)
+          ensure_type('Paintshop Pro Image', 'image/x-paintshoppro', AssetCategory.image_category)
+          ensure_type('Mobile Image (plb,psb,pvb)', 'application/vnd.3gpp.pic-bw-large application/vnd.3gpp.pic-bw-small application/vnd.3gpp.pic-bw-var', AssetCategory.image_category)
+        end
+
+        def self.build_audio_types
+          ensure_type('Moile Audio (3gpp,3gpp2)', 'audio/3gpp audio/3gpp2', AssetCategory.audio_category)
+          ensure_type('Dolby Digital Audio (ac3)', 'audio/ac3', AssetCategory.audio_category)
+          ensure_type('Mpeg Audio (mpga,mp2,mp3,mp4,mpa)', 'audio/mpeg audio/mpeg4-generic audio/mp4 audio/mp3 audio/mpa-robust', AssetCategory.audio_category) # @mpga,mp2,mp3
+          ensure_type('Aiff Audio (aif,aifc,aiff)', 'audio/x-aiff', AssetCategory.audio_category)
+          ensure_type('Midi Audio (mid,midi,kar)', 'audio/x-midi', AssetCategory.audio_category)
+          ensure_type('Real Audio (rm,ram,ra)', 'audio/x-pn-realaudio audio/x-realaudio', AssetCategory.audio_category)
+          ensure_type('Wav Audio (wav)', 'audio/x-wav', AssetCategory.audio_category)
+          ensure_type('Ogg Vorbis Audio (ogg)', 'application/ogg', AssetCategory.audio_category)
+        end
+
+        def self.build_video_types
+          ensure_type('Mobile Video', 'video/3gpp video/3gpp-tt video/3gpp2', AssetCategory.video_category) #  @3gp,3gpp 'RFC3839,DRAFT:draft-gellens-mime-bucket
+          ensure_type('Digital Video', 'video/DV', AssetCategory.video_category) #  RFC3189
+          ensure_type('Compressed Video', 'application/mpeg4-iod-xmt application/mpeg4-iod application/mpeg4-generic video/mp4  application/mp4 video/MPV video/mpeg4-generic video/mpeg video/MP2T video/H261 video/H263 video/H263-1998 video/H263-2000 video/H264 video/MP1S video/MP2P', AssetCategory.video_category) #  RFC3555
+          ensure_type('Jpeg Video', 'video/JPEG video/MJ2', AssetCategory.video_category) #  RFC3555
+          ensure_type('Quicktime Video', 'video/quicktime', AssetCategory.video_category)
+          ensure_type('Uncompressed Video', 'video/raw', AssetCategory.video_category)
+          ensure_type('Mpeg Playlist (mxu,m4u)', 'video/vnd.mpegurl', AssetCategory.video_category)
+          ensure_type('Avi Video (avi)', 'video/x-msvideo', AssetCategory.video_category)
+          ensure_type('Flash Video', 'video/x-flv', AssetCategory.video_category)
+          ensure_type('M4v Video', 'video/x-m4v', AssetCategory.video_category)
+        end
+
+        def self.build_document_types
+          #document category
+          ensure_type('Generic Document', 'application/x-csh application/x-dvi application/oda application/pgp-encrypted application/pgp-keys application/pgp-signature', AssetCategory.document_category)
+          ensure_type('Calendar Document', 'text/calendar text/x-vcalendar', AssetCategory.document_category)
+          ensure_type('Comma Seperated Values Document (csv)', 'text/csv text/comma-separated-values', AssetCategory.document_category)
+          ensure_type('Tab Seperated Values Text Document', 'text/tab-separated-values', AssetCategory.document_category)
+          ensure_type('Web Document', 'text/html', AssetCategory.document_category)
+          ensure_type('Plain Text Document', 'text/plain', AssetCategory.document_category)
+          ensure_type('Rich Text Document', 'text/richtext text/rtf', AssetCategory.document_category)
+          ensure_type('Sgml Document', 'text/sgml', AssetCategory.document_category)
+          ensure_type('Wap Document', 'text/vnd.wap.wml text/vnd.wap.wmlscript', AssetCategory.document_category)
+          ensure_type('XML Document', 'text/xml text/xml-external-parsed-entity', AssetCategory.document_category)
+          ensure_type('V-Card Document (vcf)', 'text/x-vcard', AssetCategory.document_category)
+          ensure_type('Apple Macintosh Document (hqx)', 'application/mac-binhex40', AssetCategory.document_category)
+          ensure_type('Adobe Acrobat Document (pdf)', 'application/pdf', AssetCategory.document_category)
+          self.buid_microsoft_office_types
+        end
+
+        def self.buid_microsoft_office_types
+          ensure_type('Microsoft Word Document (doc,dot,docx)', 'application/msword application/word', AssetCategory.document_category)
+          ensure_type('Microsoft Powerpoint Document (ppt,pps,pot,pptx)', 'application/vnd.ms-powerpoint application/powerpoint', AssetCategory.document_category)
+          ensure_type('Microsoft Excel Document (xls,xlt,xlsx)', 'application/vnd.ms-excel application/excel', AssetCategory.document_category)
+          ensure_type('Microsoft Works Document', 'application/vnd.ms-works', AssetCategory.document_category)
+          ensure_type('Microsoft Project Document (mpp)', 'application/vnd.ms-project', AssetCategory.document_category)
+          ensure_type('Microsoft Visio Document (vsd,vst,vsw,vss)', 'application/vnd.visio', AssetCategory.document_category)
+          ensure_type('HTML Help Document (chm)', 'application/x-chm', AssetCategory.document_category)
+        end
+    end
+  end
+end

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

@@ -13,30 +13,46 @@ module Gluttonberg
 
         # Collect mp3 files info using Mp3Info gem
         def self.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)
+            Mp3Info.open(asset.location_on_disk) do |mp3|
+              self.update_audio_attributes(asset, mp3)
             end
+            self.enqueue_job(asset)
           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
+            # if exception occurs and asset has some attributes, 
+            # then remove them.
+            AudioAssetAttribute.where(:asset_id => asset.id).delete_all
           end
 
         end #collect_mp3_info
 
+        private
+          def self.enqueue_job(asset)
+            if Gluttonberg::Setting.get_setting("audio_assets") == "Enable"
+              AudioJob.perform_async(asset.id)
+            end
+          end
+
+          def self.update_audio_attributes(asset, mp3)
+            audio = asset.audio_asset_attribute
+            audio_attrs = {
+              :asset_id => asset.id, 
+              :length => mp3.length , 
+              :title => mp3.tag.title, 
+              :artist => mp3.tag.artist, 
+              :album => mp3.tag.album, 
+              :tracknum => mp3.tag.tracknum,
+              :genre =>""
+            }
+            if audio.blank?
+              AudioAssetAttribute.create(audio_attrs)
+            else
+              audio.update_attributes(audio_attrs)
+            end
+          end
+
       end
     end
   end
-end
+end

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

@@ -3,12 +3,13 @@ module Gluttonberg
     module Processor
       class Image
 
-        attr_accessor :asset
+        attr_accessor :asset, :replace_backup
 
-        def self.process(asset_obj)
+        def self.process(asset_obj, replace_backup=true)
           if asset_obj.asset_type.asset_category.name == "image"
             processor = self.new
             processor.asset = asset_obj
+            processor.replace_backup = replace_backup
             processor.generate_thumb_and_proper_resolution
           end
         end
@@ -16,13 +17,18 @@ module Gluttonberg
         # 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
+          begin
+            if File.exist?(asset.tmp_location_on_disk)
+              generate_proper_resolution
+              generate_image_thumbnails
+            end
+          rescue => e
+            puts e
+          end
         end
 
         def suggested_measures(object , required_geometry)
-          required_geometry = required_geometry.delete("#")
-          required_geometry_tokens = required_geometry.split("x")
+          required_geometry_tokens = required_geometry.delete("#").split("x")
           actual_width = object.width.to_i
           actual_height = object.height.to_i
           required_width = required_geometry_tokens.first.to_i
@@ -49,86 +55,89 @@ module Gluttonberg
         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)
+          asset_thumb = asset.asset_thumbnails.find_or_initialize_by_thumbnail_type(image_type.to_s)
+          asset_thumb.user_generated = true
+          asset_thumb.save
+          config = asset.class.sizes[image_type.to_sym]
+          file_name = "#{config[:filename]}.#{asset.file_extension}"
+          image = read_image_file(asset)
+          aurgments_str = _prepare_image_crop_arguments(x , y , w , h, config)
+          _resize_and_save(asset, image, nil, aurgments_str, file_name)
         end
 
         # Create thumbnailed versions of image attachements.
-        # TODO: generate thumbnails with the correct extension
-        def generate_image_thumb
+        def generate_image_thumbnails
           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 #{config[:grayscale] && config[:grayscale] == true ? "-colorspace Gray":""}"
-                rescue => e
-                  puts e
-                end
-              else
-                image.resize config[:geometry]
-                image.arguments << "-colorspace Gray" if config[:grayscale] && config[:grayscale] == true
-              end
-              image.save File.join(asset.tmp_directory, file_name)
-              asset.move_tmp_file_to_actual_directory(file_name, true)
-            end # asset_thumb.blank?
+            asset_thumb = asset.asset_thumbnails.where({
+              :thumbnail_type => name.to_s,
+              :user_generated => true
+            }).first
+            _generate_image_thumbnail(name, config) if 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
+          asset.make_backup(replace_backup)
+          image = read_image_file(asset)
+          asset.update_attributes( :width => image.width.to_i, :height => image.height.to_i)
+          _resize_and_save(asset, image, asset.class.max_image_size, nil, asset.file_name)
+          clean_audio_attributes_for_images(asset)
+        end
+
+        private
+          def _prepare_image_crop_arguments(x , y , w , h, config)
+            thumb_defined_width = config[:geometry].split('x').first
+            scaling_percent = (thumb_defined_width.to_i/(w.to_i*1.0))*100
+            aurgments_str = " -crop #{w}x#{h}+#{x}+#{y} +repage"
+            aurgments_str << " -resize #{scaling_percent}%" if scaling_percent != 1.0
+            aurgments_str
           end
 
-          actual_width = image.width.to_i
-          actual_height = image.height.to_i
+          def _generate_image_thumbnail(name, config)
+            image = read_image_file(asset)
+            file_name = "#{config[:filename]}.#{asset.file_extension}"
+            _resize_image_thumbnail(name, config, image, asset, file_name)
+          end
 
-          asset.update_attributes( :width => actual_width ,:height => actual_height)
+          def _resize_image_thumbnail(name, config, image, asset, file_name)
+            aurgments_str = (config[:grayscale] == true ?  "-colorspace Gray" : "" )
+            resize_str = config[:geometry]
 
-          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
+            aurgments_str << " -quality #{config[:quality]} " unless config[:quality].blank?
 
+            #fixed size thumbnail
+            if config[:geometry].include?("#")
+              resize_str = suggested_measures(image, config[:geometry])
+              aurgments_str << " -gravity Center  -crop #{config[:geometry].delete("#")}+0+0 +repage"
+            end
+            _resize_and_save(asset, image, resize_str, aurgments_str, file_name)
+          end
 
+          def read_image_file(asset)
+            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
+            image
+          end
 
+          def _resize_and_save(asset, image, resize_str, aurgments_str, file_name)
+            image.resize resize_str unless resize_str.blank?
+            image.arguments << aurgments_str unless aurgments_str.blank?
+            image.save File.join(asset.tmp_directory, file_name)
+            asset.move_tmp_file_to_actual_directory(file_name , true)
+          end
+
+          def clean_audio_attributes_for_images(asset)
+            # remove mp3 info if any image have.
+            # it may happen in the case of updating asset from mp3 to image
+            AudioAssetAttribute.where(:asset_id => asset.id).delete_all
+          end
       end
     end
   end

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

@@ -1,100 +1,70 @@
 require "tempfile"
+image = Pathname(__FILE__).dirname.expand_path
+require File.join(image, "image", "draw")
+require File.join(image, "image", "operators_and_settings")
+require File.join(image, "image", "serialization")
 
 module Gluttonberg
   module Library
-
     module QuickMagick
-  
       class Image
-        class << self
-      
-          # create an array of images from the given blob data
-          def from_blob(blob, &proc)
-            file = Tempfile.new(QuickMagick::random_string)
-            file.binmode
-            file.write(blob)
-            file.close
-            self.read(file.path, &proc)
-          end
-      
-          # create an array of images from the given file
-          def read(filename, &proc)
-            info = identify(%Q<"#{filename}">)
-            info_lines = info.split(/[\r\n]/)
-            images = []
-            info_lines.each_with_index do |info_line, i|
-              images << Image.new("#{filename}", i, info_line)
-            end
-            images.each(&proc) if block_given?
-            return images
-          end
-      
-          alias open read
-      
-          # Creates a new image initially set to gradient
-          # Default gradient is linear gradient from black to white
-          def gradient(width, height, type=QuickMagick::LinearGradient, color1=nil, color2=nil)
-            template_name = type + ":"
-            template_name << color1.to_s if color1
-            template_name << '-' << color2.to_s if color2
-            i = self.new(template_name, 0, nil, true)
-            i.size = QuickMagick::geometry(width, height)
-            yield(i) if block_given?
-            i
-          end
-      
-          # Creates an image with solid color
-          def solid(width, height, color=nil)
-            template_name = QuickMagick::SolidColor+":"
-            template_name << color.to_s if color
-            i = self.new(template_name, 0, nil, true)
-            i.size = QuickMagick::geometry(width, height)
-            yield(i) if block_given?
-            i
-          end
-      
-          # Creates an image from pattern
-          def pattern(width, height, pattern)
-            raise QuickMagick::QuickMagickError, "Invalid pattern '#{pattern.to_s}'" unless QuickMagick::Patterns.include?(pattern.to_s)
-            template_name = "pattern:#{pattern.to_s}"
-            i = self.new(template_name, 0, nil, true)
-            i.size = QuickMagick::geometry(width, height)
-            yield(i) if block_given?
-            i
-          end
+        include Draw
+        include OperatorsAndSettings
+        include Serialization
 
-          # returns info for an image using <code>identify</code> command
-          def identify(filename)
-            QuickMagick.exec3 "identify #{QuickMagick.c filename}"
-          end
+        # Creates a new image initially set to gradient
+        # Default gradient is linear gradient from black to white
+        def self.gradient(width, height, type=QuickMagick::LinearGradient, color1=nil, color2=nil)
+          template_name = type + ":"
+          template_name << color1.to_s if color1
+          template_name << '-' << color2.to_s if color2
+          i = self.new(template_name, 0, nil, true)
+          i.size = QuickMagick::geometry(width, height)
+          yield(i) if block_given?
+          i
+        end
+
+        # Creates an image with solid color
+        def self.solid(width, height, color=nil)
+          template_name = QuickMagick::SolidColor+":"
+          template_name << color.to_s if color
+          i = self.new(template_name, 0, nil, true)
+          i.size = QuickMagick::geometry(width, height)
+          yield(i) if block_given?
+          i
+        end
+
+        # Creates an image from pattern
+        def self.pattern(width, height, pattern)
+          raise QuickMagick::QuickMagickError, "Invalid pattern '#{pattern.to_s}'" unless QuickMagick::Patterns.include?(pattern.to_s)
+          template_name = "pattern:#{pattern.to_s}"
+          i = self.new(template_name, 0, nil, true)
+          i.size = QuickMagick::geometry(width, height)
+          yield(i) if block_given?
+          i
+        end
 
+        # returns info for an image using <code>identify</code> command
+        def self.identify(filename)
+          QuickMagick.exec3 "identify #{QuickMagick.c filename}"
         end
 
+        # ClassMethods
+
+        #instance methods
+
         # append the given option, value pair to the settings of the current image
         def append_to_settings(arg, value=nil)
           @arguments << "-#{arg} #{QuickMagick.c value} "
           @last_is_draw = false
           self
         end
-    
+
         # append the given string as is. Used to append special arguments like +antialias or +debug
         def append_basic(arg)
           @arguments << arg << ' '
         end
 
-        # Image settings supported by ImageMagick
-        IMAGE_SETTINGS_METHODS = %w{
-          adjoin affine alpha authenticate attenuate background bias black-point-compensation
-          blue-primary bordercolor caption channel colors colorspace comment compose compress define
-          delay depth display dispose dither encoding endian family fill filter font format fuzz gravity
-          green-primary intent interlace interpolate interword-spacing kerning label limit loop mask
-          mattecolor monitor orient ping pointsize preview quality quiet red-primary regard-warnings
-          remap respect-parentheses scene seed stretch stroke strokewidth style taint texture treedepth
-          transparent-color undercolor units verbose view virtual-pixel weight white-point
-
-          density page sampling-factor size tile-offset
-        }
-
         # append the given option, value pair to the args for the current image
         def append_to_operators(arg, value=nil)
           is_draw = (arg == 'draw')
@@ -106,7 +76,7 @@ module Gluttonberg
           @last_is_draw = is_draw
           self
         end
-    
+
         # Reverts this image to its last saved state.
         # Note that you cannot revert an image created from scratch.
         def revert!
@@ -114,91 +84,20 @@ module Gluttonberg
           @arguments = ""
         end
 
-        # Image operators supported by ImageMagick
-        IMAGE_OPERATORS_METHODS = %w{
-          alpha auto-orient bench black-threshold bordercolor charcoal clip clip-mask clip-path colorize
-          contrast convolve cycle decipher deskew despeckle distort edge encipher emboss enhance equalize
-          evaluate flip flop function gamma identify implode layers level level-colors median modulate monochrome
-          negate noise normalize opaque ordered-dither NxN paint polaroid posterize print profile quantize
-          radial-blur Raise random-threshold recolor render rotate segment sepia-tone set shade solarize
-          sparse-color spread strip swirl threshold tile tint transform transparent transpose transverse trim
-          type unique-colors white-threshold
-
-          adaptive-blur adaptive-resize adaptive-sharpen annotate blur border chop contrast-stretch extent
-          extract frame gaussian-blur geometry lat linear-stretch liquid-rescale motion-blur region repage
-          resample resize roll sample scale selective-blur shadow sharpen shave shear sigmoidal-contrast
-          sketch splice thumbnail unsharp vignette wave
-      
-          append average clut coalesce combine composite deconstruct flatten fx hald-clut morph mosaic process reverse separate write
-          crop
-          }
-
-        # methods that are called with (=)
-        WITH_EQUAL_METHODS =
-          %w{alpha background bias black-point-compensation blue-primary border bordercolor caption
-            cahnnel colors colorspace comment compose compress depth density encoding endian family fill filter
-            font format frame fuzz geometry gravity label mattecolor page pointsize quality stroke strokewidth
-            undercolor units weight
-            brodercolor transparent type size}
-
-        # methods that takes geometry options
-        WITH_GEOMETRY_METHODS =
-          %w{density page sampling-factor size tile-offset adaptive-blur adaptive-resize adaptive-sharpen
-            annotate blur border chop contrast-stretch extent extract frame gaussian-blur
-            geometry lat linear-stretch liquid-rescale motion-blur region repage resample resize roll
-            sample scale selective-blur shadow sharpen shave shear sigmoidal-contrast sketch
-            splice thumbnail unsharp vignette wave crop}
-   
-        # Methods that need special treatment. This array is used just to keep track of them.
-        SPECIAL_COMMANDS =
-          %w{floodfill antialias draw}
-
-        IMAGE_SETTINGS_METHODS.each do |method|
-          if WITH_EQUAL_METHODS.include?(method)
-            define_method((method+'=').to_sym) do |arg|
-              append_to_settings(method, arg)
-            end
-          elsif WITH_GEOMETRY_METHODS.include?(method)
-            define_method((method).to_sym) do |*args|
-              append_to_settings(method, QuickMagick::geometry(*args) )
-            end
-          else
-            define_method(method.to_sym) do |*args|
-              append_to_settings(method, args.join(" "))
-            end
-          end
-        end
-    
-        IMAGE_OPERATORS_METHODS.each do |method|
-          if WITH_EQUAL_METHODS.include?(method)
-            define_method((method+'=').to_sym) do |arg|
-              append_to_operators(method, arg )
-            end
-          elsif WITH_GEOMETRY_METHODS.include?(method)
-            define_method((method).to_sym) do |*args|
-              append_to_operators(method, QuickMagick::geometry(*args) )
-            end
-          else
-            define_method(method.to_sym) do |*args|
-              append_to_operators(method, args.join(" "))
-            end
-          end
-        end
-
         # Fills a rectangle with a solid color
         def floodfill(width, height=nil, x=nil, y=nil, flag=nil, color=nil)
           append_to_operators "floodfill", QuickMagick::geometry(width, height, x, y, flag), color
         end
-    
+
         # Enables/Disables flood fill. Pass a boolean argument.
         def antialias=(flag)
-        	append_basic flag ? '-antialias' : '+antialias'
+          append_basic flag ? '-antialias' : '+antialias'
         end
-    
+
         # define attribute readers (getters)
         attr_reader :image_filename
         alias original_filename image_filename
-    
+
         # constructor
         def initialize(filename, index=0, info_line=nil, pseudo_image=false)
           @image_filename = filename
@@ -206,22 +105,24 @@ module Gluttonberg
           @pseudo_image = pseudo_image
           if info_line
             @image_infoline = info_line.split
-            @image_infoline[0..1] = @image_infoline[0..1].join(' ') while @image_infoline.size > 1 && !@image_infoline[0].start_with?(image_filename)
+            process_info_line
+            #@image_infoline[0..1] = @image_infoline[0..1].join(' ') while @image_infoline.size > 1 && !@image_infoline[0].start_with?(image_filename)
           end
           @arguments = ""
         end
-    
+
         # The command line so far that will be used to convert or save the image
         def command_line
           %Q< "(" #{@arguments} #{QuickMagick.c(image_filename + (@pseudo_image ? "" : "[#{@index}]"))} ")" >
         end
-    
+
         # An information line about the image obtained using 'identify' command line
         def image_infoline
           return nil if @pseudo_image
           unless @image_infoline
             @image_infoline = QuickMagick::Image::identify(command_line).split
-            @image_infoline[0..1] = @image_infoline[0..1].join(' ') while @image_infoline.size > 1 && !@image_infoline[0].start_with?(image_filename)
+            process_info_line
+            #@image_infoline[0..1] = @image_infoline[0..1].join(' ') while @image_infoline.size > 1 && !@image_infoline[0].start_with?(image_filename)
           end
           @image_infoline
         end
@@ -257,159 +158,6 @@ module Gluttonberg
           points_str
         end
 
-        # The shape primitives are drawn in the color specified by the preceding -fill setting.
-        # For unfilled shapes, use -fill none.
-        # You can optionally control the stroke (the "outline" of a shape) with the -stroke and -strokewidth settings.
-    
-        # draws a point at the given location in pixels
-        # A point primitive is specified by a single point in the pixel plane, that is, by an ordered pair
-        # of integer coordinates, x,y.
-        # (As it involves only a single pixel, a point primitive is not affected by -stroke or -strokewidth.)
-        def draw_point(x, y, options={})
-          append_to_operators("draw", "#{options_to_str(options)} point #{x},#{y}")
-        end
-    
-        # draws a line between the given two points
-        # A line primitive requires a start point and end point.
-        def draw_line(x0, y0, x1, y1, options={})
-          append_to_operators("draw", "#{options_to_str(options)} line #{x0},#{y0} #{x1},#{y1}")
-        end
-    
-        # draw a rectangle with the given two corners
-        # A rectangle primitive is specified by the pair of points at the upper left and lower right corners.
-        def draw_rectangle(x0, y0, x1, y1, options={})
-          append_to_operators("draw", "#{options_to_str(options)} rectangle #{x0},#{y0} #{x1},#{y1}")
-        end
-
-        # draw a rounded rectangle with the given two corners
-        # wc and hc are the width and height of the arc
-        # A roundRectangle primitive takes the same corner points as a rectangle
-        # followed by the width and height of the rounded corners to be removed.
-        def draw_round_rectangle(x0, y0, x1, y1, wc, hc, options={})
-          append_to_operators("draw", "#{options_to_str(options)} roundRectangle #{x0},#{y0} #{x1},#{y1} #{wc},#{hc}")
-        end
-    
-        # The arc primitive is used to inscribe an elliptical segment in to a given rectangle.
-        # An arc requires the two corners used for rectangle (see above) followed by
-        # the start and end angles of the arc of the segment segment (e.g. 130,30 200,100 45,90).
-        # The start and end points produced are then joined with a line segment and the resulting segment of an ellipse is filled.
-        def draw_arc(x0, y0, x1, y1, a0, a1, options={})
-          append_to_operators("draw", "#{options_to_str(options)} arc #{x0},#{y0} #{x1},#{y1} #{a0},#{a1}")
-        end
-
-        # Use ellipse to draw a partial (or whole) ellipse.
-        # Give the center point, the horizontal and vertical "radii"
-        # (the semi-axes of the ellipse) and start and end angles in degrees (e.g. 100,100 100,150 0,360).
-        def draw_ellipse(x0, y0, rx, ry, a0, a1, options={})
-          append_to_operators("draw", "#{options_to_str(options)} ellipse #{x0},#{y0} #{rx},#{ry} #{a0},#{a1}")
-        end
-    
-        # The circle primitive makes a disk (filled) or circle (unfilled). Give the center and any point on the perimeter (boundary).
-        def draw_circle(x0, y0, x1, y1, options={})
-          append_to_operators("draw", "#{options_to_str(options)} circle #{x0},#{y0} #{x1},#{y1}")
-        end
-    
-        # The polyline primitive requires three or more points to define their perimeters.
-        # A polyline is simply a polygon in which the final point is not stroked to the start point.
-        # When unfilled, this is a polygonal line. If the -stroke setting is none (the default), then a polyline is identical to a polygon.
-        #  points - A single array with each pair forming a coordinate in the form (x, y).
-        # e.g. [0,0,100,100,100,0] will draw a polyline between points (0,0)-(100,100)-(100,0)
-        def draw_polyline(points, options={})
-          append_to_operators("draw", "#{options_to_str(options)} polyline #{points_to_str(points)}")
-        end
-
-        # The polygon primitive requires three or more points to define their perimeters.
-        # A polyline is simply a polygon in which the final point is not stroked to the start point.
-        # When unfilled, this is a polygonal line. If the -stroke setting is none (the default), then a polyline is identical to a polygon.
-        #  points - A single array with each pair forming a coordinate in the form (x, y). 
-        # e.g. [0,0,100,100,100,0] will draw a polygon between points (0,0)-(100,100)-(100,0)
-        def draw_polygon(points, options={})
-          append_to_operators("draw", "#{options_to_str(options)} polygon #{points_to_str(points)}")
-        end
-
-        # The Bezier primitive creates a spline curve and requires three or points to define its shape.
-        # The first and last points are the knots and these points are attained by the curve,
-        # while any intermediate coordinates are control points.
-        # If two control points are specified, the line between each end knot and its sequentially
-        # respective control point determines the tangent direction of the curve at that end.
-        # If one control point is specified, the lines from the end knots to the one control point
-        # determines the tangent directions of the curve at each end.
-        # If more than two control points are specified, then the additional control points
-        # act in combination to determine the intermediate shape of the curve.
-        # In order to draw complex curves, it is highly recommended either to use the path primitive
-        # or to draw multiple four-point bezier segments with the start and end knots of each successive segment repeated.
-        def draw_bezier(points, options={})
-          append_to_operators("draw", "#{options_to_str(options)} bezier #{points_to_str(points)}")
-        end
-    
-        # A path represents an outline of an object, defined in terms of moveto
-        # (set a new current point), lineto (draw a straight line), curveto (draw a Bezier curve),
-        # arc (elliptical or circular arc) and closepath (close the current shape by drawing a
-        # line to the last moveto) elements.
-        # Compound paths (i.e., a path with subpaths, each consisting of a single moveto followed by
-        # one or more line or curve operations) are possible to allow effects such as donut holes in objects.
-        # (See http://www.w3.org/TR/SVG/paths.html)
-        def draw_path(path_spec, options={})
-          append_to_operators("draw", "#{options_to_str(options)} path #{path_spec}")
-        end
-    
-        # Use image to composite an image with another image. Follow the image keyword
-        # with the composite operator, image location, image size, and filename
-        # You can use 0,0 for the image size, which means to use the actual dimensions found in the image header.
-        # Otherwise, it is scaled to the given dimensions. See -compose for a description of the composite operators.
-        def draw_image(operator, x0, y0, w, h, image_filename, options={})
-          append_to_operators("draw", "#{options_to_str(options)} image #{operator} #{x0},#{y0} #{w},#{h} \"#{image_filename}\"")
-        end
-    
-        # Use text to annotate an image with text. Follow the text coordinates with a string.
-        def draw_text(x0, y0, text, options={})
-          append_to_operators("draw", "#{options_to_str(options)} text #{x0},#{y0} '#{text}'")
-        end
-    
-        # saves the current image to the given filename 
-        def save(output_filename)
-          result = QuickMagick.exec3 "convert #{command_line} #{QuickMagick.c output_filename} "#-quality 92" 
-        	if @pseudo_image
-        		# since it's been saved, convert it to normal image (not pseudo)
-        		initialize(output_filename)
-    	    	revert!
-        	end
-          return result 
-        end
-    
-        alias write save
-        alias convert save
-    
-        # saves the current image overwriting the original image file
-        def save!
-          raise QuickMagick::QuickMagickError, "Cannot mogrify a pseudo image" if @pseudo_image
-          result = QuickMagick.exec3 "mogrify #{command_line}"
-          # remove all operations to avoid duplicate operations
-          revert!
-          return result 
-        end
-
-        alias write! save!
-        alias mogrify! save!
-    
-        def to_blob
-        	tmp_file = Tempfile.new(QuickMagick::random_string)
-        	if command_line =~ /-format\s(\S+)\s/
-        		# use format set up by user
-        		blob_format = $1
-        	elsif !@pseudo_image
-        		# use original image format
-        		blob_format = self.format
-        	else
-    		  	# default format is jpg
-    		  	blob_format = 'jpg'
-        	end
-        	save "#{blob_format}:#{tmp_file.path}"
-        	blob = nil
-        	File.open(tmp_file.path, 'rb') { |f| blob = f.read}
-        	blob
-        end
-
         def arguments
           @arguments
         end
@@ -417,36 +165,36 @@ module Gluttonberg
         def format
           image_infoline[1]
         end
-    
+
         # columns of image in pixels
         def columns
           image_infoline[2].split('x').first.to_i
         end
-    
+
         alias width columns
-    
+
         # rows of image in pixels
         def rows
           image_infoline[2].split('x').last.to_i
         end
-    
+
         alias height rows
-    
+
         # Bit depth
         def bit_depth
           image_infoline[4].to_i
         end
-    
+
         # Number of different colors used in this image
         def colors
           image_infoline[6].to_i
         end
-    
+
         # returns size of image in bytes
         def size
           File.size?(image_filename)
         end
-    
+
         # Reads a pixel from the image.
         # WARNING: This is done through command line which is very slow.
         # It is not recommended at all to use this method for image processing for example.
@@ -455,16 +203,21 @@ module Gluttonberg
           result =~ /Histogram:\s*\d+:\s*\(\s*(\d+),\s*(\d+),\s*(\d+)\)/
           return [$1.to_i, $2.to_i, $3.to_i]
         end
-    
+
         # displays the current image as animated image
         def animate
           `animate #{command_line}`
         end
-    
+
         # displays the current image to the x-windowing system
         def display
           `display #{command_line}`
         end
+
+        private
+          def process_info_line
+            @image_infoline[0..1] = @image_infoline[0..1].join(' ') while @image_infoline.size > 1 && !@image_infoline[0].start_with?(image_filename)
+          end
       end
     end
   end # Assetlibrary