spreadsheet_architect 5.0.0 → 5.0.1

data/test/unit/spreadsheet_architect/utils/ods_test.rb

@@ -1,58 +0,0 @@
-require 'test_helper'
-
-class SpreadsheetArchitect::Utils::OdsTest < ActiveSupport::TestCase
-  klass = SpreadsheetArchitect::Utils::ODS
-  
-  describe "get_cell_type" do
-    describe "without passing the type argument" do
-      test "it gets the correct cell type" do
-        assert_equal :string, klass.get_cell_type("foobar")
-        assert_equal :float, klass.get_cell_type(1)
-      end
-    end
-
-    describe "when passing the type argument" do
-      test "returns the given type" do
-        assert_equal "foobar", klass.get_cell_type(1, "foobar")
-      end
-
-      describe "hyperlinks" do
-        test "returns :string" do
-          assert_equal :string, klass.get_cell_type("foobar", :hyperlink)
-          assert_equal :string, klass.get_cell_type(1, :hyperlink)
-        end
-      end
-    end
-  end
-
-  describe "convert_styles" do
-    test "convert_styles_to_ods" do
-      ods_styles = klass.convert_styles({
-        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
-  end
-
-end

data/test/unit/spreadsheet_architect/utils/xlsx_test.rb

@@ -1,114 +0,0 @@
-require 'test_helper'
-
-class SpreadsheetArchitectXlsxUtilsTest < ActiveSupport::TestCase
-  klass = SpreadsheetArchitect::Utils::XLSX
-
-  def setup
-  end
-
-  def teardown
-  end
-      
-  test "convert_styles_to_axlsx" do
-    xlsx_styles = klass.convert_styles_to_axlsx({background_color: '333333', color: '000000', align: true, bold: true, font_size: 14, italic: true, underline: true, test: true})
-
-    assert_equal(xlsx_styles, {bg_color: '333333', fg_color: '000000', alignment: {horizontal: true}, b: true, sz: 14, i: true, u: true, test: true})
-  end
-
-  test "get_type" do
-    assert_equal(klass.get_type('string'), :string)
-    assert_equal(klass.get_type(123.01), :float)
-    assert_equal(klass.get_type(BigDecimal('123.01')), :float)
-    assert_equal(klass.get_type(10), :integer)
-    assert_equal(klass.get_type(:test), :string)
-    assert_equal(klass.get_type(Time.now.to_date), :date)
-    assert_equal(klass.get_type(DateTime.now), :time)
-    assert_equal(klass.get_type(Time.now), :time)
-  end
-
-  test "range_hash_to_str" do
-    num_columns = 26
-    num_rows = 10
-
-    assert_raise SpreadsheetArchitect::Exceptions::InvalidRangeError do
-      klass.range_hash_to_str({}, num_columns, num_rows)
-    end
-
-    assert_raise SpreadsheetArchitect::Exceptions::InvalidRangeOptionError do
-      klass.range_hash_to_str({columns: [1,2,3], rows: 1}, num_columns, num_rows)
-    end
-
-    assert_raise SpreadsheetArchitect::Exceptions::InvalidRangeOptionError do
-      klass.range_hash_to_str({columns: 1, rows: [1,2,3]}, num_columns, num_rows)
-    end
-
-    assert_equal klass.range_hash_to_str({columns: 1}, num_columns, num_rows), "B1:B10"
-
-    assert_equal klass.range_hash_to_str({rows: 1}, num_columns, num_rows), "A1:Z1"
-
-    assert_equal klass.range_hash_to_str({columns: 0, rows: 1}, num_columns, num_rows), "A1:A1"
-
-    assert_equal klass.range_hash_to_str({columns: (0..2), rows: (1..3)}, num_columns, num_rows), "A1:C3"
-
-    assert_equal klass.range_hash_to_str({columns: ('A'..'C'), rows: (1..3)}, num_columns, num_rows), "A1:C3"
-
-    assert_equal klass.range_hash_to_str({columns: :all, rows: :all}, num_columns, num_rows), "A1:Z10"
-
-    assert_raise SpreadsheetArchitect::Exceptions::InvalidRangeValue do
-      assert_equal klass.range_hash_to_str({columns: ('foobar'..'asd'), rows: (1..3)}, num_columns, num_rows), "foobar1:asd3"
-    end
-  end
-
-  test "verify_range" do
-    num_rows = 10
-
-    klass.verify_range("A1:Z10", num_rows)
-
-    assert_raise SpreadsheetArchitect::Exceptions::InvalidRangeError do
-      klass.verify_range(:foo, num_rows)
-    end
-
-    assert_raise SpreadsheetArchitect::Exceptions::InvalidRangeError do
-      klass.verify_range("A1Z10", num_rows)
-    end
-
-    assert_raise SpreadsheetArchitect::Exceptions::InvalidRangeValue do
-      klass.verify_range("A1:A#{num_rows+1}", num_rows)
-    end
-
-    klass.verify_range("A1:AAA1", num_rows)
-  end
-
-  test "verify_column" do
-    num_columns = 26
-
-    klass.verify_column(1, num_columns)
-
-    klass.verify_column("A", num_columns)
-
-    assert_raise SpreadsheetArchitect::Exceptions::InvalidColumnError do
-      klass.verify_column(-1, num_columns)
-    end
-
-    assert_raise SpreadsheetArchitect::Exceptions::InvalidColumnError do
-      klass.verify_column(99, num_columns)
-    end
-
-    assert_raise SpreadsheetArchitect::Exceptions::InvalidColumnError do
-      klass.verify_column("foobar", num_columns)
-    end
-
-    assert_raise SpreadsheetArchitect::Exceptions::InvalidColumnError do
-      klass.verify_column([], num_columns)
-    end
-
-    klass.verify_column("ZZ", num_columns)
-  end
-
-  test "constants" do
-    assert_equal klass::COL_NAMES.count, 16384
-    assert_equal klass::COL_NAMES.first, 'A'
-    assert_equal klass::COL_NAMES.last, 'XFD'
-  end
-
-end

data/test/unit/spreadsheet_architect/utils_test.rb

@@ -1,197 +0,0 @@
-require 'test_helper'
-
-class SpreadsheetArchitectUtilsTest < 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(headers: false), 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_nil klass.get_options({header_style: false, headers: false}, SpreadsheetArchitect)[:header_style]
-
-    ### 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'
-
-    ### sets :escape_formulas if not given
-    assert_equal klass.get_options({}, SpreadsheetArchitect)[:escape_formulas], true
-
-    assert_equal klass.get_options({}, SpreadsheetArchitect)[:use_zero_based_row_index], false
-
-    ### removes default styles
-    assert_equal klass.get_options({skip_defaults: true}, SpreadsheetArchitect), {skip_defaults: true, sheet_name: "Sheet1", escape_formulas: true, use_zero_based_row_index: false}
-    assert_equal klass.get_options({skip_defaults: true}, Post), {skip_defaults: true, sheet_name: "Posts", escape_formulas: true, use_zero_based_row_index: false}
-
-    assert_not_equal klass.get_options({skip_defaults: false}, SpreadsheetArchitect), {skip_defaults: true, sheet_name: "Sheet1", escape_formulas: true, use_zero_based_row_index: false}
-    assert_not_equal klass.get_options({skip_defaults: false}, Post), {skip_defaults: true, sheet_name: "Posts", escape_formulas: true, use_zero_based_row_index: false}
-  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::OptionTypeError 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::OptionTypeError 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
-
-  test "symbolize_keys" do
-    hash = klass.symbolize_keys({})
-    assert_empty hash
-
-    hash = klass.symbolize_keys({'foo' => :bar})
-    assert_nil hash['foo']
-    assert_equal hash[:foo], :bar
-
-    hash = klass.symbolize_keys({'foo' => :bar, bar: :foo})
-    assert_nil hash['foo']
-    assert_equal hash[:foo], :bar
-
-    hash = klass.symbolize_keys({'foo' => {'foo' => :bar}})
-    assert_nil hash['foo']
-    assert_equal hash[:foo][:foo], :bar
-
-    hash = klass.symbolize_keys({'foo' => {'foo' => {'foo' => :bar}}})
-    assert_nil hash['foo']
-    assert_equal hash[:foo][:foo][:foo], :bar
-  end
-
-  test "hash_array_symbolize_keys" do
-    array = klass.hash_array_symbolize_keys([])
-    assert_empty array
-
-    array = klass.hash_array_symbolize_keys([{'foo' => :bar}])
-    assert_nil array[0]['foo']
-    assert_equal array[0][:foo], :bar
-  end
-
-end

data/test/unit/xlsx/freeze_test.rb

@@ -1,79 +0,0 @@
-require "test_helper"
-
-class XlsxFreezeTest < ActiveSupport::TestCase
-
-  def setup
-    @options = {
-      headers: [
-        ['Latest Posts'],
-        ['Title','Category','Author','Posted on','Posted At','Earnings']
-      ],
-      data: 50.times.map{|i| [i, "foobar-#{i}", 5.4*i, true, Date.today, Time.now]},
-    }
-  end
-
-  def teardown
-  end
-
-  test "basic" do
-    opts = @options.merge({
-      freeze: {rows: 1, columns: 1},
-    })
-
-    # Using Array Data
-    file_data = SpreadsheetArchitect.to_xlsx(opts)
-
-    save_file("xlsx/freeze_basic.xlsx", file_data)
-  end
-
-  test "using_ranges" do
-    opts = @options.merge({
-      freeze: {rows: (2..4), columns: (2..4)},
-    })
-
-    # Using Array Data
-    file_data = SpreadsheetArchitect.to_xlsx(opts)
-
-    save_file("xlsx/freeze_using_ranges.xlsx", file_data)
-  end
-
-  test "using_legacy_arguments" do
-    opts = @options.merge({
-      freeze: {rows: :all, columns: 2},
-    })
-
-    # Using Array Data
-    file_data = SpreadsheetArchitect.to_xlsx(opts)
-
-    save_file("xlsx/freeze_using_legacy_arguments.xlsx", file_data)
-  end
-
-  test "freeze_type" do
-    opts = @options.merge({
-      freeze: {row: (@options[:data].size-2), column: 16, type: "split_panes"},
-    })
-
-    # Using Array Data
-    file_data = SpreadsheetArchitect.to_xlsx(opts)
-
-    save_file("xlsx/freeze_type.xlsx", file_data)
-  end
-
-  test "panes_all_axlsx_options" do
-    opts = @options.merge({
-      freeze: {
-        row: (@options[:data].size-2),
-        column: 16, 
-        state: "split", 
-        #active_pane: "top_right", 
-        #top_left_cell: "A2",
-      },
-    })
-
-    # Using Array Data
-    file_data = SpreadsheetArchitect.to_xlsx(opts)
-
-    save_file("xlsx/freeze_panes_all_axlsx_options.xlsx", file_data)
-  end
-
-end

data/test/unit/xlsx/general_test.rb

@@ -1,199 +0,0 @@
-require 'test_helper'
-
-class XlsxGeneralTest < ActiveSupport::TestCase
-
-  describe "header" do
-    test "header: false" do
-      spreadsheet = SpreadsheetArchitect.to_xlsx(headers: false, data: [[1]])
-      
-      save_file("xlsx/headers_false_test.xlsx", spreadsheet)
-    end
-  end
-
-  test "use_zero_based_row_index" do
-    spreadsheet = SpreadsheetArchitect.to_xlsx(
-      use_zero_based_row_index: true,
-      headers: [1, 2, 3],
-      data: [
-        [4,5,6],
-        [7,8,9],
-        [10,11,12],
-      ],
-      range_styles: [
-        {range: {rows: 0, columns: 0}, styles: {bold: true}},
-        {range: {rows: (2..3), columns: 0}, styles: {italic: true}},
-      ],
-      merges: [
-        {range: {rows: 0, columns: 1..2}},
-        {range: {rows: (2..3), columns: 2}},
-      ],
-      borders: [
-        {range: {rows: 0, columns: :all}},
-        {range: {rows: 3, columns: 0}},
-      ],
-    )
-
-    save_file("xlsx/use_zero_based_row_index_test.xlsx", spreadsheet)
-  end
-
-  test "multisheet" do
-    test_data = [[1,2,3], [4,5,6], [7,8,9]]
-
-    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)
-
-    save_file("xlsx/multi_sheet.xlsx", package)
-  end
-
-  test "kitchen sink" do
-    options = {
-      headers: [
-        ['Latest Posts'],
-        ['Title','Category','Author','Posted on','Posted At','Earnings']
-      ],
-      data: 50.times.map{|i| [i, "foobar-#{i}", 5.4*i, true, Date.today, Time.now]},
-      header_style: {background_color: "000000", color: "FFFFFF", align: :center, font_size: 12, bold: true},
-      row_style: {background_color: nil, color: "000000", align: :left, font_size: 12},
-      sheet_name: 'Kitchen Sink',
-      freeze_headers: true,
-
-      column_styles: [
-        {columns: 0, styles: {bold: true}},
-        {columns: (1..3), styles: {color: "444444"}},
-        {columns: [4], include_header: false, styles: {italic: true}}
-      ],
-
-      range_styles: [
-        {range: "B2:C4", styles: {background_color: "CCCCCC"}},
-        {range: {rows: 1, columns: :all}, styles: {bold: true}},
-        {range: {rows: (20..25), columns: (1..4)}, styles: {italic: true}},
-        {range: {rows: :all, columns: (3..4)}, styles: {color: "999999"}}
-      ],
-
-      conditional_row_styles: [
-        {
-          if: Proc.new{|row_data, row_index|
-            row_index == 0 || row_data[0].to_i == 2
-          }, 
-          styles: {font_size: 18}
-        },
-        {
-          unless: Proc.new{|row_data, row_index|
-            row_index <= 10 || row_data[0].to_i == 15
-          }, 
-          styles: {align: :right}
-        },
-      ],
-
-      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: [
-        :integer,
-        :string,
-        :float,
-        :boolean,
-        :date,
-        :time,
-        nil,
-      ],
-    }
-
-    # Using Array Data
-    file_data = SpreadsheetArchitect.to_xlsx(options)
-
-    save_file("xlsx/kitchen_sink.xlsx", file_data)
-  end
-
-  describe "column_types" do
-    test "validates provided types" do
-      assert_raise SpreadsheetArchitect::Exceptions::ArgumentError do
-        SpreadsheetArchitect.to_axlsx_package(
-          data: [], 
-          column_types: [""]
-        )
-      end
-
-      SpreadsheetArchitect.to_axlsx_package(
-        data: [], 
-        column_types: [:string, :integer, :float, :date, :time, :boolean, :hyperlink, nil, ->(x){ :foo }]
-      )
-    end
-
-    test "works with Proc types" do
-      url = "https://github.com/westonganger/spreadsheet_architect"
-
-      data = [
-        [1, 2],
-        [1, url],
-      ]
-
-      p = SpreadsheetArchitect.to_axlsx_package(
-        data: data, 
-        column_types: [
-          :string, 
-          ->(x){ x.to_s.start_with?("http") ? :hyperlink : :string }
-        ]
-      )
-
-      doc = parse_axlsx_package(p)
-
-      hyperlinks = doc.css("hyperlinks hyperlink")
-
-      assert_equal 1, hyperlinks.size
-
-      ref = "B2"
-      assert_equal ref, hyperlinks[0].attr("ref")
-      cell = doc.at("c[r='#{ref}']")
-      assert_equal url, cell.text
-      assert_equal "inlineStr", cell.attr("t")
-
-      save_file("xlsx/hyperlinks.xlsx", p)
-    end
-
-    describe "hyperlinks" do
-      test "shows the text and have the correct attributes" do
-        url = "https://github.com/westonganger/spreadsheet_architect"
-
-        data = [
-          [1,2,3],
-          [1, url, "https://github.com/caxlsx/caxlsx"],
-        ]
-
-        p = SpreadsheetArchitect.to_axlsx_package(data: data, column_types: [:string, :hyperlink, :string])
-
-        doc = parse_axlsx_package(p)
-
-        hyperlinks = doc.css("hyperlinks hyperlink")
-
-        assert_equal 2, hyperlinks.size
-
-        ref = "B1"
-        assert_equal ref, hyperlinks[0].attr("ref")
-        cell = doc.at("c[r='#{ref}']")
-        assert_equal "2", cell.text
-        assert_equal "inlineStr", cell.attr("t")
-
-        ref = "B2"
-        assert_equal ref, hyperlinks[1].attr("ref")
-        cell = doc.at("c[r='#{ref}']")
-        assert_equal url, cell.text
-        assert_equal "inlineStr", cell.attr("t")
-
-        save_file("xlsx/hyperlinks.xlsx", p)
-      end
-    end
-  end
-
-end