datashift 0.10.2 → 0.11.0

data/VERSION

@@ -1 +1 @@
-0.10.2
+0.11.0

data/datashift.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "datashift"
-  s.version = "0.10.2"
+  s.version = "0.11.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Thomas Statter"]
-  s.date = "2012-10-21"
+  s.date = "2012-10-23"
   s.description = "Comprehensive tools to import/export between Excel/CSV and ActiveRecord databases, Rails apps, and any Ruby project."
   s.email = "rubygems@autotelik.co.uk"
   s.extra_rdoc_files = [

data/lib/datashift/method_dictionary.rb

@@ -12,13 +12,11 @@ module DataShift
   class MethodDictionary
 
     include DataShift::Logging
-    
-    def initialize
-    end
-
-    # Has the dictionary been populated for  klass
+   
+    # Return true if dictionary has  been populated for  klass
     def self.for?(klass)
-      return !(has_many[klass] || belongs_to[klass] || has_one[klass] || assignments[klass]).nil?
+      any = has_many[klass] || belongs_to[klass] || has_one[klass] || assignments[klass]
+      return any != nil
     end
     
     # Create simple picture of all the operator names for assignment available on an AR model,

data/lib/datashift/method_mapper.rb

@@ -84,8 +84,7 @@ module DataShift
         DataShift::MethodDictionary.build_method_details(klass)
       end 
       
-      forced = [*options[:force_inclusion]].compact
-      forced.collect! { |f| f.downcase }
+      forced = [*options[:force_inclusion]].compact.collect { |f| f.to_s.downcase }
       
       @method_details, @missing_methods = [], []
     
@@ -94,7 +93,7 @@ module DataShift
         raw_col_data = col_data.to_s
         
         if(raw_col_data.nil? or raw_col_data.empty?)
-          logger.warn("Column list contains empty or null columns") 
+          logger.warn("Column list contains empty or null column at index #{col_index}") 
           @method_details << nil
           next
         end
@@ -103,10 +102,10 @@ module DataShift
        
         md = MethodDictionary::find_method_detail( klass, raw_col_name )
         
-        # TODO be nice if we could cheeck that the assoc on klass responds to the specified
+        # TODO be nice if we could check that the assoc on klass responds to the specified
         # lookup key now (nice n early)
         # active_record_helper = "find_by_#{lookup}"
-        if(md.nil? && options[:include_all] || forced.include?(raw_col_name.downcase))
+        if(md.nil? && (options[:include_all] || forced.include?(raw_col_name.downcase)) )
           md = MethodDictionary::add(klass, raw_col_name)
         end
         
@@ -149,7 +148,9 @@ module DataShift
     
     # Returns true if discovered methods contain every operator in mandatory_list
     def contains_mandatory?( mandatory_list )
-      [ [*mandatory_list] - operator_names].flatten.empty?
+      a = [*mandatory_list].collect { |f| f.downcase }
+      b = operator_names.collect { |f| f.downcase }
+      (a - b).empty?
     end
 
     def missing_mandatory( mandatory_list )

data/lib/datashift/populator.rb

@@ -31,7 +31,7 @@ module DataShift
             record.send(op, value.send( f) )
             break
           rescue => e
-            #puts "DEBUG: insistent_assignment: #{e.inspect}"
+            puts "DEBUG: insistent_assignment: #{e.inspect}"
             if f == Populator::insistent_method_list.last
               puts  "I'm sorry I have failed to assign [#{value}] to #{operator}"
               raise "I'm sorry I have failed to assign [#{value}] to #{operator}" unless value.nil?

data/lib/loaders/csv_loader.rb

@@ -86,8 +86,8 @@ module DataShift
 
     include DataShift::CsvLoading
 
-    def initialize(klass, object = nil, options = {})
-      super( klass, object, options )
+    def initialize(klass, find_operators = true, object = nil, options = {})
+      super( klass, find_operators, object, options )
       raise "Cannot load - failed to create a #{klass}" unless @load_object
     end
 

data/lib/loaders/excel_loader.rb

@@ -44,7 +44,6 @@ module DataShift
       puts "\n\n\nLoading from Excel file: #{file_name}"
 
       sheet_number = options[:sheet_number] || 0
-
       
       @sheet = @excel.worksheet( sheet_number )
 
@@ -66,14 +65,11 @@ module DataShift
       end
 
       raise MissingHeadersError, "No headers found - Check Sheet #{@sheet} is complete and Row #{header_row_index} contains headers" if(@headers.empty?)
-
       
       # Create a method_mapper which maps list of headers into suitable calls on the Active Record class
       # For example if model has an attribute 'price' will map columns called Price, price, PRICE etc to this attribute
       populate_method_mapper_from_headers( @headers, options )
       
-      @method_mapper
-
       logger.info "Excel Loader processing #{@sheet.num_rows} rows"
       
       loaded_objects.clear
@@ -105,10 +101,9 @@ module DataShift
          
           # Iterate over method_details, working on data out of associated Excel column
           @method_mapper.method_details.each do |method_detail|
-            
-            
+                
             next unless method_detail # TODO populate unmapped with a real MethodDetail that is 'null' and create is_nil
-
+            
             value = row[method_detail.column_index]
 
             contains_data = true unless(value.nil? || value.to_s.empty?)
@@ -155,8 +150,8 @@ module DataShift
 
     include ExcelLoading
   
-    def initialize(klass, object = nil, options = {})
-      super( klass, object, options )
+    def initialize(klass, find_operators = true, object = nil, options = {})
+      super( klass, find_operators, object, options )
       raise "Cannot load - failed to create a #{klass}" unless @load_object
     end
 

data/lib/loaders/loader_base.rb

@@ -39,25 +39,25 @@ module DataShift
     # 
     # Options to drive building the method dictionary for a class, enabling headers to be mapped to operators on that class.
     #  
+    # find_operators [default = true] : Populate method dictionary with operators and method details
+    #      
     # Options
-    #  :load [default = true] : Load the method dictionary for object_class
     #  
     #  :reload           : Force load of the method dictionary for object_class even if already loaded
-    #  :instance_methods : Include setter type instance methods for assignment as well as AR columns
-
-    
-    def initialize(object_class, object = nil, options = {})
+    #  :instance_methods : Include setter/delegate style instance methods for assignment, as well as AR columns
+    #
+    def initialize(object_class, find_operators = true, object = nil, options = {})
       @load_object_class = object_class
-
+      
       # Gather names of all possible 'setter' methods on AR class (instance variables and associations)
-      unless(MethodDictionary::for?(object_class) && options[:reload] == false)
-        #puts "Building Method Dictionary for class #{object_class}"
+      if((find_operators && !MethodDictionary::for?(object_class)) || options[:reload])
+        puts "Building Method Dictionary for class #{object_class}"
         DataShift::MethodDictionary.find_operators( @load_object_class, :reload => options[:reload], :instance_methods => options[:instance_methods] )
         
         # 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(@load_object_class)
-      end if(options[:load] || options[:reload])
+      end
       
       @method_mapper = DataShift::MethodMapper.new
       @config = options.dup    # clone can cause issues like 'can't modify frozen hash'
@@ -152,10 +152,10 @@ module DataShift
         raise MappingDefinitionError, "Missing mappings for columns : #{@method_mapper.missing_methods.join(",")}" if(strict)
       end
 
-      unless(@method_mapper.contains_mandatory?(mandatory) )
-        @method_mapper.missing_mandatory(mandatory).each { |e| puts "ERROR: Mandatory column missing - expected column '#{e}'" }
+      unless(mandatory.empty? || @method_mapper.contains_mandatory?(mandatory) )
+        @method_mapper.missing_mandatory(mandatory).each { |er| puts "ERROR: Mandatory column missing - expected column '#{er}'" }
         raise MissingMandatoryError, "Mandatory columns missing  - please fix and retry."
-      end unless(mandatory.empty?)
+      end
       
       @method_mapper
     end
@@ -184,6 +184,7 @@ module DataShift
         prepare_data(method_detail, data)
         process()
       else
+        puts "No matching method found for column #{column_name}"
         @load_object.errors.add(:base, "No matching method found for column #{column_name}")
       end
     end

data/lib/loaders/paperclip/attachment_loader.rb

@@ -20,20 +20,16 @@ module DataShift
       
       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
-      
+      # Constructor
+      # 
       # Options 
-    
+      #
       # => :attach_to_klass    
-      #       A class that has a relationship with - has_many, has_one or belongs_to - the attachment 
+      #       A class that has a relationship with the attachment (has_many, has_one or belongs_to etc)  
       #       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
@@ -41,6 +37,7 @@ module DataShift
       # => :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
@@ -48,27 +45,31 @@ module DataShift
       # => :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 = {})
+      def initialize(attachment_klazz, find_operators = true, attachment = nil, options = {})
         
         init_from_options( options )
-  
-        opts = options.merge(:load => false) 
-
-        super( attachment_klazz, attachment, opts )
+ 
+        super( attachment_klazz, find_operators, attachment, options.dup )
          
         puts "Attachment Class is #{load_object_class}" if(@verbose)
        
         raise "Failed to create Attachment for loading" unless @load_object
       end
+            
       
+      # Options
+      # :reload
+      # :attach_to_klass, :attach_to_field, :attach_to_find_by_field
+      #
       def init_from_options( options )
-      
-        @attach_to_klass  = options[:attach_to_klass] || @attach_to_klass || nil
         
+        @attach_to_klass  = options[:attach_to_klass] || @attach_to_klass || nil
+            
         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 )
