photofy 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 49e3ec95765a73b90e67cce0cd7bdb93715e8a29
-  data.tar.gz: dacaee79783ed98425ae22cf1cec3bf821f24d60
+  metadata.gz: 9d91dc5fee2f8769167a2bd1652afe389190d87e
+  data.tar.gz: 27a6f56405e6b5df8ad47d303eb01a3c03cf567d
 SHA512:
-  metadata.gz: 05b9c2eb56e049b069f7fe5646fee1189baf554890daaeaadcbe2976a487430ba48089c8e7c9b01f8fd2e5ef8c5e261e671599b641e516b765f23c6674ca41e7
-  data.tar.gz: dbfde9014503a0a2cd61a66531000a40121f2489ceee2fec4d66a2752fb86fb5d37e7bee55228373ae2d372490f9f32298b5a21a7353735e890fc98da37ac858
+  metadata.gz: f8d67b670200d45149d1d6e5d6ff13f1b0d5da5d2f1f20589914c53990ab9b78e976f871bbed7c182065910267ba9e0255565dfc325f67e7932d35d046473fbc
+  data.tar.gz: 61b15cac3e9c70458472f32c6a5001566f6d9d0ac7e76f294806f5354a97fa4840b742e1874fa7643e44f004c398520ec3422a7f804e161e63c928f3c7e935a1

data/lib/photofy.rb

@@ -1,154 +1,175 @@
-begin
-  require "RMagick"
-rescue Exception => e
-  puts "Unable to load 'RMagick' for after_photofy methods"
-end
-
 module Photofy
   def self.included(base)
     base.extend(ClassMethods)
   end
 
   module ClassMethods
-    attr_accessor :photofield_flag
-    attr_accessor :photofy_attr
-    attr_accessor :photo_repository
-
-    #Generates photo field from photo_field argument which can be used to store a post processed image(using rmagick) of originally uploaded.
-    #Takes two arguments:
-    #1. field name
-    #2. Proc with rmagick img object
+    attr_accessor :photofied_flag
+    attr_accessor :photo_fields
+    attr_accessor :photos_repository
+    attr_accessor :photo_formats
+
+    #Getter to check if model is enabled with file_folder
+    def is_photofied?
+      @photofied_flag.nil? ? false : @photofied_flag
+    end
+
+    #Generates photo field which can be used to store a post processed image(using rmagick) of parent photo field.
+    #Takes three arguments:
+    #1. parent photo field name
+    #2. field name
+    #3. Proc with rmagick img object
     #return value should be an object of rmagick's image object
     #
     #Example usage..
