spreadsheet_architect 2.1.2 → 3.0.0

data/test/integration/application_test.rb

@@ -4,26 +4,21 @@ require 'test_helper'
 
 class ApplicationTest < ActionDispatch::IntegrationTest
   def setup
-    @path = Rails.root.join('tmp/integration_tests')
+    @path = VERSIONED_BASE_PATH.join("integration")
     FileUtils.mkdir_p(@path)
   end
 
-  test "Renders sample xlsx action" do
-    get '/spreadsheet/xlsx', params: {format: :xlsx}
-    assert_response :success
-    assert_not @response.body.include?("<h1>Hello World!</h1>")
-  end
-
   def test_csv
-    get '/spreadsheet/csv'
+    get '/spreadsheets/csv', params: {format: :csv}
     assert_response :success
+
     File.open(File.join(@path, 'csv.csv'), 'w+b') do |f|
       f.write @response.body
     end
   end
 
   def test_ods
-    get '/spreadsheet/ods'
+    get '/spreadsheets/ods'
     assert_response :success
 
     File.open(File.join(@path, 'ods.ods'), 'w+b') do |f|
@@ -32,16 +27,18 @@ class ApplicationTest < ActionDispatch::IntegrationTest
   end
 
   def test_xlsx
-    get '/spreadsheet/xlsx'
+    get '/spreadsheets/xlsx'
     assert_response :success
+
     File.open(File.join(@path, 'xlsx.xlsx'), 'w+b') do |f|
       f.write @response.body
     end
   end
 
   def test_alt_xlsx
-    get '/spreadsheet/alt_xlsx', params: {format: :xlsx}
+    get '/spreadsheets/alt_xlsx', params: {format: :xlsx}
     assert_response :success
+
     File.open(File.join(@path, 'alt_xlsx.xlsx'), 'w+b') do |f|
       f.write @response.body
     end

data/test/models/all_models_test.rb

@@ -0,0 +1,107 @@
+require "test_helper"
+
+class AllModelsTest < ActiveSupport::TestCase
+
+  def setup
+    @data = [
+      ['row1', 'test1'],
+      [123.456, nil, '123'],
+      [123, Date.today, Time.now]
+    ]
+  end
+
+  def teardown
+  end
+
+  def set_path(klass)
+    @path = VERSIONED_BASE_PATH.join("models/#{klass}")
+    FileUtils.mkdir_p(@path)
+  end
+
+  models = [SpreadsheetArchitect, ActiveModelObject, PlainRubyObject, LegacyPlainRubyObject, Post, CustomPost]
+
+  models.each do |klass|
+    instances = 5.times.map{|i| 
+      x = (klass == SpreadsheetArchitect ? Post : klass).new
+      x.name = i
+      x.content = i+2
+      x.created_at = Time.now
+      x
+    }
+
+    ['csv', 'ods', 'xlsx'].each do |format|
+
+      if klass.instance_methods.include?(:spreadsheet_columns) || klass.instance_methods.include?(:column_names)
+
+        test ":instances #{klass} #{format}" do
+          set_path(klass)
+
+          method = "to_#{format}"
+          which = klass.respond_to?(method) ? klass : SpreadsheetArchitect
+
+          data = which.send(method, instances: instances)
+
+          File.open(File.join(@path, "instances.#{format}"), 'w+b') do |f|
+            f.write data
+          end
+        end
+
+        test "Empty :instances #{klass} #{format}" do
+          set_path(klass)
+
+          method = "to_#{format}"
+          which = klass.respond_to?(method) ? klass : SpreadsheetArchitect
+
+          File.open(File.join(@path, "empty.#{format}"),'w+b') do |f|
+            f.write which.send(method, instances: [])
+          end
+        end
+      end
+
+      test ":data #{klass} #{format}" do
+        set_path(klass)
+
+        method = "to_#{format}"
+        which = klass.respond_to?(method) ? klass : SpreadsheetArchitect
+
+        data = which.send(method, data: @data)
+
+        File.open(File.join(@path, "data.#{format}"), 'w+b') do |f|
+          f.write data
+        end
+      end
+
+      test "Empty :data #{klass} #{format}" do
+        set_path(klass)
+
+        method = "to_#{format}"
+        which = klass.respond_to?(method) ? klass : SpreadsheetArchitect
+
+        File.open(File.join(@path, "empty.#{format}"),'w+b') do |f|
+          f.write which.send(method, data: [])
+        end
+      end
+
+      if klass.is_a?(ActiveRecord::Base)
+        test "ActiveRecord::Relation" do
+          method = "to_#{format}"
+
+          File.open(File.join(@path, "active_record_relation.#{format}"),'w+b') do |f|
+            f.write klass.all.send(method)
+          end
+        end
+
+        test "Empty ActiveRecord::Relation" do
+          method = "to_#{format}"
+
+          File.open(File.join(@path, "empty_active_record_relation.#{format}"),'w+b') do |f|
+            f.write klass.limit(0).send(method)
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/test_helper.rb