@@ -86,6 +87,15 @@ module DataShift
         end
       end
       
+            
+      # If we have instantiated a method detail based on the attach 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
+      
+      
       # This version creates attachments and also attaches them to instances of :attach_to_klazz
       # 
       # Options
@@ -125,7 +135,7 @@ module DataShift
             
           record = nil
             
-          puts "try to find record where #{attach_to_find_by_field} ==  #{base_name}"
+          puts "Attempting to find matching 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)
@@ -139,12 +149,11 @@ module DataShift
 
           # Check if attachment must have an associated record
           if(record)
-            puts "now create attachment"
             reset()
           
             create_attachment(@load_object_class, file_name, record, attach_to_field, options)
    
-            puts "Added Attachment #{File.basename(file_name)} to #{record.send(attach_to_find_by_field)} : #{record.id}" if(@verbose)
+            puts "Added Attachment #{File.basename(file_name)} to #{record.send(attach_to_find_by_field)}(id : #{record.id})" if(@verbose)
           end
 
         end
@@ -153,7 +162,7 @@ module DataShift
           FileUtils.mkdir_p('MissingAttachmentRecords') unless File.directory?('MissingAttachmentRecords')
         
           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"
+          puts "For your convenience files with MISSING #{attach_to_klass} have been copied to : MissingAttachmentRecords"
           missing_records.each do |i|
             puts "Copying #{i} to MissingAttachmentRecords folder" if(options[:verbose])
             FileUtils.cp( i, 'MissingAttachmentRecords')  unless(options[:dummy] == 'true')

