datashift 0.10.1 → 0.10.2

data/lib/loaders/paperclip/attachment_loader.rb

@@ -10,95 +10,163 @@ require 'datashift_paperclip'
 
 module DataShift
  
-  class AttachmentLoader < LoaderBase
+  module Paperclip
+    
+    class AttachmentLoader < LoaderBase
       
-    include DataShift::Paperclip
+      include DataShift::Paperclip
       
-    attr_accessor :attach_to_klass
+      attr_accessor :attach_to_klass, :attach_to_find_by_field
       
-    def initialize(attachment_klazz, attachment = nil, options = {})
+      attr_writer :attach_to_field
+      attr_reader :attachment_path, :loading_files_cache
+      
+      
+      # If we have instantiated a method detail based on the attch to class and fields
+      # return that otherwise return the raw format of :attach_to_find_by_field
+      
+      def attach_to_field
+        @attach_to_method_detail || @attach_to_field
+      end
+      
+      # Options 
+    
+      # => :attach_to_klass    
+      #       A class that has a relationship with - has_many, has_one or belongs_to - the attachment 
+      #       The instance of :attach_to_klass can be searched for and the new attachment assigned.
+      #     Examples     
+      #       Owner has_many pdfs and mp3 files as Digitals .... :attach_to_klass = Owner
+      #       User has a single image used as an avatar ... :attach_to_klass = User
+      #
+      # => :attach_to_find_by_field    
+      #       For the :attach_to_klass, this is the field used to search for the parent
+      #       object to assign the new attachment to.
+      #     Examples     
+      #       Owner has a unique 'name' field ... :attach_to_find_by_field = :name
+      #       User has a unique  'login' field  ... :attach_to_klass = :login
+      #
+      # => :attach_to_field    
+      #       Attribute/association to assign attachment to on :attach_to_klass.
+      #      Examples
+      #         :attach_to_field => digitals  : Owner.digitals = attachment
+      #         :attach_to_field => avatar    : User.avatar = attachment
+      #         
+      #       
+      def initialize(attachment_klazz, attachment = nil, options = {})
         
-      opts = options.merge(:load => false) 
+        init_from_options( options )
+  
+        opts = options.merge(:load => false) 
 
-      super( attachment_klazz, attachment, opts )
+        super( attachment_klazz, attachment, opts )
+         
+        puts "Attachment Class is #{load_object_class}" if(@verbose)
+       
+        raise "Failed to create Attachment for loading" unless @load_object
+      end
+      
+      def init_from_options( options )
+      
+        @attach_to_klass  = options[:attach_to_klass] || @attach_to_klass || nil
         
-      @attach_to_klass  = options[:attach_to_klass]
-           
-      puts "Attachment Class is #{@attachment_klazz}" if(@verbose)
-          
-      raise "Failed to create Attachment for loading" unless @load_object
-    end
+        unless(@attach_to_klass.nil? || (MethodDictionary::for?(@attach_to_klass) && options[:reload] == false))
+          #puts "Building Method Dictionary for class #{object_class}"
+          DataShift::MethodDictionary.find_operators( @attach_to_klass, :reload => options[:reload], :instance_methods => true )
+        
+          # Create dictionary of data on all possible 'setter' methods which can be used to
+          # populate or integrate an object of type @load_object_class
+          DataShift::MethodDictionary.build_method_details(@attach_to_klass)
+        end
       
-    # :split_file_name_on
+        @attach_to_find_by_field  = options[:attach_to_find_by_field] || @attach_to_find_by_field || nil
+        @attach_to_field  = options[:attach_to_field] || @attach_to_field || nil
+        
+        unless(@attach_to_klass.nil? && @attach_to_field.nil? )
+          @attach_to_method_detail = MethodDictionary.find_method_detail(@attach_to_klass, @attach_to_field)
+        end
+      end
       
-    def process_from_filesystem(path, options )
-       
-      @attach_to_klass  = options[:attach_to_klazz] if(options[:attach_to_klazz])
-       
-      raise "The class that attachments belong to has not set" unless(@attach_to_klass)
+      # This version creates attachments and also attaches them to instances of :attach_to_klazz
+      # 
+      # Options
+      #   :split_file_name_on   Used in scan process to progresivly split filename to find   
+      #                         :attach_to_klass with matching :attach_to_find_by_field
+      #
+      #
+      def process_from_filesystem(path, options = {} )
+     
+        init_from_options( options )
         
-      @attachment_path = path
+        raise "The class that attachments belongs to has not been set (:attach_to_klass)" unless(@attach_to_klass) 
+                
+        raise "The field to search for attachment's owner has not been set (:attach_to_find_by_field)" unless(@attach_to_find_by_field)
+               
+        @load_object = options[:attachment] if(options[:attachment])
+  
+        @attachment_path = path
         
