datashift 0.15.0 → 0.16.0

data/lib/datashift/thor_base.rb

@@ -0,0 +1,38 @@
+# Copyright:: (c) Autotelik Media Ltd 2012
+# Author ::   Tom Statter
+# Date ::     Dec 2014
+# License::   MIT.
+#
+# Note, not DataShift, case sensitive, create namespace for command line : datashift
+require 'thor'
+
+module DataShift
+
+  class DSThorBase < Thor
+
+    include DataShift::Logging
+
+    no_commands do
+
+      def start_connections()
+
+        # TODO - We're assuming run from a rails app/top level dir...
+
+        if(File.exists?(File.expand_path('config/environment.rb')))
+          begin
+            require File.expand_path('config/environment.rb')
+          rescue => e
+            logger.error("Failed to initialise ActiveRecord : #{e.message}")
+            raise ConnectionError.new("No config/environment.rb found - cannot initialise ActiveRecord")
+          end
+
+        else
+          raise PathError.new("No config/environment.rb found - cannot initialise ActiveRecord")
+          # TODO make this more robust ? e.g what about when using active record but not in Rails app, Sinatra etc
+        end
+      end
+    end
+
+  end
+
+end

data/lib/exporters/csv_exporter.rb

@@ -7,27 +7,19 @@
 #
 #
 require 'exporter_base'
-require 'csv'
+require 'csv_file'
 
 module DataShift
 
   class CsvExporter < ExporterBase
-     
+
     include DataShift::Logging
-    
-    attr_accessor :text_delim
-    
+    include DataShift::ColumnPacker
+
     def initialize(filename)
       super(filename)
-      @text_delim = "\'"
     end
 
-    # Return opposite of text delim - "hello, 'barry'" => '"hello, "barry""'
-    def escape_text_delim
-      return '"' if @text_delim == "\'"
-      "\'"
-    end
-    
     # Create CSV file from set of ActiveRecord objects
     # Options :
     # => :filename
@@ -35,161 +27,81 @@ module DataShift
     # => ::methods => List of methods to additionally call on each record
     #
     def export(export_records, options = {})
-      
+
       records = [*export_records]
-       
-            
-      puts records, records.inspect
-      
+
       unless(records && records.size > 0)
-        logger.warn("No objects supplied for export") 
-        return 
+        logger.warn("No objects supplied for export")
+        return
       end
-      
+
       first = records[0]
-     
+
       raise ArgumentError.new('Please supply set of ActiveRecord objects to export') unless(first.is_a?(ActiveRecord::Base))
- 
-      f = options[:filename] || filename()
-      
-      @text_delim = options[:text_delim] if(options[:text_delim])
-      
-      File.open(f, "w") do |csv|
-        
-        headers = first.serializable_hash.keys
-           
-        [*options[:methods]].each do |c| headers << c if(first.respond_to?(c)) end if(options[:methods])
-             
-        csv << headers.join(Delimiters::csv_delim) << Delimiters::eol
-        
+
+      Delimiters.text_delim = options[:text_delim] if(options[:text_delim])
+
+      CSV.open( (options[:filename] || filename), "w" ) do |csv|
+
+        csv.ar_to_headers( records )
+
         records.each do |r|
           next unless(r.is_a?(ActiveRecord::Base))
-          
-          csv << record_to_csv(r, options) << Delimiters::eol
+          csv.ar_to_csv(r, options)
         end
       end
     end
-      
+
     # Create an Excel file from list of ActiveRecord objects
     # Specify which associations to export via :with or :exclude
     # Possible values are : [:assignment, :belongs_to, :has_one, :has_many]
     #
     def export_with_associations(klass, records, options = {})
-        
-      f = options[:filename] || filename()
-      
-      @text_delim = options[:text_delim] if(options[:text_delim])
-       
+
+      Delimiters.text_delim = options[:text_delim] if(options[:text_delim])
+
       MethodDictionary.find_operators( klass )
-        
-      # builds all possible operators
+
       MethodDictionary.build_method_details( klass )