-    #after_photofy :stamp, Proc.new{|img| img.scale(25, 25)}
-    #will give a 'stamp' attribute which on save of main photo filed will scale it to 25 x 25 dimesnions
-    #after_photofy :portfolio, Proc.new{|img| img.scale(150, 250)}
-    #will give a 'portfolio' attribute which on save of main photo filed will scale it to 150 x 250 dimesnions
-    #and also provide 're_photofy_portfolio!'(Proc.new{|img| img.scale(10, 20)}) to perform operation on other user defined events
-    def after_photofy(photo_field, p = Proc.new { |img| puts "Rmagick image: #{img.inspect}" })
-      #define_method "#{photo_field}" do
-      #  File.exist?(send("#{photo_field}_path")) ? File.read(send("#{photo_field}_path")) : nil
-      #end
-
-      #define_method "#{photo_field}?" do
-      #  send("#{photo_field}").nil? ? false : true
-      #end
-
-      #define_method "#{photo_field}_cover_path" do
-      #  directoy_path = FileUtils.mkdir_p File.join(self.class.photo_repository, photo_field.to_s)
-      #  File.join(directoy_path, "#{photo_field}_#{self.send(self.class.primary_key)}.jpg")
-      #end
-
-      define_method "re_photofy_#{photo_field}!" do |proc|
-        send("process_n_save_#{photo_field}", proc)
-      end
-
-      define_method "process_and_save_#{photo_field}!" do
-        send("process_n_save_#{photo_field}", p)
-      end
-
-      define_method "process_n_save_#{photo_field}" do |proc|
-        begin
-          if File.exist?(send("#{photo_field}_path"))
-            img = Magick::Image.read(send("#{photo_field}_path")).first # path of Orignal image that has to be worked upon
-            img = proc.call(img)
-            img.write(send("#{photo_field}_path"))
-          end
-        rescue Exception => e
-          puts "Unable to process_n_save_#{photo_field} due to #{e.message}"
-          e.backtrace.each { |trace| puts trace }
-        end
-      end
-
-      define_method "destroy_#{photo_field}" do
-        File.delete(send("#{photo_field}_path")) if File.exist?(send("#{photo_field}_path"))
-      end
-
-      send(:after_save, "process_and_save_#{photo_field}!")
-      send(:after_destroy, "destroy_#{photo_field}")
-    end
-
-    #Getter to check if model is enabled with photofied
-    def is_photofield?
-      @photofield_flag.nil? ? false : @photofield_flag
-    end
-
-    def register_callbacks(photo_filed)
-      send(:after_save, "#{photo_filed}_store!")
-      send(:after_destroy, "#{photo_filed}_destroy!")
+    #after_photofy :profile, :stamp, Proc.new{|img| img.scale(25, 25)}
+    #will give a 'stamp' attribute which on save of 'profile' photo field will scale it to 25 x 25 dimensions
+    #after_photofy :profile, :portfolio, Proc.new{|img| img.scale(150, 250)}
+    #will give a 'portfolio' attribute which on save of 'profile' photo field will scale it to 150 x 250 dimensions
+    def after_photofy(parent_photo_field, photo_field, proc = Proc.new { |img| puts "Rmagick image: #{img.inspect}" })
+      photofy(photo_field, image_processor: proc, parent_photo_field: parent_photo_field)
     end
 
+    #Example
+    #photofy(:door)
+    #photofy(:small_door, {parent_photo_field: :door})
+    #photofy(:window, {image_processor: Proc.new { |img| img.scale(25, 25) }})
+    #after_photofy :door, :ventilator, Proc.new { |img| img.scale(25, 25) }
+    #
     #Generates photo filed from photo_field arguments and provides methods like
     #if photo_filed is "collage" then it provides methods on top of it as
     #collage >> Getter,
-    #collage? >> Returns true if collage is having value other than nil else false,
-    #collage =  >> Setter. Accepted inputs are file upload(ActionDispatch::Http::UploadedFile), filer handle and String(format validation is ignored),
-    #collage_path >> Getter of filepath,
+    #collage? >> Returns true if assignment is having value other than nil else false,
+    #collage =  >> Setter. Acceptable inputs are file upload(ActionDispatch::Http::UploadedFile), filer handle and String(format validation is ignored),
+    #collage_path >> File path of assignment,
+    #collage_path_to_write >> File path of assignment to write (specific to writing. Used internally),
     #collage_persisted? >> true if provided file/data is stored on disk,
     #collage_store! >> to store provided  file/data on disk,
     #collage_destroy! >> to store destroy stored file/data from disk
-    def photofy(photo_filed, options = {})
-      if options.is_a?(Hash)
-        @photofy_attr ||={}
-        @photofy_attr[photo_filed] ||={}
-        @photofy_attr[photo_filed][:formats] = options[:formats].is_a?(Array) ? options[:formats].collect { |x| x.starts_with?(".") ? x : ".#{x}" } : [".bmp", ".jpg", ".jpeg", '.png']
-      else
-        raise "InvalidArguments"
+    #
+    #Options:
+    #image_processor: a proc for image processing like Proc.new { |img| img.scale(25, 25) }
+    #parent_photo_field: a parent photo field name to be used as source
+    def photofy(photo_field, options = {})
+      collect_photo_formats(photo_field, options)
+
+      @photo_fields ||=[]
+      @photo_fields << photo_field
+
+      define_method 'initialize_photo_buffers' do
+        @photo_file_buffer ||= {}
+        @photo_file_ofn ||= {}
       end
-      register_callbacks(photo_filed)
 