-      missing_records = []
+        missing_records = []
          
-      # try splitting up filename in various ways looking for the SKU
-      split_search_term  = @config['split_file_name_on'] || options[:split_file_name_on]
+        # try splitting up filename in various ways looking for the attachment owqner
+        split_on  = @config['split_file_name_on'] || options[:split_file_name_on]
              
-      cache = Paperclip::get_files(@attachment_path, options)
+        @loading_files_cache = Paperclip::get_files(path, options)
       
-      puts "Found #{cache.size} files - splitting names on delimiter [#{split_search_term}]"
-       
-      lookup_field = options[:attach_to_lookup_field]
-        
-      cache.each do |file_name|
+        puts "Found #{loading_files_cache.size} files - splitting names on delimiter [#{split_on}]"
 
-        attachment_name = File.basename(file_name)
+        loading_files_cache.each do |file_name|
 
-        logger.info "Processing attachment file #{attachment_name} "
+          attachment_name = File.basename(file_name)
+
+          logger.info "Processing attachment file #{attachment_name} "
           
-        base_name = File.basename(file_name, '.*')
-        base_name.strip!
+          base_name = File.basename(file_name, '.*')
+          base_name.strip!
+            
+          record = nil
             
-        record = nil
-                   
-        record = get_record_by(@attach_to_klass, lookup_field, base_name, split_search_term)
+          puts "try to find record where #{attach_to_find_by_field} ==  #{base_name}"
+          record = get_record_by(attach_to_klass, attach_to_find_by_field, base_name, split_on)
              
-        if(record)
-          logger.info "Found record for attachment : #{record.inspect}"
-        else
-          missing_records << file_name
-        end
+          if(record)
+            puts "Found record for attachment :\n#{record.inspect}"
+            logger.info "Found record for attachment : #{record.inspect}"
+          else
+            missing_records << file_name
+          end
           
-        next if(options[:dummy]) # Don't actually create/upload to DB if we are doing dummy run
+          next if(options[:dummy]) # Don't actually create/upload to DB if we are doing dummy run
 
-        # Check if attachment must have an associated record
-        if(record)
-          reset()
+          # Check if attachment must have an associated record
+          if(record)
+            puts "now create attachment"
+            reset()
           
-          create_attachment(@load_object_class, file_name, record, options[:attach_to_klass_field], options)
+            create_attachment(@load_object_class, file_name, record, attach_to_field, options)
    
-          puts "Added Attachment #{File.basename(file_name)} to #{record.send(lookup_field)} : #{record.id}" if(@verbose)
-        end
+            puts "Added Attachment #{File.basename(file_name)} to #{record.send(attach_to_find_by_field)} : #{record.id}" if(@verbose)
+          end
 
-      end
+        end
 
-      unless missing_records.empty?
-        FileUtils.mkdir_p('MissingAttachmentRecords') unless File.directory?('MissingAttachmentRecords')
+        unless missing_records.empty?
+          FileUtils.mkdir_p('MissingAttachmentRecords') unless File.directory?('MissingAttachmentRecords')
         
-        puts "WARNING : #{missing_records.size} of #{cache.size} files could not be attached to a #{@load_object_class}"
-        puts "For your convenience a copy of files with MISSING #{@load_object_class} :  ./MissingAttachmentRecords"
-        missing_records.each do |i|
-          puts "Copying #{i} to MissingAttachmentRecords folder" if(options[:verbose])
-          FileUtils.cp( i, 'MissingAttachmentRecords')  unless(options[:dummy] == 'true')
+          puts "WARNING : #{missing_records.size} of #{loading_files_cache.size} files could not be attached to a #{@load_object_class}"
+          puts "For your convenience a copy of files with MISSING #{@load_object_class} :  ./MissingAttachmentRecords"
+          missing_records.each do |i|
+            puts "Copying #{i} to MissingAttachmentRecords folder" if(options[:verbose])
+            FileUtils.cp( i, 'MissingAttachmentRecords')  unless(options[:dummy] == 'true')
+          end
+        else
+          puts "Created #{loading_files_cache.size} #{@load_object_class} attachments and succesfully attached to a #{@attach_to_klass}"
         end
-      else
-        puts "All files (#{cache.size}) were succesfully attached to a #{@load_object_class}"
-      end
 
-      puts "Dummy Run Complete- if happy run without -d" if(options[:dummy])
+        puts "Dummy Run Complete- if happy run without -d" if(options[:dummy])
    