-           
-      work_list = options[:with] ? Set(options[:with]) : MethodDetail::supported_types_enum
-      
-      assoc_work_list = work_list.dup
-
-      details_mgr = MethodDictionary.method_details_mgrs[klass]
-
-      headers, assoc_operators, assignments = [], [], []
-      
-      # headers
-      if(work_list.include?(:assignment))
-        assignments << details_mgr.get_list(:assignment).collect( &:operator)
-        assoc_work_list.delete :assignment
-      end
-         
-      headers << assignments.flatten!
-      # based on users requested list ... belongs_to has_one, has_many etc ... select only those operators
-      assoc_operators = assoc_work_list.collect do |op_type|     
-        details_mgr.get_list(op_type).collect(&:operator).flatten
-      end
-      
-      assoc_operators.flatten!
-      
-      File.open(f, "w") do |csv|  
-          
-        csv << headers.join(Delimiters::csv_delim)
-        
-        csv << Delimiters::csv_delim << assoc_operators.join(Delimiters::csv_delim) unless(assoc_operators.empty?)
-        
-        csv << Delimiters::eol
-        
-        records.each do |r|
-          next unless(r.is_a?(ActiveRecord::Base))
-          
-          csv_columns = []
-          # need to make sure order matches headers
-          # could look at collection headers via serializable hash.keys and then use 
-          # csv << record_to_csv(r) ??
-          assignments.each {|x| csv << escape(r.send(x)) << Delimiters::csv_delim }
-                 
-          # done records basic attributes now deal with associations
-          
-          #assoc_work_list.each do |op_type| 
-          # details_mgr.get_operators(op_type).each do |operator| 
-          assoc_operators.each do |operator| 
-            assoc_object = r.send(operator) 
-              
-            if(assoc_object.is_a?ActiveRecord::Base)
-              column_text = record_to_column(assoc_object)     # belongs_to or has_one
-                
-              # TODO -ColumnPacker class shared between excel/csv
-              
-              csv << "#{@text_delim}#{column_text}#{@text_delim}" << Delimiters::csv_delim
-              #csv << record_to_csv(r)
-                
-            elsif(assoc_object.is_a? Array)
-              items_to_s = assoc_object.collect {|x| record_to_column(x) }
-                
-              # create a single column
-              csv << "#{@text_delim}#{items_to_s.join(Delimiters::multi_assoc_delim)}#{@text_delim}" << Delimiters::csv_delim
-                
-            else
-              csv << Delimiters::csv_delim
+
+      only  = options[:only] ? [*options[:only]] : nil
+
+      # For each type belongs has_one, has_many etc find the operators
+      # and create headers, then for each record call those operators
+      operators = options[:with] || MethodDetail::supported_types_enum
+
+      CSV.open( (options[:filename] || filename), "w" ) do |csv|
+
+        csv.ar_to_headers( records, operators, options)
+
+        details_mgr = MethodDictionary.method_details_mgrs[klass]
+
+        records.each do |obj|
+
+          row = []
+
+          operators.each do |op_type|
+
+            operators_for_type = details_mgr.get_list(op_type)
+
+            next if(operators_for_type.nil? || operators_for_type.empty?)
+
+            operators_for_type.each do |md|
+
+              next if(only && !only.include?( md.name.to_sym ) )
+
+              if(MethodDetail.is_association_type?(op_type))
+                row << record_to_column( obj.send( md.operator ))    # pack association into single column
+              else
+                row << escape_for_csv( obj.send( md.operator ) )
+              end
             end
-            #end
           end
-          
-          csv << Delimiters::eol   # next record
-          
+
+          csv << row # next record
         end
       end
-    end
-    
-  
-    # Convert an AR instance to a single CSV column
-  
-    def record_to_column(record) 
-    
-      csv_data = []
-      record.serializable_hash.each do |name, value|
-        value = 'nil' if value.nil?
-        text = value.to_s.gsub(@text_delim, escape_text_delim())
-        csv_data << "#{name.to_sym} => #{text}"
-      end
-      "#{csv_data.join(Delimiters::csv_delim)}"
-    end
-    
-    
-    # Convert an AR instance to a set of CSV columns
-    def record_to_csv(record, options = {})
-      csv_data = record.serializable_hash.values.collect { |value| escape(value) }
-
-      [*options[:methods]].each { |x| csv_data << escape(record.send(x)) if(record.respond_to?(x)) } if(options[:methods])
-      
-      csv_data.join( Delimiters::csv_delim )
-    end
-    
-
-    private
 
-    def escape(value)
-      text = value.to_s.gsub(@text_delim, escape_text_delim())
-      
-      text = "#{@text_delim}#{text}#{@text_delim}" if(text.include?(Delimiters::csv_delim)) 
-      text
     end
-    
   end
 end

data/lib/exporters/excel_exporter.rb

@@ -11,107 +11,120 @@
 module DataShift
 
   require 'exporter_base'
-      
+
   require 'excel'
 
   class ExcelExporter < ExporterBase
-    
+
     include DataShift::Logging