-      define_method "#{photo_filed}" do
-        self.class.photofy_attr[photo_filed][:file_buffer].nil? ?
-            (send("#{photo_filed}_persisted?") ? File.read(send("#{photo_filed}_path")) : nil)
-            : self.class.photofy_attr[photo_filed][:file_buffer]
+      #Defining getter
+      define_method "#{photo_field}" do
+        send('initialize_photo_buffers')
+
+        if @photo_file_buffer[photo_field].nil?
+          send("#{photo_field}_persisted?") ? File.read(send("#{photo_field}_path")) : nil
+        else
+          @photo_file_buffer[photo_field]
+        end
       end
 
-      define_method "#{photo_filed}?" do
-        send("#{photo_filed}").nil? ? false : true
+      define_method "#{photo_field}?" do
+        send("#{photo_field}").nil? ? false : true
       end
 
-      define_method "#{photo_filed}=" do |file_upload|
+      #Defining setter
+      define_method "#{photo_field}=" do |file_upload|
+        send('initialize_photo_buffers')
+
         if file_upload.class == ActionDispatch::Http::UploadedFile
-          return false unless self.class.photofy_attr[photo_filed][:formats].include?(File.extname(file_upload.original_filename).downcase)
-          self.class.photofy_attr[photo_filed][:file_buffer] = File.read(file_upload.path)
+          return false unless self.class.photo_formats[photo_field].include?(File.extname(file_upload.original_filename).downcase)
+          @photo_file_buffer[photo_field] = File.read(file_upload.path)
+          @photo_file_ofn[photo_field] = File.basename(file_upload.original_filename)
+
         elsif file_upload.class == File
-          return false unless self.class.photofy_attr[photo_filed][:formats].include?(File.extname(file_upload.path).downcase)
-          self.class.photofy_attr[photo_filed][:file_buffer] = file_upload.read
+          return false unless self.class.photo_formats[photo_field].include?(File.extname(file_upload.path).downcase)
+          @photo_file_buffer[photo_field] = file_upload.read
+          @photo_file_ofn[photo_field] = File.basename(file_upload.path)
+
+          file_upload.rewind
         elsif file_upload.class == String
-          #return false unless self.class.photo_formats.include?(File.extname(file_upload).downcase)
-          self.class.photofy_attr[photo_filed][:file_buffer] = file_upload
+          #return false unless self.class.photo_formats[photo_field].include?(File.extname(file_upload).downcase)
+          @photo_file_buffer[photo_field] = file_upload
+          #@photo_file_ofn[photo_field] = File.basename(file_upload.path) #As there is nothing like original_file_name for a string :)
         end
+
+        file_upload
+      end
+
+      define_method "#{photo_field}_path" do
+        directory_path = FileUtils.mkdir_p File.join(self.class.photos_repository, photo_field.to_s)
+        (guessed_file = Dir[File.join(directory_path, "#{self.send(self.class.primary_key).to_s}_*")].first).nil? ?
+            File.join(directory_path, self.send(self.class.primary_key).to_s) : guessed_file
       end
 
