datashift 0.9.0 → 0.10.0

data/lib/applications/ruby_poi_translations.rb

@@ -0,0 +1,64 @@
+# Copyright:: Autotelik Media Ltd
+# Author ::   Tom Statter
+# Date ::     July 2010
+# License::   
+#
+#
+if(DataShift::Guards::jruby?)
+  
+  require 'java'
+  
+  require 'benchmark'
+  require "poi-3.7-20101029.jar"
+  
+  module RubyPoiTranslations
+  
+    java_import 'org.apache.poi.poifs.filesystem.POIFSFileSystem'
+
+    java_import 'org.apache.poi.hssf.usermodel.HSSFCell'
+    java_import 'org.apache.poi.hssf.usermodel.HSSFWorkbook'
+    java_import 'org.apache.poi.hssf.usermodel.HSSFCellStyle'
+    java_import 'org.apache.poi.hssf.usermodel.HSSFDataFormat'
+    java_import 'org.apache.poi.hssf.usermodel.HSSFClientAnchor'
+    java_import 'org.apache.poi.hssf.usermodel.HSSFRichTextString'
+    
+    java_import 'org.apache.poi.hssf.util.HSSFColor'
+
+    java_import 'java.io.ByteArrayOutputStream'
+    java_import 'java.util.Date'
+    java_import 'java.io.FileInputStream'
+    java_import 'java.io.FileOutputStream'
+    
+    # Cell.CELL_TYPE_NUMERIC, Cell.CELL_TYPE_STRING, Cell.CELL_TYPE_FORMULA, 
+    # Cell.CELL_TYPE_BLANK, Cell.CELL_TYPE_BOOLEAN, Cell.CELL_TYPE_ERROR
+
+    def cell_value(cell)
+      case (cell.getCellType())
+      when HSSFCell::CELL_TYPE_FORMULA  then return cell.getCellFormula()
+      when HSSFCell::CELL_TYPE_NUMERIC  then return cell.getNumericCellValue()
+      when HSSFCell::CELL_TYPE_STRING   then return cell.getStringCellValue()
+      when HSSFCell::CELL_TYPE_BOOLEAN  then return cell.getBooleanCellValue()
+      when HSSFCell::CELL_TYPE_ERROR    then return cell.getErrorCellValue()
+
+      when HSSFCell::CELL_TYPE_BLANK    then return ""
+      end
+    end
+    
+    # Return the suitable type for a HSSFCell from a Ruby data type
+    
+    def poi_cell_type(data)
+        
+      if(data.kind_of?(Numeric))
+        HSSFCell::CELL_TYPE_NUMERIC
+      elsif(data.nil?)
+        HSSFCell::CELL_TYPE_BLANK
+      elsif(data.is_a?(TrueClass) || data.is_a?(FalseClass))
+        HSSFCell::CELL_TYPE_BOOLEAN
+      else
+        HSSFCell::CELL_TYPE_STRING
+      end
+      # HSSFCell::CELL_TYPE_FORMULA
+    end
+  end
+  
+end

data/lib/applications/spreadsheet_extensions.rb

@@ -0,0 +1,31 @@
+# Copyright:: Autotelik Media Ltd
+# Author ::   Tom Statter
+# Date ::     July 2010
+# License::   
+#
+#
+# Extend the Sporeadsheet classes with some of our common methods
+# 
+# ... to do extract into separate module with pure ruby that works with both POI and Spreadsheet
+
+require 'excel_base'
+  
+class Spreadsheet::Worksheet 
+     
+   include ExcelBase
+    
+  # Convert array into a header row
+  def set_headers(headers, apply_style = nil)
+    return if headers.empty?
+
+    headers.each_with_index do |datum, i|
+      self[0, i] = datum
+    end
+  end
+  
+  def num_rows
+    rows.size
+  end
+  
+end
+  

data/lib/datashift/method_details_manager.rb

@@ -50,9 +50,13 @@ module DataShift
       @method_details_list[type.to_sym] || []
     end
     
+    alias_method(:get_list_of_method_details, :get_list) 
+    
     def get_operators( op_type )
       get_list(op_type).collect { |md| md.operator }
     end
+    
+    alias_method(:get_list_of_operators, :get_list) 
      
     def all_available_operators
       method_details_list.values.flatten.collect(&:operator)

data/lib/exporters/csv_exporter.rb

@@ -47,7 +47,7 @@ module DataShift
       
       File.open(f, "w") do |csv|
         
-        headers = first.serializable_hash.keys.collect
+        headers = first.serializable_hash.keys
            
         [*options[:methods]].each do |c| headers << c if(first.respond_to?(c)) end if(options[:methods])
              
@@ -125,6 +125,8 @@ module DataShift
               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)
                 

data/lib/exporters/excel_exporter.rb