@@ -23,13 +23,22 @@ Minitest::Reporters.use!
 
 require 'custom_assertions'
 
-### Cleanup old test spreadsheets
-FileUtils.remove_dir(Rails.root.join('tmp/'), true)
-FileUtils.mkdir(Rails.root.join('tmp/'))
-
 post_count = Post.count
 if post_count < 5
   (5 - post_count).times do |i|
     Post.create!(name: "foo #{i}", content: "bar #{i}", age: i)
   end
 end
+
+axlsx_spec = Gem.loaded_specs['axlsx']
+if !axlsx_spec.source.is_a?(Bundler::Source::Rubygems)
+  axlsx_version = 'axlsx-master'
+else
+  axlsx_version = axlsx_spec.version.to_s
+end
+
+VERSIONED_BASE_PATH = Rails.root.join("tmp/#{axlsx_version}")
+
+### Cleanup old test spreadsheets
+FileUtils.remove_dir(VERSIONED_BASE_PATH, true)
+FileUtils.mkdir_p(VERSIONED_BASE_PATH)

data/test/unit/exceptions_test.rb

@@ -0,0 +1,168 @@
+require 'test_helper'
+
+class ExceptionsTest < ActiveSupport::TestCase
+
+  test "NoDataError" do
+    error = SpreadsheetArchitect::Exceptions::NoDataError
+
+    assert error.new
+
+    assert_raise error do
+      SpreadsheetArchitect.to_csv(foo: :bar)
+    end
+  end
+
+  test "MultipleDataSourcesError" do
+    error = SpreadsheetArchitect::Exceptions::MultipleDataSourcesError
+
+    assert error.new
+
+    assert_raise error do
+      SpreadsheetArchitect.to_csv(data: [], instances: [])
+    end
+  end
+
+  test "InvalidTypeError" do
+    error = SpreadsheetArchitect::Exceptions::InvalidTypeError
+
+    assert error.new(:foobar_option).message
+
+    assert_raise error do
+      SpreadsheetArchitect.to_csv(spreadsheet_columns: :foo)
+    end
+    assert_raise error do
+      SpreadsheetArchitect.to_csv(data: :foo)
+    end
+    assert_raise error do
+      SpreadsheetArchitect.to_csv(instances: :foo)
+    end
+    assert_raise error do
+      SpreadsheetArchitect.to_csv(headers: :foo)
+    end
+    assert_raise error do
+      SpreadsheetArchitect.to_csv(header_style: :foo)
+    end
+    assert_raise error do
+      SpreadsheetArchitect.to_csv(row_style: :foo)
+    end
+    assert_raise error do
+      SpreadsheetArchitect.to_csv(column_styles: :foo)
+    end
+    assert_raise error do
+      SpreadsheetArchitect.to_csv(range_styles: :foo)
+    end
+    assert_raise error do
+      SpreadsheetArchitect.to_csv(merges: :foo)
+    end
+    assert_raise error do
+      SpreadsheetArchitect.to_csv(borders: :foo)
+    end
+    assert_raise error do
+      SpreadsheetArchitect.to_csv(column_widths: :foo)
+    end
+  end
+
+  test "SpreadsheetColumnsNotDefinedError" do
+    error = SpreadsheetArchitect::Exceptions::SpreadsheetColumnsNotDefinedError
+
+    assert_raise ArgumentError do
+      error.new
+    end
+
+    assert error.new(SpreadsheetArchitect)
+
+    class QuickBadClass
+      include SpreadsheetArchitect
+    end
+
+    assert_raise error do
+      QuickBadClass.to_csv(instances: [])
+    end
+  end
+
+  test "InvalidColumnError" do
+    error = SpreadsheetArchitect::Exceptions::InvalidColumnError
+
+    assert_raise ArgumentError do
+      error.new
+    end
+
+    assert error.new(:foobar_column)
+
+    assert_raise error do
+      SpreadsheetArchitect.to_xlsx(data: [[1]], column_styles: [{columns: 999}])
+    end
+
+    assert_raise error do
+      SpreadsheetArchitect.to_xlsx(data: [[1]], column_styles: [{columns: 'ZZZ'}])
+    end
+
+    assert_raise error do
+      SpreadsheetArchitect.to_xlsx(data: [[1]], column_styles: [{columns: [999]}])
+    end
+
+    assert_raise error do
+      SpreadsheetArchitect.to_xlsx(data: [[1]], column_styles: [{columns: ('ZZX'..'ZZZ')}])
+    end
+  end
+
+  test "InvalidRangeStylesOptionError" do
+    error = SpreadsheetArchitect::Exceptions::InvalidRangeStylesOptionError
+
+    assert_raise ArgumentError do
+      error.new
+    end
+
+    assert error.new(:columns, :bar_opt)
+    assert error.new(:row, :bar_opt)
+    assert error.new(:foo, :bar_opt)
+
+    assert_raise error do
+      SpreadsheetArchitect::Utils::XLSX.range_hash_to_str({columns: :foo}, 1, 1)
+    end
+
+    assert_raise error do
+      SpreadsheetArchitect::Utils::XLSX.range_hash_to_str({rows: :foo}, 1, 1)
+    end
+  end
+
+  test "InvalidRangeError" do
+    error = SpreadsheetArchitect::Exceptions::InvalidRangeError
+
+    assert_raise ArgumentError do
+      error.new
+    end
+
+    errors = []
+    errors.push error.new(:foo_type, :bar_opt)
+    errors.push error.new(:columns, :bar_opt)
+    errors.push error.new(:rows, :bar_opt)
+    errors.push error.new(:format, :bar_opt)
+    errors.push error.new(:type, :bar_opt)
+    errors.push error.new(:foo_type, :bar_opt)
+
+    assert_equal errors.count, errors.uniq.count
+    assert error.new(:foo_type, :bar_opt)
+
+    assert_raise error do
+      SpreadsheetArchitect::Utils::XLSX.verify_range(:foo, 1)
+    end
+
+    assert_raise error do
+      SpreadsheetArchitect::Utils::XLSX.verify_range("foo", 1)
+    end
+
+    assert_raise error do
+      SpreadsheetArchitect::Utils::XLSX.verify_range("foo:foo", 1)
+    end
+
+    assert_raise error do
+      SpreadsheetArchitect::Utils::XLSX.verify_range("A1:A2", 1)
+    end
+
+    assert_raise error do
+      SpreadsheetArchitect::Utils::XLSX.verify_range("@1:A2", 1)
+    end
+  end
+
+end