-      define_method "#{photo_filed}_path" do
-        directoy_path = FileUtils.mkdir_p File.join(self.class.photo_repository, photo_filed.to_s)
-        File.join(directoy_path, self.send(self.class.primary_key).to_s)
+      define_method "#{photo_field}_path_to_write" do |overload_dir = nil|
+        directoy_path = FileUtils.mkdir_p File.join(self.class.photos_repository, photo_field.to_s, overload_dir.to_s)
+        File.join(directoy_path, "#{self.send(self.class.primary_key).to_s}#{(@photo_file_ofn[photo_field].nil?) ? "_" : "_#{@photo_file_ofn[photo_field]}" }")
       end
 
-      define_method "#{photo_filed}_persisted?" do
-        (self.class.photofy_attr[photo_filed][:file_buffer].nil? and File.file?(send("#{photo_filed}_path")))
+      define_method "#{photo_field}_persisted?" do
+        send('initialize_photo_buffers')
+        (@photo_file_buffer[photo_field].nil? and File.file?(send("#{photo_field}_path")))
       end
 
-      define_method "#{photo_filed}_store!" do
-        return unless self.class.is_photofield?
-        unless self.class.photofy_attr[photo_filed][:file_buffer].nil?
-          File.open(send("#{photo_filed}_path"), "wb+") { |f| f.puts(self.class.photofy_attr[photo_filed][:file_buffer]) }
-          self.class.photofy_attr[photo_filed].delete(:file_buffer)
+      define_method "#{photo_field}_store" do |proc, parent_photo_field|
+        return unless self.class.is_photofied?
+
+        send('initialize_photo_buffers')
+
+        #Loading content from parent_photo_field if specified
+        send("#{photo_field}=", File.open(send("#{parent_photo_field}_path"))) unless parent_photo_field.nil?
+
+        unless @photo_file_buffer[photo_field].nil?
+          File.delete(send("#{photo_field}_path")) if File.exist?(send("#{photo_field}_path")) #Clearing any existing existence
+          File.open(send("#{photo_field}_path_to_write"), "wb+") { |f| f.puts(@photo_file_buffer[photo_field]) }
+
+          unless proc.nil?
+            FileUtils.copy(send("#{photo_field}_path_to_write"), send("#{photo_field}_path_to_write", "original_source"))
+            img = Magick::Image.read(send("#{photo_field}_path")).first
+            img = proc.call(img)
+            img.write(send("#{photo_field}_path_to_write"))
+          end
+
+          @photo_file_buffer[photo_field] = nil
+          @photo_file_ofn[photo_field] = nil
         end
       end
 
-      define_method "#{photo_filed}_destroy!" do
-        return unless self.class.is_photofield?
-        self.class.photofy_attr[photo_filed].delete(:file_buffer)
-        File.delete(send("#{photo_filed}_path")) if File.exist?(send("#{photo_filed}_path"))
+      define_method "#{photo_field}_store!" do
+        send("#{photo_field}_store", options[:image_processor], options[:parent_photo_field])
+      end
+
+      define_method "#{photo_field}_destroy!" do
+        return unless self.class.is_photofied?
+
+        send('initialize_photo_buffers')
+        @photo_file_buffer[photo_field] = nil
+        File.delete(send("#{photo_field}_path")) if File.exist?(send("#{photo_field}_path"))
       end
 
-      @photofield_flag = true
+      send(:after_save, "#{photo_field}_store!")
+      send(:after_destroy, "#{photo_field}_destroy!")
+
+      @photofied_flag = true
+    end
+
+    def photos_repository
+      @photos_repository ||= FileUtils.mkdir_p File.join(Rails.root, "photofy", self.name)
     end
 
-    def photo_repository
-      @photo_repository ||= FileUtils.mkdir_p File.join(Rails.root, "photofied", self.name)
+    #Collects valid photo formats specific to photo fields
+    def collect_photo_formats(photo_field, options)
+      if options.is_a?(Hash)
+        @photo_formats ||= {}
+        @photo_formats[photo_field] = options[:formats].is_a?(Array) ? options[:formats].collect { |x| x.starts_with?(".") ? x : ".#{x}" } : [".jpeg", ".jpg", ".gif", ".png", ".bmp"]
+      else
+        raise 'InvalidArguments'
+      end
     end
 
   end

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: photofy
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Praveen Kumar Sinha
 - Annu Yadav
-- sachin choudhary
+- Sachin Choudhary
 autorequire: 
 bindir: bin
 cert_chain: []
@@ -17,8 +17,10 @@ description: |-
       #Generates photo filed from photo_field arguments and provides methods like
       #if photo_filed is "collage" then it provides methods on top of it as
       #collage >> Getter,
-      #collage =  >> Setter. Accepted inputs are file upload(ActionDispatch::Http::UploadedFile), filer handle and String(no format validation is ignored),
-      #collage_path >> Getter of filepath,
+      #collage? >> Returns true if assignment is having value other than nil else false,
+      #collage =  >> Setter. Acceptable inputs are file upload(ActionDispatch::Http::UploadedFile), filer handle and String(format validation is ignored),
+      #collage_path >> File path of assignment,
+      #collage_path_to_write >> File path of assignment to write (specific to writing. Used internally),
       #collage_persisted? >> true if provided file/data is stored on disk,
       #collage_store! >> to store provided  file/data on disk,
       #collage_destroy! >> to store destroy stored file/data from disk