spreadsheet_architect 1.4.8 → 2.0.0

data/lib/spreadsheet_architect/action_controller_renderers.rb

@@ -1,23 +1,13 @@
 if defined? ActionController
-  ActionController::Renderers.add :xlsx do |data, options|
-    if data.is_a?(ActiveRecord::Relation)
-      options[:filename] = data.klass.name.pluralize
-      data = data.to_xlsx
+
+  ['csv','ods','xlsx'].each do |format|
+    ActionController::Renderers.add(format.to_sym) do |data, options|
+      if data.is_a?(ActiveRecord::Relation)
+        options[:filename] = data.klass.name.pluralize
+        data = data.send("to_#{format}")
+      end
+      send_data data, type: format.to_sym, disposition: :attachment, filename: "#{options[:filename] ? options[:filename].sub(".#{format}",'') : 'data'}.#{format}"
     end
-    send_data data, type: :xlsx, disposition: :attachment, filename: "#{options[:filename] ? options[:filename].sub('.xlsx','') : 'data'}.xlsx"
-  end
-  ActionController::Renderers.add :ods do |data, options|
-    if data.is_a?(ActiveRecord::Relation)
-      options[:filename] = data.klass.name.pluralize
-      data = data.to_ods
-    end
-    send_data data, type: :ods, disposition: :attachment, filename: "#{options[:filename] ? options[:filename].sub('.ods','') : 'data'}.ods"
-  end
-  ActionController::Renderers.add :csv do |data, options|
-    if data.is_a?(ActiveRecord::Relation)
-      options[:filename] = data.klass.name.pluralize
-      data = data.to_csv
-    end
-    send_data data, type: :csv, disposition: :attachment, filename: "#{options[:filename] ? options[:filename].sub('.csv','') : 'data'}.csv"
   end
+
 end

data/lib/spreadsheet_architect/class_methods/csv.rb

@@ -0,0 +1,22 @@
+require 'csv'
+
+module SpreadsheetArchitect
+  module ClassMethods
+    def to_csv(opts={})
+      opts = SpreadsheetArchitect::Utils.get_cell_data(opts, self)
+      options = SpreadsheetArchitect::Utils.get_options(opts, self)
+
+      CSV.generate do |csv|
+        if options[:headers]
+          options[:headers].each do |header_row|
+            csv << header_row
+          end
+        end
+        
+        options[:data].each do |row_data|
+          csv << row_data
+        end
+      end
+    end
+  end
+end

data/lib/spreadsheet_architect/class_methods/ods.rb

@@ -0,0 +1,61 @@
+require 'rodf'
+
+module SpreadsheetArchitect
+  module ClassMethods
+    def to_ods(opts={})
+      return to_rodf_spreadsheet(opts).bytes
+    end
+
+    def to_rodf_spreadsheet(opts={}, spreadsheet=nil)
+      opts = SpreadsheetArchitect::Utils.get_cell_data(opts, self)
+      options = SpreadsheetArchitect::Utils.get_options(opts, self)
+
+      if !spreadsheet
+        spreadsheet = RODF::Spreadsheet.new
+      end
+
+      spreadsheet.office_style :header_style, family: :cell do
+        if options[:header_style]
+          SpreadsheetArchitect::Utils.convert_styles_to_ods(options[:header_style]).each do |prop, styles|
+            styles.each do |k,v|
+              property prop.to_sym, k => v
+            end
+          end
+        end
+      end
+
+      spreadsheet.office_style :row_style, family: :cell do
+        if options[:row_style]
+          SpreadsheetArchitect::Utils.convert_styles_to_ods(options[:row_style]).each do |prop, styles|
+            styles.each do |k,v|
+              property prop.to_sym, k => v
+            end
+          end
+        end
+      end
+
+      spreadsheet.table options[:sheet_name] do 
+        if options[:headers]
+          options[:headers].each do |header_row|
+            row do
+              header_row.each_with_index do |header, i|
+                cell header, style: :header_style
+              end
+            end
+          end
+        end
+
+        options[:data].each_with_index do |row_data, index|
+          row do 
+            row_data.each_with_index do |y,i|
+              cell y, style: :row_style, type: (options[:types][i] if options[:types])
+            end
+          end
+        end
+      end
+
+      return spreadsheet
+    end
+
+  end
+end

