spreadsheet_architect 2.1.2 → 3.0.0

data/lib/spreadsheet_architect/exceptions.rb

@@ -1,33 +1,30 @@
 module SpreadsheetArchitect
   module Exceptions
 
-    class NoDataError < StandardError
-      def initialize
-        super("Missing :data option")
-      end
-    end
-
-    class NoInstancesError < StandardError
-      def initialize
-        super("Missing :instances option")
+    class InvalidRangeError < StandardError
+      def initialize(type, range)
+        case type
+        when :columns, :rows
+          super("Invalid range `#{range}` passed. Some of the #{type} specified were greater than the total number of #{type}")
+        when :format
+          super("Invalid range `#{range}` passed. Format must be as follows: A1:D4")
+        when :type
+          super("Invalid range type `#{range}`. Valid types are String and Hash")
+        else
+          super("Invalid range `#{range}` passed.")
+        end
       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}")
+    class InvalidTypeError < StandardError
+      def initialize(which)
+        super("Invalid data type for the #{which}")
       end
     end
 
     class InvalidColumnError < StandardError
-      def initialize(range_hash)
-        super("Invalid Column `#{range_hash}` given for column_types options")
+      def initialize(col)
+        super("Invalid Column `#{col}` given for column_types options")
       end
     end
 
@@ -37,16 +34,21 @@ module SpreadsheetArchitect
       end
     end
 
-    class BadRangeError < StandardError
-      def initialize(type, range)
-        case type
-        when :columns, :rows
-          super("Bad range `#{range}` passed. Some of the #{type} specified were greater than the total number of #{type}")
-        when :format
-          super("Bad range `#{range}` passed. Format must be as follows: A1:D4")
-        when :type
-          super("Incorrect range type `#{range}`. Valid types are String and Hash")
-        end
+    class NoDataError < StandardError
+      def initialize
+        super("Missing :data or :instances option")
+      end
+    end
+
+    class MultipleDataSourcesError < StandardError
+      def initialize
+        super("Both :data and :instances options cannot be combined, please choose one.")
+      end
+    end
+    
+    class SpreadsheetColumnsNotDefinedError < StandardError
+      def initialize(klass)
+        super("The instance method `spreadsheet_columns` is not defined on #{klass}")
       end
     end
   end

data/lib/spreadsheet_architect/utils/xlsx.rb

@@ -28,16 +28,12 @@ module SpreadsheetArchitect
         styles = {} unless styles.is_a?(Hash)
         styles = self.symbolize_keys(styles)
 
-        if styles[:fg_color].nil?
-          if styles[:color].respond_to?(:sub) && !styles[:color].empty?
-            styles[:fg_color] = styles.delete(:color).sub('#','')
-          end
+        if styles[:fg_color].nil? && styles[:color] && styles[:color].respond_to?(:sub) && !styles[:color].empty?
+          styles[:fg_color] = styles.delete(:color).sub('#','')
         end
 
-        if styles[:bg_color].nil?
-          if styles[:background_color].respond_to?(:sub) && !styles[:background_color].empty?
-            styles[:bg_color] = styles.delete(:background_color).sub('#','')
-          end
+        if styles[:bg_color].nil? && styles[:background_color] && styles[:background_color].respond_to?(:sub) && !styles[:background_color].empty?
+          styles[:bg_color] = styles.delete(:background_color).sub('#','')
         end
         
         if styles[:alignment].nil? && styles[:align]
@@ -48,26 +44,26 @@ module SpreadsheetArchitect
               wrap_text: styles[:align][:wrap_text]
             }
           else
-            styles[:alignment] = {horizontal: styles.delete(:align)}
+            styles[:alignment] = {horizontal: (styles.delete(:align) || nil) }
           end
 
           styles.delete(:align)
         end
 
         if styles[:b].nil?
-          styles[:b] = styles.delete(:bold)
+          styles[:b] = styles.delete(:bold) || nil
         end
 
         if styles[:sz].nil?
-          styles[:sz] = styles.delete(:font_size)
+          styles[:sz] = styles.delete(:font_size) || nil
         end
 
         if styles[:i].nil?
-          styles[:i] = styles.delete(:italic)
+          styles[:i] = styles.delete(:italic) || nil
         end
 
         if styles[:u].nil?
-          styles[:u] = styles.delete(:underline)
+          styles[:u] = styles.delete(:underline) || nil
         end
 
         ### If `:u` is false instead of nil, it may be incorrectly rendered as true in Excel
@@ -78,16 +74,26 @@ module SpreadsheetArchitect
         styles.delete_if{|k,v| v.nil?}
       end
 