data/lib/loaders/paperclip/datashift_paperclip.rb

@@ -56,7 +56,7 @@ module DataShift
     #     
     #     Pass through hash of attributes to klass initializer
     # 
-    #   :has_attached_file_attribute 
+    #   :has_attached_file_name
     #   
     #     Paperclip attachment name defined with macro 'has_attached_file :name'  
     #   
@@ -71,7 +71,7 @@ module DataShift
     #     
     def create_attachment(klass, attachment_path, record = nil, attach_to_record_field = nil, options = {})
        
-      has_attached_file_attribute = options[has_attached_file_attribute] ? options[:has_attached_file_attribute].to_sym : :attachment
+      has_attached_file_attribute = options[:has_attached_file_name] ? options[:has_attached_file_name].to_sym : :attachment
   
       attributes = { has_attached_file_attribute => get_file(attachment_path) }
 
@@ -81,6 +81,7 @@ module DataShift
       
       #attributes.merge!(attach_to_record_field.to_sym => record) if(record && attach_to_record_field)
        
+      puts attributes.inspect
       begin
         
         @attachment = klass.new(attributes, :without_protection => true) 
@@ -92,11 +93,12 @@ module DataShift
             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)
+            record.send("#{attach_to_record_field}=", @attachment)
           end if(record && attach_to_record_field)
           
         else
           puts "ERROR : Problem saving to DB : #{@attachment.inspect}"