data/test/unit/formats_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class FormatsTest < ActiveSupport::TestCase
+
+  [:xlsx, :ods, :csv].each do |format|
+    test "Registers :#{format} mime type" do
+      assert Mime::Type.lookup_by_extension(format)
+    end
+
+    test "Registers :#{format} template handler" do
+      assert ActionController::Renderers::RENDERERS.include?(format.to_sym)
+    end
+  end
+
+end

data/test/unit/general_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class GeneralTest < ActiveSupport::TestCase
+
+  test "Version accessible by default" do
+    assert_not_nil SpreadsheetArchitect::VERSION
+  end
+
+  test "Constants dont change" do
+    x = SpreadsheetArchitect.default_options.to_s
+    SpreadsheetArchitect.to_xlsx(headers: [[1]], data: [[1]], header_style: {b: false}, row_style: {background_color: '000000'})
+    assert_equal(x, SpreadsheetArchitect.default_options.to_s)
+  end
+
+end

data/test/unit/kitchen_sink_test.rb

@@ -0,0 +1,87 @@
+require "test_helper"
+
+class KitchenSinkTest < ActiveSupport::TestCase
+
+  def setup
+    @options = {
+      headers: [
+        ['Latest Posts'],
+        ['Title','Category','Author','Posted on','Earnings']
+      ],
+      data: 50.times.map{|i| [i, i*2, i*3, i*4, i*5, i*6, i*7, i*8]},
+      header_style: {background_color: "000000", color: "FFFFFF", align: :center, font_size: 12, bold: true, italic: true},
+      row_style: {background_color: nil, color: "000000", align: :left, font_size: 12},
+      sheet_name: 'Kitchen Sink'
+    }
+  end
+
+  def teardown
+  end
+
+  def test_xlsx
+    @options.merge!({
+      column_styles: [
+        {columns: 0, styles: {bold: true}},
+        {columns: (1..3), styles: {format_code: "$#,##0.00"}},
+        {columns: [4], include_header: true, styles: {italic: true}}
+      ],
+
+      range_styles: [
+        {range: "B2:C4", styles: {background_color: "CCCCCC"}},
+        {range: {rows: 1, columns: :all}, styles: {bold: true}},
+        {range: {rows: (0..5), columns: (1..4)}, styles: {italic: true}},
+        {range: {rows: :all, columns: (3..4)}, styles: {color: "999999"}}
+      ],
+
+      borders: [
+        {range: "B2:C4"},
+        {range: "D6:D7", border_styles: {style: :dashDot, color: "333333"}},
+        {range: {rows: (2..11), columns: :all}, border_styles: {edges: [:top,:bottom]}},
+        {range: {rows: 3, columns: 4}, border_styles: {edges: [:top,:bottom]}}
+      ],
+
+      merges: [
+        {range: "A1:C1"},
+        {range: {rows: 2, columns: :all}},
+        {range: {rows: (3..4), columns: (0..3)}}
+      ],
+
+      column_types: [
+        :string,
+        :integer,
+        :float,
+        :boolean,
+        nil,
+      ],
+    })
+
+    # Using Array Data
+    file_data = SpreadsheetArchitect.to_xlsx(@options)
+
+    File.open(VERSIONED_BASE_PATH.join("kitchen_sink.xlsx"),'w+b') do |f|
+      f.write file_data
+    end
+  end
+
+  def test_ods
+    @options.merge!({
+      column_types: [
+        :string,
+        :float,
+        :percent,
+        :currency,
+        :date,
+        :time,
+        nil
+      ],
+    })
+
+    # Using Array Data
+    file_data = SpreadsheetArchitect.to_ods(@options)
+
+    File.open(VERSIONED_BASE_PATH.join("kitchen_sink.ods"),'w+b') do |f|
+      f.write file_data
+    end
+  end
+
+end