-      def self.range_hash_to_str(hash, num_columns, num_rows, col_names=Array('A'..'ZZZ'))
+      def self.range_hash_to_str(hash, num_columns, num_rows)
         case hash[:columns]
         when Integer
-          start_col = end_col = col_names[hash[:columns]]
+          start_col = end_col = COL_NAMES[hash[:columns]]
+        when String
+          start_col = hash[:columns].first
+          end_col = hash[:columns].last
         when Range
-          start_col = col_names[hash[:columns].first]
-          end_col = col_names[hash[:columns].last]
+          start_col = hash[:columns].first
+          unless start_col.is_a?(String)
+            start_col = COL_NAMES[start_col]
+          end
+
+          end_col = hash[:columns].last
+          unless end_col.is_a?(String)
+            end_col = COL_NAMES[end_col]
+          end
         when :all
           start_col = 'A'
-          end_col = col_names[num_columns-1]
+          end_col = COL_NAMES[num_columns-1]
         else
           raise SpreadsheetArchitect::Exceptions::InvalidRangeStylesOptionError.new(:columns, hash)
         end
@@ -105,28 +111,40 @@ module SpreadsheetArchitect
           raise SpreadsheetArchitect::Exceptions::InvalidRangeStylesOptionError.new(:rows, hash)
         end
 
-        return "#{start_col}#{start_row}:#{end_col}#{end_row}"
+        range_str = "#{start_col}#{start_row}:#{end_col}#{end_row}"
+
+        unless hash[:columns] == :all && hash[:rows] == :all
+          verify_range(range_str, num_rows)
+        end
+
+        return range_str
       end
 
-      def self.verify_range(range, num_rows, col_names=Array('A'..'ZZZ'))
+      def self.verify_range(range, num_rows)
         if range.is_a?(String)
           if range.include?(':')
             front, back = range.split(':')
             start_col, start_row = front.scan(/\d+|\D+/)
             end_col, end_row = back.scan(/\d+|\D+/)
 
-            unless col_names.include?(start_col) && col_names.include?(end_col)
-              raise SpreadsheetArchitect::Exceptions::BadRangeError.new(:columns, range)
+            unless COL_NAMES.include?(start_col) && COL_NAMES.include?(end_col)
+              raise SpreadsheetArchitect::Exceptions::InvalidRangeError.new(:columns, range)
             end
             
             unless start_row.to_i <= num_rows && end_row.to_i <= num_rows
-              raise SpreadsheetArchitect::Exceptions::BadRangeError.new(:rows, range)
+              raise SpreadsheetArchitect::Exceptions::InvalidRangeError.new(:rows, range)
             end
           else
-            raise SpreadsheetArchitect::Exceptions::BadRangeError.new(:format, range)
+            raise SpreadsheetArchitect::Exceptions::InvalidRangeError.new(:format, range)
           end
         else
-          raise SpreadsheetArchitect::Exceptions::BadRangeError.new(:type, range)
+          raise SpreadsheetArchitect::Exceptions::InvalidRangeError.new(:type, range)
+        end
+      end
+
+      def self.verify_column(col, num_columns)
+        unless (col.is_a?(String) && COL_NAMES.include?(col)) || (col.is_a?(Integer) && col >= 0 && col < num_columns)
+          raise SpreadsheetArchitect::Exceptions::InvalidColumnError.new(col)
         end
       end
 
@@ -144,6 +162,9 @@ module SpreadsheetArchitect
         new_hash
       end
 
+      ### Limit of 16384 columns as per Excel limitations
+      COL_NAMES = Array('A'..'XFD').freeze
+
     end
   end
 end

data/lib/spreadsheet_architect/utils.rb

@@ -1,90 +1,83 @@
 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}
+    def self.get_cell_data(options, klass)
+      if options[:data] && options[:instances]
+        raise SpreadsheetArchitect::Exceptions::MultipleDataSourcesError
+      elsif options[:data]
+        data = options[:data]
       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]
+      if !options[:data] && options[:headers] == true
+        headers = []
+        needs_headers = true
+      elsif options[:headers].is_a?(Array)
+        headers = options[:headers]
       else
-        has_custom_columns = options[:spreadsheet_columns] || klass.instance_methods.include?(:spreadsheet_columns)
+        headers = false
+      end
 
-        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[:column_types]
+        column_types = options[:column_types]
+      else
+        column_types = []
+        needs_column_types = true
+      end
 
+      if !data
         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
+          if is_ar_model?(klass) 
+            options[:instances] = klass.where(nil).to_a # triggers the relation call, not sure how this works but it does
+          else
+            raise SpreadsheetArchitect::Exceptions::NoDataError
+          end
         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