@@ -12,108 +12,93 @@ module DataShift
 
   require 'exporter_base'
       
-  if(Guards::jruby?)
+  require 'excel'
 
-    require 'jruby/jexcel_file'
+  class ExcelExporter < ExporterBase
 
-    class ExcelExporter < ExporterBase
-
-      attr_accessor :filename
+    attr_accessor :filename
   
-      def initialize(filename)
-        @filename = filename
-      end
+    def initialize(filename)
+      @filename = filename
+    end
 
   
-      # Create an Excel file from list of ActiveRecord objects
-      def export(records, options = {})
+    # Create an Excel file from list of ActiveRecord objects
+    def export(records, options = {})
         
-        raise ArgumentError.new('Please supply array of records to export') unless records.is_a? Array
+      raise ArgumentError.new('Please supply array of records to export') unless records.is_a? Array
 
-        excel = JExcelFile.new()
+      excel = Excel.new
 
-        if(options[:sheet_name] )
-          excel.create_sheet( options[:sheet_name] ) 
-        else
-          excel.create_sheet( records.first.class.name )
-        end
+      if(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_headers(records)
         
-        excel.ar_to_xls(records)
-
-              
-        # => :methods => List of methods to additionally export on each record
-         
-        excel.save( filename() )
-      end
+      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]
-      #
-      def export_with_associations(klass, items, options = {})
+    # 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, items, options = {})
 
-        excel = JExcelFile.new()
+      excel = Excel.new
 
-        if(options[:sheet_name] )
-          excel.create_sheet( options[:sheet_name] ) 
-        else
-          excel.create_sheet( items.first.class.name )
-        end
+      if(options[:sheet_name] )
+        excel.create_worksheet( :name => options[:sheet_name] ) 
+      else
+        excel.create_worksheet( :name => items.first.class.name )
+      end
         
-        MethodDictionary.find_operators( klass )
+      MethodDictionary.find_operators( klass )
          
-        MethodDictionary.build_method_details( klass )
+      MethodDictionary.build_method_details( klass )
            
-        work_list = options[:with] || MethodDetail::supported_types_enum
+      work_list = options[:with] || MethodDetail::supported_types_enum
         
-        headers = []
-        puts "work_list :  [#{work_list.inspect}]"
+      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|
+      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)
+        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?)
+        next if(list_for_class_and_op.nil? || list_for_class_and_op.empty?)
 
-          # method_details = MethodDictionary.send("#{mdtype}_for", klass)
+        # 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
-         
+        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 )
+        excel.set_headers( headers )
         
-          row_index = 1
+        row = 1
+        column = 0
         
-          items.each do |datum| 
-            excel.create_row(row_index += 1)
-            excel.ar_to_xls_row(1, datum)
-          end
-           
-          excel.save( filename() )
+        items.each do |row_of_data| 
+          excel.ar_to_xls_row(row, column, row_of_data)
+          row += 1
         end
-      end
-    end # ExcelGenerator
-
-  else
-    class  ExcelExporter < ExporterBase
-      
-      def initialize(filename)
-        raise DataShift::BadRuby, "Apologies but DataShift Excel facilities currently need JRuby. Please switch to, or install JRuby"
+           
+        excel.write( filename() )
       end
     end
-  end # jruby
+  end # ExcelGenerator
   
 end # DataShift

data/lib/generators/excel_generator.rb

@@ -12,111 +12,107 @@ module DataShift
 
   require 'generator_base'
       
-  if(Guards::jruby?)
+  require 'excel'
 
-    require 'jruby/jexcel_file'
+  class ExcelGenerator < GeneratorBase
 
-    class ExcelGenerator < GeneratorBase
-
-      include DataShift::Logging
+    include DataShift::Logging
       
-      attr_accessor :excel, :filename
+    attr_accessor :excel, :filename
   
-      def initialize(filename)
-        @filename = filename
-      end
+    def initialize(filename)
+      @filename = filename
+    end
 
-      # Create an Excel file template (header row) representing supplied Model
-      # Options:
-      # * <tt>:autosize</tt> - Autosize all the columns
-      #
-      def generate(klass, options = {})
+    # Create an Excel file template (header row) representing supplied Model
+    # Options:
+    # * <tt>:autosize</tt> - Autosize all the columns
+    #
+    def generate(klass, options = {})
      
-        prepare(klass, options)
+      prepare_excel(klass, options)
         
-        @excel.set_headers(MethodDictionary.assignments[klass])
+      @excel.set_headers(MethodDictionary.assignments[klass])
 
-        logger.info("ExcelGenerator saving generated template #{@filename}")
+      logger.info("ExcelGenerator saving generated template #{@filename}")
         
-        @excel.autosize if(options[:autosize])
+      #@excel.autosize if(options[:autosize])
         