data/test/unit/multi_sheet_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+class MultiSheetTest < ActiveSupport::TestCase
+
+  def setup
+    @test_data = [[1,2,3], [4,5,6], [7,8,9]]
+  end
+
+  test "xlsx" do
+    package = Post.to_axlsx_package
+    package = CustomPost.to_axlsx_package({sheet_name: 'Latest Projects'}, package)
+    package = SpreadsheetArchitect.to_axlsx_package({data: @test_data, sheet_name: 'Another Sheet'}, package)
+
+    File.open(VERSIONED_BASE_PATH.join("multi_sheet.xlsx"),'w+b') do |f|
+      f.write package.to_stream.read
+    end
+  end
+
+  test "ods" do
+    spreadsheet = Post.to_rodf_spreadsheet
+    spreadsheet = CustomPost.to_rodf_spreadsheet({sheet_name: 'Latest Projects'}, spreadsheet)
+    spreadsheet = SpreadsheetArchitect.to_rodf_spreadsheet({data: @test_data, sheet_name: 'Another Sheet'}, spreadsheet)
+
+    File.open(VERSIONED_BASE_PATH.join("multi_sheet.ods"),'w+b') do |f|
+      f.write spreadsheet.bytes
+    end
+  end
+
+end

data/test/unit/utils_test.rb