+        if !options[:spreadsheet_columns] && klass != SpreadsheetArchitect && !klass.instance_methods.include?(:spreadsheet_columns)
+          if is_ar_model?(klass)
+            the_column_names = klass.column_names
+            headers = the_column_names.map{|x| str_titleize(x)} if needs_headers
+            columns = the_column_names.map{|x| x.to_sym}
+          else
+            raise SpreadsheetArchitect::Exceptions::SpreadsheetColumnsNotDefinedError.new(klass)
           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]
+          if columns
+            data.push columns.map{|col| col.is_a?(Symbol) ? instance.instance_eval(col.to_s) : col}
+          else
             row_data = []
-            instance.spreadsheet_columns.each do |x|
+
+            if !options[:spreadsheet_columns]
+              if klass == SpreadsheetArchitect && !instance.respond_to?(:spreadsheet_columns)
+                raise SpreadsheetArchitect::Exceptions::SpreadsheetColumnsNotDefinedError.new(instance.class)
+              else
+                instance_cols = instance.spreadsheet_columns
+              end
+            else
+              instance_cols = options[:spreadsheet_columns].call(instance)
+            end
+
+            instance_cols.each_with_index do |x,i|
               if x.is_a?(Array)
+                headers.push(x[0].to_s) if needs_headers
                 row_data.push(x[1].is_a?(Symbol) ? instance.instance_eval(x[1].to_s) : x[1])
+                if needs_column_types
+                  column_types[i] = x[2]
+                end
               else
+                headers.push(str_titleize(x.to_s)) if needs_headers
                 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}
+
+            needs_headers = false
+            needs_column_types = false
           end
+
         end
       end
 
@@ -92,54 +85,50 @@ module SpreadsheetArchitect
         headers = [headers]
       end
 
-      return options.merge(headers: headers, data: data, column_types: options[:column_types])
+      if column_types.compact.empty?
+        column_types = nil
+      end
+
+      return options.merge(headers: headers, data: data, column_types: column_types)
     end
 
-    def self.get_options(options={}, klass)
-      if options[:headers]
-        if defined?(klass::SPREADSHEET_OPTIONS)
-          header_style = deep_clone(SpreadsheetArchitect.default_options[:header_style]).merge(klass::SPREADSHEET_OPTIONS[:header_style] || {})
+    def self.get_options(options, klass)
+      verify_option_types(options)
+
+      if defined?(klass::SPREADSHEET_OPTIONS)
+        if klass::SPREADSHEET_OPTIONS.is_a?(Hash)
+          options = SpreadsheetArchitect.default_options.merge(
+            klass::SPREADSHEET_OPTIONS.merge(options)
+          )
         else
-          header_style = deep_clone(SpreadsheetArchitect.default_options[:header_style])
-        end
-        
-        if options[:header_style]
-          header_style.merge!(options[:header_style])
-        elsif options[:header_style] == false
-          header_style = false
+          raise SpreadsheetArchitect::Exceptions::InvalidTypeError.new("#{klass}::SPREADSHEET_OPTIONS constant")
         end
       else
-        header_style = false
+        options = SpreadsheetArchitect.default_options.merge(options)
       end
 
-      if options[:row_style] == false
-        row_style = false
-      else
-        if defined?(klass::SPREADSHEET_OPTIONS)
-          row_style = deep_clone(SpreadsheetArchitect.default_options[:row_style]).merge(klass::SPREADSHEET_OPTIONS[:row_style] || {})
+      if !options[:headers]
+        options[:header_style] = false
+      end
+
+      if !options[:sheet_name]
+        if klass == SpreadsheetArchitect
+          options[:sheet_name] = 'Sheet1'
         else
-          row_style = deep_clone(SpreadsheetArchitect.default_options[:row_style])
-        end
+          options[:sheet_name] = klass.name
 
-        if options[:row_style]
-          row_style.merge!(options[:row_style])
+          if options[:sheet_name].respond_to?(:pluralize)
+            options[:sheet_name] = options[:sheet_name].pluralize
+          end
         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)
+      return options
     end
 
     def self.convert_styles_to_ods(styles={})
       styles = {} unless styles.is_a?(Hash)
-      styles = self.stringify_keys(styles)
+      styles = stringify_keys(styles)
 
       property_styles = {}
 
@@ -175,48 +164,54 @@ module SpreadsheetArchitect
 
     private
 
-    def self.deep_clone(x)
-      Marshal.load(Marshal.dump(x))
+    def self.is_ar_model?(klass)
+      defined?(ActiveRecord) && klass.ancestors.include?(ActiveRecord::Base)
     end
 