data/lib/spreadsheet_architect/class_methods/xlsx.rb

@@ -0,0 +1,162 @@
+require 'axlsx'
+require 'axlsx_styler'
+
+require 'spreadsheet_architect/monkey_patches/axlsx_column_width'
+
+module SpreadsheetArchitect
+  module ClassMethods
+    def to_xlsx(opts={})
+      return to_axlsx_package(opts).to_stream.read
+    end
+
+    def to_axlsx_package(opts={}, package=nil)
+      opts = SpreadsheetArchitect::Utils.get_cell_data(opts, self)
+      options = SpreadsheetArchitect::Utils.get_options(opts, self)
+    
+      header_style = SpreadsheetArchitect::Utils::XLSX.convert_styles_to_axlsx(options[:header_style])
+      row_style = SpreadsheetArchitect::Utils::XLSX.convert_styles_to_axlsx(options[:row_style])
+
+      if package.nil?
+        package = Axlsx::Package.new
+      end
+
+      return package if !options[:headers] && options[:data].empty?
+
+      package.workbook.add_worksheet(name: options[:sheet_name]) do |sheet|
+        max_row_length = options[:data].empty? ? 0 : options[:data].max_by{|x| x.length}.length
+
+        if options[:headers]
+          header_style_index = package.workbook.styles.add_style(header_style)
+
+          options[:headers].each do |header_row|
+            missing = max_row_length - header_row.count
+            if missing > 0
+              missing.times do
+                header_row.push(nil)
+              end
+            end
+
+            sheet.add_row header_row, style: header_style_index
+          end
+        end
+
+        if options[:data].empty?
+          break
+        end
+
+        row_style_index = package.workbook.styles.add_style(row_style)
+
+        options[:data].each do |row_data|
+          missing = max_row_length - row_data.count
+          if missing > 0
+            missing.times do
+              row_data.push(nil)
+            end
+          end
+
+          types = []
+          row_data.each_with_index do |x,i|
+            if (x.respond_to?(:empty) ? x.empty? : x.nil?)
+              types[i] = nil
+            else
+              if options[:column_types]
+                types[i] = options[:column_types][i]
+              end
+
+              types[i] ||= SpreadsheetArchitect::Utils::XLSX.get_type(x)
+            end
+          end
+
+          sheet.add_row row_data, style: row_style_index, types: types
+        end
+
+        options[:data].first.each_with_index do |x,i|
+          types = []
+
+          if options[:column_types]
+            types[i] = options[:column_types][i]
+          end
+
+          types[i] ||= SpreadsheetArchitect::Utils::XLSX.get_type(x)
+
+          if [:date, :time].include?(types[i])
+            if types[i] == :date
+              format_code = 'm/d/yyyy'
+            else
+              format_code = 'yyyy/m/d h:mm AM/PM'
+            end
+
+            sheet.col_style(i, package.workbook.styles.add_style(format_code: format_code), row_offset: (options[:headers] ? options[:headers].count : 0))
+          end
+        end
+
+        if options[:column_widths]
+          sheet.column_widths(*options[:column_widths])
+        end
+
+        if options[:borders] || options[:column_styles] || options[:range_styles] || options[:merges]
+          col_names = max_row_length > 675 ? Array('A'..'ZZZ') : Array('A'..'ZZ')
+          num_rows = options[:data].count
+        end
+
+        if options[:borders]
+          options[:borders].each do |x|
+            if x[:range].is_a?(Hash)
+              x[:range] = SpreadsheetArchitect::Utils::XLSX.range_hash_to_str(x[:range], max_row_length, num_rows, col_names)
+            end
+
+            SpreadsheetArchitect::Utils::XLSX.verify_range(x[:range], num_rows, col_names)
+            sheet.add_border x[:range], x[:border_styles]
+          end
+        end
+
+        if options[:column_styles]
+          options[:column_styles].each do |x|
+            start_row = !x[:include_header] && options[:headers] ? options[:headers].count : 0
+
+            package.workbook.styles do |s|
+              style = s.add_style row_style.merge(SpreadsheetArchitect::Utils::XLSX.convert_styles_to_axlsx(x[:styles]))
+              if x[:columns].is_a?(Array) || x[:columns].is_a?(Range) 
+                x[:columns].each do |col|
+                  if col.is_a?(String)
+                    col = col_names.index(col)
+                  end
+
+                  sheet.col_style(col, style, row_offset: start_row)
+                end
+              elsif x[:columns].is_a?(Integer)
+                sheet.col_style(x[:columns], style, row_offset: start_row)
+              end
+            end
+          end
+        end
+
+        if options[:range_styles]
+          options[:range_styles].each do |x|
+            styles = SpreadsheetArchitect::Utils::XLSX.convert_styles_to_axlsx(x[:styles])
+
+            if x[:range].is_a?(Hash)
+              x[:range] = SpreadsheetArchitect::Utils::XLSX.range_hash_to_str(x[:range], max_row_length, num_rows, col_names)
+            end
+
+            SpreadsheetArchitect::Utils::XLSX.verify_range(x[:range], num_rows, col_names)
+            sheet.add_style x[:range], styles
+          end
+        end
+
+        if options[:merges]
+          options[:merges].each do |x|
+            if x[:range].is_a?(Hash)
+              x[:range] = SpreadsheetArchitect::Utils::XLSX.range_hash_to_str(x[:range], max_row_length, num_rows, col_names)
+            end
+
+            SpreadsheetArchitect::Utils::XLSX.verify_range(x[:range], num_rows, col_names)
+            sheet.merge_cells x[:range]
+          end
+        end
+      end
+
+      return package
+    end
+  end
+end