-        @excel.save( @filename )
-      end
+      @excel.write( @filename )
+    end
 
       
-      # Create an Excel file template (header row) representing supplied Model
-      # and it's associations
-      # 
-      # Options:
-      # * <tt>:autosize</tt> - Autosize all the columns
-      #
-      # * <tt>:exclude</tt> - Associations to exclude.
-      #   You can specify a hash of {association_type => [array of association names] }
-      #   to exclude from the template.
-      #   
-      # Possible association_type values are given by MethodDetail::supported_types_enum
-      #  ... [:assignment, :belongs_to, :has_one, :has_many]
-      #
-      def generate_with_associations(klass, options = {})
+    # Create an Excel file template (header row) representing supplied Model
+    # and it's associations
+    # 
+    # Options:
+    # * <tt>:autosize</tt> - Autosize all the columns
+    #
+    # * <tt>:exclude</tt> - Association TYPE(s) to exclude.
+    #   You can specify a hash of {association_type => [array of association names] }
+    #   to exclude from the template.
+    #   
+    #     Possible association_type values are given by MethodDetail::supported_types_enum
+    #       ... [:assignment, :belongs_to, :has_one, :has_many]
+    #       
+    # * <tt>:remove</tt> - Association NAME(s) to remove .. :title, :id, :name
+    # .
+    def generate_with_associations(klass, options = {})
 
-        prepare(klass, options)
+      prepare_excel(klass, options)
          
-        MethodDictionary.build_method_details( klass )
+      MethodDictionary.build_method_details( klass )
            
-        work_list = MethodDetail::supported_types_enum.to_a
-        work_list -= options[:exclude].to_a
+      work_list = MethodDetail::supported_types_enum.to_a - [ *options[:exclude] ]
+        
+      remove_list = [ *options[:remove] ].compact.collect{|x| x.to_s.downcase.to_sym }
          
-        headers = []
+      headers = []
       
-        details_mgr = MethodDictionary.method_details_mgrs[klass]
+      details_mgr = MethodDictionary.method_details_mgrs[klass]
                   
-        work_list.each do |op_type|
-          list_for_class_and_op = details_mgr.get_list(op_type)
+      work_list.each do |assoc_type|
+        method_details_for_assoc_type = details_mgr.get_list_of_method_details(assoc_type)
           
-          next if(list_for_class_and_op.nil? || list_for_class_and_op.empty?)
-          list_for_class_and_op.each {|md| headers << "#{md.operator}" }
+        next if(method_details_for_assoc_type.nil? || method_details_for_assoc_type.empty?)
+        
+        method_details_for_assoc_type.each do |md| 
+          comparable_association = md.operator.to_s.downcase.to_sym
+
+          i = remove_list.index { |r| r == comparable_association }
+             
+          (i) ? remove_list.delete_at(i) : headers << "#{md.operator}"
         end
+      end
         
-        @excel.set_headers( headers )
+      @excel.set_headers( headers )
         
-        @excel.autosize if(options[:autosize])
+      # @excel.autosize if(options[:autosize])
                 
-        @excel.save( filename() )
-      end
+      @excel.write( filename() )
+    end
       
-      private
+    private
       
-      def prepare(klass, options = {})
-        @filename = options[:filename] if  options[:filename]
+    def prepare_excel(klass, options = {})
+      @filename = options[:filename] if  options[:filename]
         
-        logger.info("ExcelGenerator creating template with associations for class #{klass}")
+      logger.info("ExcelGenerator creating template with associations for class #{klass}")
         
-        @excel = JExcelFile.new()
+      @excel = Excel.new()
 
-        if(options[:sheet_name] )
-          @excel.create_sheet( options[:sheet_name] ) 
-        else
-          @excel.create_sheet( klass.name )
-        end
+      name  = options[:sheet_name] || klass.name
         
-        unless @excel.sheet
-          logger.error("Excel failed to create WorkSheet for #{klass.name}")
-        
-          raise "Failed to create Excel WorkSheet for #{klass.name}" 
-        end
+      sheet = @excel.create_worksheet( :name => name ) 
+    
+      unless sheet
+        logger.error("Excel failed to create WorkSheet for #{name}")
         
-        MethodDictionary.find_operators( klass )
-      end
-    end # ExcelGenerator
-
-  else
-    class  ExcelGenerator < GeneratorBase
-      
-      def initialize(filename)
-        @filename = filename
-        raise DataShift::BadRuby, "Apologies but DataShift Excel facilities currently need JRuby. Please switch to, or install JRuby"
+        raise "Failed to create Excel WorkSheet for #{name}" 
       end
+        
+      MethodDictionary.find_operators( klass )
     end
-  end # jruby
+  end # ExcelGenerator
   
 end # DataShift