-  
+    include DataShift::ColumnPacker
+
     def initialize(filename)
       @filename = filename
     end
 
     # Create an Excel file from list of ActiveRecord objects
     def export(export_records, options = {})
-       
+
       records = [*export_records]
-      
-      puts records, records.inspect
-      
+
       unless(records && records.size > 0)
-        logger.warn("No objects supplied for export") 
-        return 
+        logger.warn("No objects supplied for export")
+        return
       end
-      
+
       first = records[0]
-     
+
+      logger.info("Exporting #{records.size} #{first.class} to Excel")
+
       raise ArgumentError.new('Please supply set of ActiveRecord objects to export') unless(first.is_a?(ActiveRecord::Base))
- 
-      
+
+
       raise ArgumentError.new('Please supply array of records to export') unless records.is_a? Array
 
       excel = Excel.new
 
       if(options[:sheet_name] )
-        excel.create_worksheet( :name => options[:sheet_name] ) 
+        excel.create_worksheet( :name => options[:sheet_name] )
       else
         excel.create_worksheet( :name => records.first.class.name )
       end
-   
+
       excel.ar_to_headers(records)
-        
+
       excel.ar_to_xls(records)
-  
+
       excel.write( filename() )
     end
-      
-    # Create an Excel file from list of ActiveRecord objects
-    # Specify which associations to export via :with or :exclude
-    # Possible values are : [:assignment, :belongs_to, :has_one, :has_many]
+
+    # Create an Excel file from list of ActiveRecord objects, includes relationships
+    #
+    #   Options
+    #
+    #     only          Specify (as symbols) columns (assignments) to export from klass
+    #     with:         Specify which association types to export :with
+    #                   Possible values are : [:assignment, :belongs_to, :has_one, :has_many]
+    #     with_only     Specify (as symbols) columns for association types to export
+    #     sheet_name    Else uses Class name
+    #     json:         Export association data in single column in JSON format
     #
-    def export_with_associations(klass, items, options = {})
+    def export_with_associations(klass, records, options = {})
+
+      records = [*records]
+
+      only  = options[:only] ? [*options[:only]] : nil
 
       excel = Excel.new
 
       if(options[:sheet_name] )
-        excel.create_worksheet( :name => options[:sheet_name] ) 
+        excel.create_worksheet( :name => options[:sheet_name] )
       else
-        excel.create_worksheet( :name => items.first.class.name )
+        excel.create_worksheet( :name => records.first.class.name )
       end
-        
+
       MethodDictionary.find_operators( klass )
-         
+
       MethodDictionary.build_method_details( klass )
-           
-      work_list = options[:with] || MethodDetail::supported_types_enum
-        
-      headers = []
-      
-      details_mgr = MethodDictionary.method_details_mgrs[klass]
-                    
-      data = []
+
       # For each type belongs has_one, has_many etc find the operators
       # and create headers, then for each record call those operators
-      work_list.each do |op_type|
-          
-        list_for_class_and_op = details_mgr.get_list(op_type)
-       
-        next if(list_for_class_and_op.nil? || list_for_class_and_op.empty?)
-
-        # method_details = MethodDictionary.send("#{mdtype}_for", klass)
-        
-        list_for_class_and_op.each do |md| 
-          headers << "#{md.operator}"
-          items.each do |i| 
-            data << i.send( md.operator )
-          end
-         
-        end
-        
-        excel.set_headers( headers )
-        
-        row = 1
+      operators = options[:with] || MethodDetail::supported_types_enum
+
+      excel.ar_to_headers( records, operators, options)
+
+      details_mgr = MethodDictionary.method_details_mgrs[klass]
+
+      row = 1
+
+      records.each do |obj|
+
         column = 0
-        
-        items.each do |row_of_data| 
-          excel.ar_to_xls_row(row, column, row_of_data)
-          row += 1
+
+        [*operators].each do |op_type|     # belongs_to, has_one, has_many etc
+
+          operators_for_type = details_mgr.get_list(op_type)
+
+          next if(operators_for_type.nil? || operators_for_type.empty?)
+
+          operators_for_type.each do |md|     # actual associations on obj
+
+            next if(only && !only.include?( md.name.to_sym ) )
+
+            if(MethodDetail.is_association_type?(op_type))
+              excel[row, column] = record_to_column( obj.send( md.operator ), options )    # pack association into single column
+            else
+              excel[row, column] = obj.send( md.operator )
+            end
+            column += 1
+          end
         end
-           
-        excel.write( filename() )
+
+        row += 1
       end
+
+      excel.write( filename() )
+
     end
   end # ExcelGenerator
-  
+
 end # DataShift