-    end
+      end
    
-  end
+    end
       
-end
+  end
+end

data/lib/loaders/paperclip/datashift_paperclip.rb

@@ -6,12 +6,17 @@
 # Details::   Module containing common functionality for working with Paperclip attachments
 # 
 require 'logging'
+require 'paperclip'
 
 module DataShift
 
   module Paperclip
     
     include DataShift::Logging
+    include DataShift::Logging
+    require 'paperclip/attachment_loader'
+    
+    attr_accessor :attachment
     
     # Get all image files (based on file extensions) from supplied path.
     # Options : 
@@ -44,28 +49,57 @@ module DataShift
     
     # Note the paperclip attachment model defines the storage path via something like :
     # => :path => ":rails_root/public/blah/blahs/:id/:style/:basename.:extension"
+    # 
     # Options 
-    #   has_attached_file_name : Paperclip attachment name defined with macro 'has_attached_file :name'  
+    # 
+    #   :attributes
+    #     
+    #     Pass through hash of attributes to klass initializer
+    # 
+    #   :has_attached_file_attribute 
+    #   
+    #     Paperclip attachment name defined with macro 'has_attached_file :name'  
+    #   
     #     e.g 
-    #     has_attached_file :avatar =>  options[:has_attached_file_name] = :avatar
-    #     has_attached_file :icon   =>  options[:has_attached_file_name] = :icon
+    #       When : has_attached_file :avatar 
+    #      
+    #       Give : {:has_attached_file_attribute => :avatar}
+    #       
+    #       When :  has_attached_file :icon 
     #
-    #   alt : Alternatice text for images
-    
+    #       Give : { :has_attached_file_attribute => :icon }
+    #     
     def create_attachment(klass, attachment_path, record = nil, attach_to_record_field = nil, options = {})
        
-      has_attached_file = options[:has_attached_file_name] ? options[:has_attached_file_name].to_sym : :attachment
-      
-      file = get_file(attachment_path)
+      has_attached_file_attribute = options[has_attached_file_attribute] ? options[:has_attached_file_attribute].to_sym : :attachment
+  
+      attributes = { has_attached_file_attribute => get_file(attachment_path) }
 
+      attributes.merge!(options[:attributes]) if(options[:attributes])
+      
+      # e.g  (:viewable => some_product) =  Icon
+      
+      #attributes.merge!(attach_to_record_field.to_sym => record) if(record && attach_to_record_field)
+       
       begin
         
-        attachment = if(record && attach_to_record_field)
-          klass.new( {has_attached_file => file}, :without_protection => true)  
+        @attachment = klass.new(attributes, :without_protection => true) 
+      
+        if(@attachment.save)
+          puts "Success: Created Attachment #{@attachment.id} : #{@attachment.attachment_file_name}"
+                
+          if(attach_to_record_field.is_a? MethodDetail)
+            attach_to_record_field.assign(record, @attachment)
+          else
+            # assume its not a has_many and try basic send 
+            record.send(attach_to_record_field + '=', @attachment)
+          end if(record && attach_to_record_field)
+          
         else
-          klass.new( {has_attached_file => file, attach_to_record_field.to_sym => record}, :without_protection => true)  
+          puts "ERROR : Problem saving to DB : #{@attachment.inspect}"
         end
-        puts attachment.save ? "Success: Created #{attachment.id} : #{attachment.attachment_file_name}" : "ERROR : Problem saving to DB : #{attachment.inspect}"
+        
+        @attachment
       rescue => e
         puts "PaperClip error - Problem creating Attachment from : #{attachment_path}"
         puts e.inspect, e.backtrace

data/lib/loaders/paperclip/image_loading.rb

@@ -6,59 +6,43 @@
 # => Provides facilities for bulk uploading/exporting attachments provided by PaperClip 
 # gem
 require 'datashift_paperclip'
+require 'attachment_loader'
 
 module DataShift
 
   module ImageLoading
  
-    include DataShift::Paperclip
-    
-    # Get all image files (based on file extensions) from supplied path.
-    # Options : 
-    #     :glob : The glob to use to find files
-    # =>  :recursive : Descend tree looking for files rather than just supplied path
-    
-    def self.get_files(path, options = {})
-      glob = options[:glob] ? options[:glob] : image_magik_glob
-      glob = (options['recursive'] || options[:recursive])  ? "**/#{glob}" : glob
-      
-      Dir.glob("#{path}/#{glob}", File::FNM_CASEFOLD)
+    include DataShift::Paperclip 
+
+    def initialize(attachment_klazz, attachment = nil, options = {})
+      super( attachment_klazz, attachment, options )
     end