data/lib/spreadsheet_architect/exceptions.rb

@@ -0,0 +1,47 @@
+module SpreadsheetArchitect
+  module Exceptions
+
+    class NoDataError < StandardError
+      def initialize
+        super("Missing :data option")
+      end
+    end
+
+    class NoInstancesError < StandardError
+      def initialize
+        super("Missing :instances option")
+      end
+    end
+
+    class IncorrectTypeError < StandardError
+      def initialize(option=nil)
+        super("Incorrect data type for :#{option} option")
+      end
+    end
+    
+    class SpreadsheetColumnsNotDefinedError < StandardError
+      def initialize(klass=nil)
+        super("The spreadsheet_columns option is not defined on #{klass.name}")
+      end
+    end
+
+    class InvalidRangeStylesOptionError < StandardError
+      def initialize(type)
+        super("Invalid type for range_styles #{type} option. Allowed formats are Integer, Range, or :all")
+      end
+    end
+
+    class BadRangeError < StandardError
+      def initialize(type)
+        case type
+        when :columns, :rows
+          super("Bad range passed. Some of the #{type} specified were greater than the total number of #{type}")
+        when :format
+          super('Bad range passed. Format must be as follows: A1:D4')
+        when :type
+          super('Incorrect range type. Valid types are String and Hash')
+        end
+      end
+    end
+  end
+end

data/lib/spreadsheet_architect/{set_mime_types.rb → mime_types.rb}

@@ -5,6 +5,4 @@ if defined? Mime
   unless defined? Mime::ODS
     Mime::Type.register "application/vnd.oasis.opendocument.spreadsheet", :ods
   end
-else
-  puts "Mime module not defined. Skipping registration of xlsx & ods"
 end

data/lib/spreadsheet_architect/monkey_patches/axlsx_column_width.rb

@@ -0,0 +1,23 @@
+if defined? Axlsx
+  module Axlsx
+    class Col
+      original_initialize = instance_method(:initialize)
+      define_method :initialize do |*args|
+        @width = nil
+
+        original_initialize.bind(self).(*args)
+      end
+
+      def width=(v)
+        if v.nil?
+          @custom_width = false
+          @width = nil
+        elsif @width.nil? || @width < v+5
+          @custom_width = @best_fit = v != nil
+          @width = v + 5
+        end
+      end
+
+    end
+  end
+end

data/lib/spreadsheet_architect/utils.rb