+          puts @attachment.errors.messages.inspect
         end
         
         @attachment

data/lib/loaders/paperclip/image_loading.rb

@@ -14,9 +14,6 @@ module DataShift
  
     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 :
     # 
@@ -33,15 +30,17 @@ module DataShift
     #   :viewable_record 
     #   
     def create_attachment(klass, attachment_path, record = nil, attach_to_record_field = nil, options = {})
-            
-      attachment_options = options.dup
-      
-      attributes = {:alt => (options[:alt] || "") }
-      
-      attributes[:position] = (!options[:position] && record and record.respond_to?(:images)) ? record.images.length : 0
+        
+      image_attributes = { :attributes => 
+                            { :alt => (options[:alt] || ""),
+                              :position => (!options[:position] && record and record.respond_to?(:images)) ? record.images.length : 0
+                            }
+      }
 
-      attachment_options.merge!( attributes )
-    
+      attachment_options = options.dup.merge(image_attributes)
+      
+      #puts "DEBUG : create_attachment options : #{attachment_options.inspect}"
+       
       super(klass, attachment_path, record, attach_to_record_field, attachment_options)
     end
     

data/lib/thor/import.thor

@@ -63,11 +63,11 @@ module Datashift
           logger.info("INFO: Using loader : #{loader.class}")
         rescue
           logger.error("INFO: No specific #{model}Loader found  - using generic ExcelLoader")
-          loader = DataShift::ExcelLoader.new(klass)
+          loader = DataShift::ExcelLoader.new(klass, true)
         end
       else
         logger.info("No Loader specified - using generic ExcelLoader")
-        loader = DataShift::ExcelLoader.new(klass)
+        loader = DataShift::ExcelLoader.new(klass, true)
       end
 
       logger.info("ARGS #{options.inspect}")

data/lib/thor/paperclip.thor

@@ -22,11 +22,32 @@ module Datashift
   
     include DataShift::Logging   
 
-    desc "attach", "Attach files from a directory\nThe attachment file names must contain the lookup info within them.
-    The instance of :attach_to_klass can be searched for and the new attachment assigned.
+    desc "attach", "Create paperclip attachments and attach to a Model from files in a directory.
+    This is specifically for the use case where the paperclip attachments are stored in a class, such as Image, Icon, Asset,
+    and this class has a relationship, such as belongs_to, with another class, such as Product, User, Document.
+ 
+    Each matching file is used to create an instance of the paperclip attachment, given by :attachment_klass.
+    
+    The class with the relationship, can be specified via :attach_to_klass
+
       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"
+        Owner has_many pdfs and mp3 files as Digitals .... :attachment_klass = Digital and :attach_to_klass = Owner
+        User has a single Image used as an avatar ... attachment_klass = Image and :attach_to_klass = User
+    
+    The file name is used to lookup the instance of :attach_to_klass to assign the new attachment to, via :attach_to_find_by_field
+
+    So say we have a file called smithj_avatar.gif, and we want to lookup Users by login
+
+        :attach_to_find_by_field = login => Run a loookup based on find_by_login == 'smithj'
+
+    Once instance of :attach_to_klass found, the new attachment is assigned.
+
+     The attribute to assign new attachment to is gtiven by :attach_to_field    
+  
+     Examples
+        :attach_to_field => digitals  : Owner.digitals = attachment(Digital)
+        :attach_to_field => avatar    : User.avatar = attachment(Image)"
+    
 
     # :dummy => dummy run without actual saving to DB
     method_option :input, :aliases => '-i', :required => true, :desc => "The input path containing images "
@@ -35,13 +56,11 @@ module Datashift
     method_option :recursive, :aliases => '-r', :type => :boolean, :desc => "Scan sub directories of input for images"
      
     method_option :attachment_klass, :required => true, :aliases => '-a', :desc => "Ruby Class name of the Attachment e.g Image, Icon"