@@ -0,0 +1,179 @@
+require 'test_helper'
+
+class UtilsTest < ActiveSupport::TestCase
+  klass = SpreadsheetArchitect::Utils
+
+  def setup
+    @options = {
+      header_style: {background_color: 'AAAAAA', color: 'FFFFFF', align: :center, font_name: 'Arial', font_size: 10, bold: false, italic: false, underline: false},
+      row_style: {background_color: nil, color: '000000', align: :left, font_name: 'Arial', font_size: 10, bold: false, italic: false, underline: false},
+      sheet_name: 'My Project Export',
+      column_styles: [],
+      range_styles: [],
+      merges: [],
+      borders: [],
+      column_types: [],
+      column_widths: [],
+
+      headers: ['test1', 'test2','test3'],
+      data: [
+        ['row1'],
+        ['row2 c1', 'row2 c2'],
+        ['the','data']
+      ]
+    }
+  end
+
+  def teardown
+  end
+
+  test "get_cell_data" do
+    assert klass.get_cell_data(@options, SpreadsheetArchitect)
+
+    assert klass.get_cell_data(@options, Post)
+
+    assert klass.get_options({}, SpreadsheetArchitect)
+
+    assert_raise SpreadsheetArchitect::Exceptions::MultipleDataSourcesError do
+      klass.get_cell_data(@options.merge(instances: []), SpreadsheetArchitect)
+    end
+
+    ### using Data option
+    output = klass.get_cell_data(@options.merge(headers: true), SpreadsheetArchitect)
+    assert_equal false, output[:headers]
+
+    output = klass.get_cell_data(@options.merge(column_types: nil), SpreadsheetArchitect)
+    assert_nil output[:column_types]
+
+    output = klass.get_cell_data(@options.merge(column_types: []), SpreadsheetArchitect)
+    assert_nil output[:column_types]
+
+    output = klass.get_cell_data(@options.merge(column_types: [:string]), SpreadsheetArchitect)
+    assert_equal output[:column_types], [:string]
+
+    headers = [[1,2,3], [3,4,5]]
+    output = klass.get_cell_data(@options.merge(headers: headers), SpreadsheetArchitect)
+    assert_equal headers, output[:headers]
+
+    ### Using instances option
+    output = klass.get_cell_data(@options.merge(data: nil), Post.all)
+    assert output[:instances].is_a?(Array)
+
+    output = klass.get_cell_data(@options.merge(data: nil), Post.limit(0))
+    assert output[:instances].is_a?(Array)
+
+    assert_raise SpreadsheetArchitect::Exceptions::NoDataError do
+      klass.get_cell_data(@options.merge(data: nil, instances: nil), SpreadsheetArchitect)
+    end
+
+    output = klass.get_cell_data(@options.merge(data: nil, instances: [PlainRubyObject.new]), SpreadsheetArchitect)
+    assert output[:instances].count == 1
+  end
+
+  test "get_options" do
+    ### Empty
+    assert_not_empty klass.get_options({}, SpreadsheetArchitect)
+
+    ### using SpreadsheetArchitect
+    assert_not_empty klass.get_options(@options, SpreadsheetArchitect)
+
+    ### with model defaults via SPREADSHEET_OPTIONS 
+    assert defined?(CustomPost::SPREADSHEET_OPTIONS)
+    assert klass.get_options(@options, CustomPost)
+
+    ### without model defaults via SPREADSHEET_OPTIONS 
+    assert_not_empty klass.get_options(@options, Post)
+
+    ### without :headers removes :header_style
+    assert_equal klass.get_options({header_style: false, headers: false}, SpreadsheetArchitect)[:header_style], false
+
+    ### sets :sheet_name if needed 
+    assert_equal klass.get_options({sheet_name: false}, SpreadsheetArchitect)[:sheet_name], 'Sheet1'
+
+    ### sets :sheet_name if needed, using pluralized only when using Rails
+    assert_equal klass.get_options({sheet_name: false}, Post)[:sheet_name], 'Posts'
+  end
+  
+  test "convert_styles_to_ods" do
+    ods_styles = klass.convert_styles_to_ods({
+      background_color: '333333', 
+      color: '000000', 
+      align: true, 
+      bold: true, 
+      font_size: 14, 
+      italic: true, 
+      underline: true, 
+      test: true
+    })
+
+    assert_equal(ods_styles, {
+      'cell' => {
+        'background-color' => '#333333'
+      }, 
+      'text' => {
+        'color' => '#000000', 
+        'align' => true, 
+        'font-weight' => 'bold', 
+        'font-size' => 14, 
+        'font-style' => 'italic', 
+        'text-underline-type' => 'single', 
+        'text-underline-style' => 'solid'
+      }
+    })
+  end
+
+  test "is_ar_model" do
+    assert klass.is_ar_model?(Post)
+
+    assert_not klass.is_ar_model?(SpreadsheetArchitect)
+  end
+
+  test "str_titleize" do
+    assert_equal(klass.str_titleize('my_project_export'), 'My Project Export')
+    assert_equal(klass.str_titleize('My Project Export'), 'My Project Export')
+    assert_equal(klass.str_titleize('TBS report'), 'TBS Report')
+  end
+
+  test "check_option_type" do
+    klass.check_option_type(@options, :data, Array)
+
+    klass.check_option_type(@options, :foo, Array)
+
+    assert_raise SpreadsheetArchitect::Exceptions::InvalidTypeError do
+      klass.check_option_type({foo: :bar}, :foo, Array)
+    end
+  end
+
+  test "verify_option_types" do
+    klass.verify_option_types(@options)
+
+    assert_raise SpreadsheetArchitect::Exceptions::InvalidTypeError do
+      klass.verify_option_types(@options.merge({column_widths: :foobar}))
+    end
+  end
+
+  test "stringify_keys" do
+    hash = klass.stringify_keys
+    assert_empty hash
+
+    hash = klass.stringify_keys({foo: :bar})
+    assert_nil hash[:foo]
+    assert_equal hash['foo'], :bar
+
+    hash = klass.stringify_keys({foo: :bar, 'bar' => :foo})
+    assert_nil hash[:foo]
+    assert_equal hash['foo'], :bar
+
+    hash = klass.stringify_keys({foo: {foo: :bar}})
+    assert_nil hash[:foo]
+    assert_equal hash['foo']['foo'], :bar
+
+    hash = klass.stringify_keys({foo: {foo: {foo: :bar}}})
+    assert_nil hash[:foo]
+    assert_equal hash['foo']['foo']['foo'], :bar
+
+    hash = klass.stringify_keys({foo: {foo: {foo: {foo: :bar}}}})
+    assert_nil hash[:foo]
+    assert_equal hash['foo']['foo']['foo']['foo'], :bar
+  end
+end