-  
     
     # Note the paperclip attachment model defines the storage path via something like :
+    # 
     # => :path => ":rails_root/public/blah/blahs/:id/:style/:basename.:extension"
+    # 
     # Options 
-    #   has_attached_file_name : Paperclip attachment name defined with macro 'has_attached_file :name'  e.g has_attached_file :avatar
-    #
-    def create_image(klass, attachment_path, viewable_record = nil, options = {})
-       
-      has_attached_file = options[:has_attached_file_name] || :attachment
+    # 
+    #   See also DataShift::paperclip create_attachment for more options
+    #   
+    #   Example:  Image is a model class with an attachment.
+    #             Image table contains a viewable field which can contain other  models,
+    #             such as Product, User etc all of which can have an Image
+    #             
+    #   :viewable_record 
+    #   
+    def create_attachment(klass, attachment_path, record = nil, attach_to_record_field = nil, options = {})
+            
+      attachment_options = options.dup
       
-      alt = if(options[:alt])
-        options[:alt]
-      else
-        (viewable_record and viewable_record.respond_to? :name) ? viewable_record.name : ""
-      end
-    
-      position = (viewable_record and viewable_record.respond_to?(:images)) ? viewable_record.images.length : 0
-          
-      file = get_file(attachment_path)
+      attributes = {:alt => (options[:alt] || "") }
+      
+      attributes[:position] = (!options[:position] && record and record.respond_to?(:images)) ? record.images.length : 0
 
-      begin
-        
-        image = klass.new( 
-          {has_attached_file.to_sym => file, :viewable => viewable_record, :alt => alt, :position => position},
-          :without_protection => true
-        )  
-        
-        #image.attachment.reprocess!  not sure this is required anymore
-        
-        puts image.save ? "Success: Created Image: #{image.id} : #{image.attachment_file_name}" : "ERROR : Problem saving to DB Image: #{image.inspect}"
-      rescue => e
-        puts "PaperClip error - Problem creating an Image from : #{attachment_path}"
-        puts e.inspect, e.backtrace
-      end
+      attachment_options.merge!( attributes )
+    
+      super(klass, attachment_path, record, attach_to_record_field, attachment_options)
     end
     
     # Set of file extensions ImageMagik can process so default glob

data/lib/thor/generate.thor

@@ -17,20 +17,24 @@
 #    bundle exec thor help  datashift:generate:excel
 #
 require 'datashift'
-  
+require 'excel_generator'
+
 # Note, not DataShift, case sensitive, create namespace for command line : datashift
 module Datashift
 
           
   class Generate < Thor     
-  
+         
     include DataShift::Logging
       
     desc "excel", "generate a template from an active record model (with optional associations)" 
     method_option :model, :aliases => '-m', :required => true, :desc => "The active record model to export"
     method_option :result, :aliases => '-r', :required => true, :desc => "Create template of model in supplied file"
     method_option :assoc, :aliases => '-a', :type => :boolean, :desc => "Include all associations in the template"
-    method_option :exclude, :aliases => '-e',  :type => :array, :desc => "Use with -a : Exclude association types. Any from #{DataShift::MethodDetail::supported_types_enum.to_a.inspect}"
+    method_option :exclude, :aliases => '-x',  :type => :array, :desc => "Use with -a : Exclude association types. Any from #{DataShift::MethodDetail::supported_types_enum.to_a.inspect}"
+    method_option :remove, :aliases => '-e',  :type => :array, :desc => "Don't generate in template the supplied fields"
+    method_option :remove_rails, :type => :boolean, :desc => "Don't generate in template the standard Rails fields: #{DataShift::GeneratorBase::rails_columns.inspect}"
+    
     
     def excel()
      
@@ -38,7 +42,7 @@ module Datashift
       # ...can we make this more robust ? e.g what about when using active record but not in Rails app, 
       require File.expand_path('config/environment.rb')
    
-      require 'excel_generator'
+
 
       model = options[:model]
       result = options[:result]
@@ -58,12 +62,18 @@ module Datashift
       begin
         gen = DataShift::ExcelGenerator.new(result)
 
+        opts =  { :remove => options[:remove],
+                  :remove_rails => options[:remove_rails]
+        }
+          
         if(options[:assoc])
-          opts = (options[:exclude]) ? {:exclude => options[:exclude]} : {}
+          
+          opts[:exclude] = options[:exclude]
+          
           logger.info("Datashift: Generating with associations")
           gen.generate_with_associations(klass, opts)
         else
-          gen.generate(klass)
+          gen.generate(klass, opts)
         end
       rescue => e
         puts e