-    def self.check_type(options, option_name, type)
-      unless options[option_name].nil?
-        valid = false
+    def self.str_titleize(str)
+      str = str.sub(/\A_+/, '')
+               .gsub(/[_\.]/,' ')
+               .sub(' rescue nil','')
+               .gsub(/(\A|\ )\w/){|x| x.upcase}
 
+      return str
+    end
+
+    def self.check_option_type(options, option_name, type)
+      val = options[option_name]
+
+      if val
         if type.is_a?(Array)
-          valid = type.any?{|t| options[option_name].is_a?(t)}
-        elsif options[option_name].is_a?(type)
-          valid = true
+          invalid = type.all?{|t| !val.is_a?(t) }
+        elsif !val.is_a?(type)
+          invalid = true
         end
 
-        if valid
-          raise SpreadsheetArchitect::Exceptions::IncorrectTypeError option_name
+        if invalid
+          raise SpreadsheetArchitect::Exceptions::InvalidTypeError.new(":#{option_name} option")
         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)
+    def self.verify_option_types(options)
+      check_option_type(options, :spreadsheet_columns, Proc)
+      check_option_type(options, :data, Array)
+      check_option_type(options, :instances, Array)
+      check_option_type(options, :headers, [TrueClass, Array])
+      check_option_type(options, :header_style, Hash)
+      check_option_type(options, :row_style, Hash)
+      check_option_type(options, :column_styles, Array)
+      check_option_type(options, :range_styles, Array)
+      check_option_type(options, :merges, Array)
+      check_option_type(options, :borders, Array)
+      check_option_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
+          new_hash[k.to_s] = self.stringify_keys(v)
         else
           new_hash[k.to_s] = v
         end

data/lib/spreadsheet_architect/version.rb

@@ -1,3 +1,3 @@
 module SpreadsheetArchitect
-  VERSION = "2.1.2"
+  VERSION = "3.0.0"
 end

data/lib/spreadsheet_architect.rb

@@ -23,7 +23,11 @@ module SpreadsheetArchitect
   }
 
   def self.default_options=(val)
-    @default_options = val
+    if val.is_a?(Hash)
+      @default_options = val
+    else
+      raise SpreadsheetArchitect::Exceptions::InvalidTypeError.new("SpreadsheetArchitect.default_options")
+    end
   end
 
   def self.default_options

data/test/dummy_app/app/models/active_model_object.rb

@@ -11,4 +11,5 @@ class ActiveModelObject
       :created_at
     ]
   end
+
 end

data/test/dummy_app/app/models/custom_post.rb

@@ -24,4 +24,5 @@ class CustomPost < ActiveRecord::Base
     borders: [],
     column_types: []
   }
+
 end

data/test/dummy_app/app/models/legacy_plain_ruby_object.rb

@@ -0,0 +1,14 @@
+class LegacyPlainRubyObject
+  include SpreadsheetArchitect ### old syntax, not in readme anymore, should easily remain compatible though
+
+  attr_accessor :name, :content, :created_at
+
+  def spreadsheet_columns
+    [
+      ['Name', :name],
+      :content,
+      ['Object ID', (object_id)]
+    ]
+  end
+
+end

data/test/dummy_app/app/models/plain_ruby_object.rb

@@ -1,19 +1,12 @@
 class PlainRubyObject
-  include SpreadsheetArchitect
+  attr_accessor :name, :content, :created_at
 
   def spreadsheet_columns
     [
-      ['Title', :title],
+      ['Name', :name],
       :content,
       ['Object ID', (object_id)]
     ]
   end
 
-  def title
-    'My Title'
-  end
-
-  def content
-    'The content...'
-  end
 end

data/test/dummy_app/app/models/post.rb

@@ -1,3 +1,6 @@
 class Post < ActiveRecord::Base
   include SpreadsheetArchitect
+
+  attr_accessor :name, :content, :created_at
+
 end

data/test/dummy_app/config/routes.rb

@@ -1,7 +1,6 @@
 Dummy::Application.routes.draw do
-  get 'spreadsheet/csv', to: 'spreadsheets#csv'
-  get 'spreadsheet/ods', to: 'spreadsheets#ods'
-  get 'spreadsheet/xlsx', to: 'spreadsheets#xlsx'
-  get 'spreadsheet/alt_xlsx', to: 'spreadsheets#alt_xlsx'
-  get 'test', to: 'spreadsheets#test_xlsx'
+  get 'spreadsheets/csv', to: 'spreadsheets#csv'
+  get 'spreadsheets/ods', to: 'spreadsheets#ods'
+  get 'spreadsheets/xlsx', to: 'spreadsheets#xlsx'
+  get 'spreadsheets/alt_xlsx', to: 'spreadsheets#alt_xlsx'
 end