-    method_option :attach_to_klass, :required => true, :aliases => '-k', :desc => "A class that has a relationship with the attachment (has_many, has_one, belongs_to)"
-
-    
-    method_option :attach_to_field, :required => true, :aliases => '-f', :desc => "Attachment belongs to field e.g Product.image, Blog.digital"
     
+    method_option :attach_to_klass, :required => true, :aliases => '-k', :desc => "A class that has a relationship with the attachment (has_many, has_one, belongs_to)"     
     method_option :attach_to_find_by_field, :required => true, :aliases => '-l', :desc => "The field to use to find the :attach_to_klass record"
-    
+    method_option :attach_to_field, :required => true, :aliases => '-f', :desc => "Attachment belongs to field e.g Product.image, Blog.digital"
+  
     
       # => :attach_to_find_by_field    
       #       For the :attach_to_klass, this is the field used to search for the parent

data/spec/excel_loader_spec.rb

@@ -31,9 +31,6 @@ describe 'Excel Loader' do
       Category.find_or_create_by_reference(cat)
     end
 
-    DataShift::MethodDictionary.find_operators( Category )
-    
-    DataShift::MethodDictionary.build_method_details( Category )
     
   end
   
@@ -57,6 +54,11 @@ describe 'Excel Loader' do
 
   it "should process multiple associationss from single column" do
 
+    
+    DataShift::MethodDictionary.find_operators( Category )
+    
+    DataShift::MethodDictionary.build_method_details( Category )
+    
     Project.find_by_title('001').should be_nil
     count = Project.count
 

data/spec/method_dictionary_spec.rb

@@ -8,25 +8,34 @@
 #             and a classes different types of assignment operators
 #
 require File.join(File.dirname(__FILE__), 'spec_helper')
-    
+  
+require 'method_dictionary'
+
 describe 'Method Dictionary' do
 
+
   include_context "ActiveRecordTestModelsConnected"
   
+  include DataShift
   
   before(:each) do
     MethodDictionary.clear
-    MethodDictionary.find_operators( Project )
-    MethodDictionary.find_operators( Milestone )
   end
   
   it "should store dictionary for multiple AR models" do
+    
+    MethodDictionary.find_operators( Project )
+    MethodDictionary.find_operators( Milestone )
+    
     MethodDictionary.assignments.size.should == 2 
     MethodDictionary.has_many.size.should == 2
   end
   
   it "should populate method dictionary for a given AR model" do
 
+    MethodDictionary.find_operators( Project )
+    MethodDictionary.find_operators( Milestone )
+    
     MethodDictionary.has_many.should_not be_empty
     MethodDictionary.has_many[Project].should include('milestones')
 
@@ -48,6 +57,8 @@ describe 'Method Dictionary' do
 
   it "should populate assigment members without the equivalent association names" do
 
+    MethodDictionary.find_operators( Project )
+    
     # we should remove has-many & belongs_to from basic assignment set as they require a DB lookup
     # or a Model.create call, not a simple assignment
 
@@ -58,6 +69,9 @@ describe 'Method Dictionary' do
 
   it "should populate assignment operators for method details for different forms of a column name" do
 
+    MethodDictionary.find_operators( Project )
+    MethodDictionary.find_operators( Milestone )
+    
     MethodDictionary.build_method_details( Project )
     
     [:value_as_string, 'value_as_string', "VALUE as_STRING", "value as string"].each do |format|
@@ -83,6 +97,8 @@ describe 'Method Dictionary' do
 
   it "should populate column types for assignment operators in method details" do
 
+    MethodDictionary.find_operators( Project )
+    
     MethodDictionary.build_method_details( Project )
         
     [:value_as_string, 'value_as_string', "VALUE as_STRING", "value as string"].each do |format|
@@ -101,6 +117,8 @@ describe 'Method Dictionary' do
 
   it "should populate required Class for assignment operators based on column type" do
 
+    MethodDictionary.find_operators( Project )
+    
     MethodDictionary.build_method_details( Project )
         
     [:value_as_string, 'value_as_string', "VALUE as_STRING", "value as string"].each do |format|
@@ -116,6 +134,9 @@ describe 'Method Dictionary' do
 
   it "should populate belongs_to operator for method details for different forms of a column name" do
 