@@ -0,0 +1,223 @@
+module SpreadsheetArchitect
+  module Utils
+    def self.str_humanize(str, capitalize = true)
+      str = str.sub(/\A_+/, '').gsub(/[_\.]/,' ').sub(' rescue nil','')
+      if capitalize
+        str = str.gsub(/(\A|\ )\w/){|x| x.upcase}
+      end
+      return str
+    end
+
+    def self.get_cell_data(options={}, klass)
+      self.check_options_types
+
+      if klass.name == 'SpreadsheetArchitect'
+        if !options[:data]
+          raise SpreadsheetArchitect::Exceptions::NoDataError
+        end
+
+        if options[:headers] && options[:headers].is_a?(Array) && !options[:headers].empty?
+          headers = options[:headers]
+        else
+          headers = false
+        end
+        
+        data = options[:data]
+      else
+        has_custom_columns = options[:spreadsheet_columns] || klass.instance_methods.include?(:spreadsheet_columns)
+
+        if !options[:instances] && defined?(ActiveRecord) && klass.ancestors.include?(ActiveRecord::Base)
+          options[:instances] = klass.where(nil).to_a # triggers the relation call, not sure how this works but it does
+        end
+
+        if !options[:instances]
+          raise SpreadsheetArchitect::Exceptions::NoInstancesError
+        end
+
+        if options[:headers].nil?
+          headers = klass::SPREADSHEET_OPTIONS[:headers] if defined?(klass::SPREADSHEET_OPTIONS)
+          headers ||= SpreadsheetArchitect.default_options[:headers]
+        elsif options[:headers].is_a?(Array)
+          headers = options[:headers]
+        end
+
+        if headers == false || headers.is_a?(Array)
+          needs_headers = false
+        else
+          headers = true
+          needs_headers = true
+        end
+
+        if has_custom_columns 
+          headers = [] if needs_headers
+          columns = []
+          array = options[:spreadsheet_columns] || (options[:instances].empty? ? [] : options[:instances].first.spreadsheet_columns)
+          array.each_with_index do |x,i|
+            if x.is_a?(Array)
+              headers.push(x[0].to_s) if needs_headers
+              columns.push x[1]
+            else
+              headers.push(str_humanize(x.to_s)) if needs_headers
+              columns.push x
+            end
+          end
+        elsif !has_custom_columns && defined?(ActiveRecord) && klass.ancestors.include?(ActiveRecord::Base)
+          ignored_columns = ["id","created_at","updated_at","deleted_at"] 
+          the_column_names = (klass.column_names - ignored_columns)
+          headers = the_column_names.map{|x| str_humanize(x)} if needs_headers
+          columns = the_column_names.map{|x| x.to_sym}
+        else
+          raise SpreadsheetArchitect::Exceptions::SpreadsheetColumnsNotDefinedError, klass
+        end
+
+        data = []
+        options[:instances].each do |instance|
+          if has_custom_columns && !options[:spreadsheet_columns]
+            row_data = []
+            instance.spreadsheet_columns.each do |x|
+              if x.is_a?(Array)
+                row_data.push(x[1].is_a?(Symbol) ? instance.instance_eval(x[1].to_s) : x[1])
+              else
+                row_data.push(x.is_a?(Symbol) ? instance.instance_eval(x.to_s) : x)
+              end
+            end
+            data.push row_data
+          else
+            data.push columns.map{|col| col.is_a?(Symbol) ? instance.instance_eval(col.to_s) : col}
+          end
+        end
+      end
+
+      if headers && !headers[0].is_a?(Array)
+        headers = [headers]
+      end
+
+      return options.merge(headers: headers, data: data, column_types: options[:column_types])
+    end
+
+    def self.get_options(options={}, klass)
+      if options[:headers]
+        if defined?(klass::SPREADSHEET_OPTIONS)
+          header_style = SpreadsheetArchitect.default_options[:header_style].merge(klass::SPREADSHEET_OPTIONS[:header_style] || {})
+        else
+          header_style = SpreadsheetArchitect.default_options[:header_style]
+        end
+        
+        if options[:header_style]
+          header_style.merge!(options[:header_style])
+        elsif options[:header_style] == false
+          header_style = false
+        end
+      else
+        header_style = false
+      end
+
+      if options[:row_style] == false
+        row_style = false
+      else
+        if defined?(klass::SPREADSHEET_OPTIONS)
+          row_style = SpreadsheetArchitect.default_options[:row_style].merge(klass::SPREADSHEET_OPTIONS[:row_style] || {})
+        else
+          row_style = SpreadsheetArchitect.default_options[:row_style]
+        end
+
+        if options[:row_style]
+          row_style.merge!(options[:row_style])
+        end
+      end
+
+      if defined?(klass::SPREADSHEET_OPTIONS)
+        sheet_name = options[:sheet_name] || klass::SPREADSHEET_OPTIONS[:sheet_name] || SpreadsheetArchitect.default_options[:sheet_name]
+      else
+        sheet_name = options[:sheet_name] || SpreadsheetArchitect.default_options[:sheet_name]
+      end
+
+      sheet_name ||= (klass.name == 'SpreadsheetArchitect' ? 'Sheet1' : klass.name)
+
+      return options.merge(header_style: header_style, row_style: row_style, sheet_name: sheet_name)
+    end
+
+    def self.convert_styles_to_ods(styles={})
+      styles = {} unless styles.is_a?(Hash)
+      styles = self.stringify_keys(styles)
+
+      property_styles = {}
+
+      text_styles = {}
+      text_styles['font-weight'] = styles.delete('bold') ? 'bold' : styles.delete('font-weight')
+      text_styles['font-size'] = styles.delete('font_size') || styles.delete('font-size')
+      text_styles['font-style'] = styles.delete('italic') ? 'italic' : styles.delete('font-style')
+      if styles['underline']
+        styles.delete('underline')
+        text_styles['text-underline-style'] = 'solid'
+        text_styles['text-underline-type'] = 'single'
+      end
+      if styles['align']
+        text_styles['align'] = true
+      end 
+      if styles['color'].respond_to?(:sub) && !styles['color'].empty?
+        text_styles['color'] = "##{styles.delete('color').sub('#','')}"
+      end
+      text_styles.delete_if{|_,v| v.nil?}
+      property_styles['text'] = text_styles
+      
+      cell_styles = {}
+      styles['background_color'] ||= styles.delete('background-color')
+      if styles['background_color'].respond_to?(:sub) && !styles['background_color'].empty?
+        cell_styles['background-color'] = "##{styles.delete('background_color').sub('#','')}"
+      end
+
+      cell_styles.delete_if{|_,v| v.nil?}
+      property_styles['cell'] = cell_styles
+
+      return property_styles
+    end
+
+    private
+
+    def self.check_type(options, option_name, type)
+      unless options[option_name].nil?
+        valid = false
+
+        if type.is_a?(Array)
+          valid = type.any?{|t| options[option_name].is_a?(t)}
+        elsif options[option_name].is_a?(type)
+          valid = true
+        end
+
+        if valid
+          raise SpreadsheetArchitect::Exceptions::IncorrectTypeError option_name
+        end
+      end
+    end
+
+    def self.check_options_types(options={})
+      self.check_type(options, :spreadsheet_columns, Array)
+      self.check_type(options, :instances, Array)
+      self.check_type(options, :headers, [TrueClass, FalseClass, Array])
+      self.check_type(options, :sheet_name, String)
+      self.check_type(options, :header_style, Hash)
+      self.check_type(options, :row_style, Hash)
+      self.check_type(options, :column_styles, Array)
+      self.check_type(options, :range_styles, Array)
+      self.check_type(options, :merges, Array)
+      self.check_type(options, :borders, Array)
+      self.check_type(options, :column_widths, Array)
+    end
+
+    # only converts the first 2 levels
+    def self.stringify_keys(hash={})
+      new_hash = {}
+      hash.each do |k,v|
+        if v.is_a?(Hash)
+          v.each do |k2,v2|
+            new_hash[k2.to_s] = v2
+          end
+        else
+          new_hash[k.to_s] = v
+        end
+      end
+      return new_hash
+    end
+  end
+end