+    MethodDictionary.find_operators( Project )
+    MethodDictionary.find_operators( Milestone )
+    
     MethodDictionary.build_method_details( Project )
     MethodDictionary.build_method_details( Milestone )
             
@@ -184,10 +205,24 @@ describe 'Method Dictionary' do
       method_details.operator_class.should == LongAndComplexTableLinkedToVersion
     end
   end
+  
+  it "should return false on for?(klass) if find_operators hasn't been called for klass" do
+    MethodDictionary.clear
+    MethodDictionary::for?(Project).should == false
+    MethodDictionary::find_operators(Project)
+    MethodDictionary::for?(Project).should == true
+     
+  end
 
-
+  it "should return false on for?(klass) if find_operators hasn't been called for klass" do
+    MethodDictionary.clear
+    MethodDictionary::for?(Project).should == false
+  end
+  
   it "should find has_many operator for method details" do
-
+    
+    MethodDictionary.find_operators( Project )
+    
     MethodDictionary.build_method_details( Project )
      
     [:milestones, "Mile Stones", 'mileSTONES', 'MileStones'].each do |format|
@@ -208,6 +243,9 @@ describe 'Method Dictionary' do
 
  
   it "should return nil when non existent column name" do
+    
+    MethodDictionary.find_operators( Project )
+    
     ["On sale", 'on_sale'].each do |format|
       detail = MethodDictionary.find_method_detail( Project, format )
 
@@ -221,11 +259,16 @@ describe 'Method Dictionary' do
   end
 
   it "should not by default map setter methods" do
+    MethodDictionary.find_operators( Milestone )
+    
     MethodDictionary.assignments[Milestone].should_not include('title')
   end
   
   it "should support reload and  inclusion of setter methods" do
 
+    MethodDictionary.find_operators( Project )
+    MethodDictionary.find_operators( Milestone )
+    
     MethodDictionary.assignments[Milestone].should_not include('title')
         
     MethodDictionary.find_operators( Milestone, :reload => true, :instance_methods => true )

data/spec/paperclip_loader_spec.rb

@@ -38,7 +38,7 @@ describe 'PaperClip Bulk Loader' do
   end
   
   it "should create a new paperclip loader and define attachment class" do 
-    loader = DataShift::Paperclip::AttachmentLoader.new(@attachment_klass, nil, @common_options)
+    loader = DataShift::Paperclip::AttachmentLoader.new(@attachment_klass, true, nil, @common_options)
     
     loader.load_object_class.should == Digital
     loader.load_object.should be_a Digital
@@ -50,7 +50,7 @@ describe 'PaperClip Bulk Loader' do
              
     opts = { :attach_to_klass => Owner }.merge(@common_options)
     
-    loader = DataShift::Paperclip::AttachmentLoader.new(@attachment_klass, nil, opts)
+    loader = DataShift::Paperclip::AttachmentLoader.new(@attachment_klass, true, nil, opts)
     
     loader.attach_to_klass.should == Owner
   end

metadata

@@ -1,58 +1,50 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: datashift
-version: !ruby/object:Gem::Version
-  version: 0.10.2
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.11.0
 platform: ruby
-authors:
+authors: 
 - Thomas Statter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-21 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-10-23 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: spreadsheet
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: rubyzip
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-description: Comprehensive tools to import/export between Excel/CSV and ActiveRecord
-  databases, Rails apps, and any Ruby project.
+  version_requirements: *id002
+description: Comprehensive tools to import/export between Excel/CSV and ActiveRecord databases, Rails apps, and any Ruby project.
 email: rubygems@autotelik.co.uk
 executables: []
+
 extensions: []
-extra_rdoc_files:
+
+extra_rdoc_files: 
 - LICENSE.txt
 - README.markdown
 - README.rdoc
-files:
+files: 
 - .document
 - LICENSE.txt
 - README.markdown
@@ -229,28 +221,31 @@ files:
 - tasks/file_tasks.rake
 - tasks/word_to_seedfu.rake
 homepage: http://github.com/autotelik/datashift
-licenses:
+licenses: 
 - MIT
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
 requirements: []
+
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Shift data betwen Excel/CSV and any Ruby app
 test_files: []
+