├── .credo.exs
├── .formatter.exs
├── .github
    └── workflows
    │   └── elixir.yml
├── .gitignore
├── CHANGELOG.md
├── README.md
├── assets
    ├── logo.png
    └── logo_hires.png
├── benchmark
    ├── files
    │   └── .gitkeep
    ├── init.exs
    └── run.exs
├── lib
    ├── xlsx_reader.ex
    └── xlsx_reader
    │   ├── array.ex
    │   ├── cell.ex
    │   ├── cell_reference.ex
    │   ├── conversion.ex
    │   ├── number.ex
    │   ├── package.ex
    │   ├── package_loader.ex
    │   ├── parsers
    │       ├── relationships_parser.ex
    │       ├── shared_strings_parser.ex
    │       ├── styles_parser.ex
    │       ├── utils.ex
    │       ├── workbook_parser.ex
    │       └── worksheet_parser.ex
    │   ├── sheet.ex
    │   ├── styles.ex
    │   ├── workbook.ex
    │   └── zip_archive.ex
├── mix.exs
├── mix.lock
└── test
    ├── compatibility_test.exs
    ├── fixtures
        ├── cells_missing_attributes.xlsx
        ├── custom_dates.xlsx
        ├── google_spreadsheet.xlsx
        ├── has_formulas.xlsx
        ├── hidden_sheets.xlsx
        ├── merged.xlsx
        ├── not_a_zip.zip
        ├── omitted_row.xlsx
        ├── package
        │   ├── [Content_Types].xml
        │   ├── _rels
        │   │   └── .rels
        │   ├── docProps
        │   │   ├── app.xml
        │   │   └── core.xml
        │   └── xl
        │   │   ├── _rels
        │   │       └── workbook.xml.rels
        │   │   ├── sharedStrings.xml
        │   │   ├── styles.xml
        │   │   ├── theme
        │   │       └── theme1.xml
        │   │   ├── workbook.xml
        │   │   └── worksheets
        │   │       ├── _rels
        │   │           └── sheet3.xml.rels
        │   │       ├── sheet1.xml
        │   │       ├── sheet2.xml
        │   │       ├── sheet3.xml
        │   │       ├── sheet4.xml
        │   │       └── sheet5.xml
        ├── test.xlsx
        ├── test.zip
        └── xml
        │   ├── sharedStringsWithRichText.xml
        │   ├── sharedStringsWithXmlSpacePreserve.xml
        │   ├── worksheetWithInlineStr.xml
        │   └── worksheetWithSharedFormulas.xml
    ├── test_helper.exs
    ├── xlsx_reader
        ├── cell_reference_test.exs
        ├── conversion_test.exs
        ├── custom_dates_test.exs
        ├── package_test.exs
        ├── parsers
        │   ├── relationships_parser_test.exs
        │   ├── shared_strings_parser_test.exs
        │   ├── styles_parser_test.exs
        │   ├── utils_test.exs
        │   ├── workbook_parser_test.exs
        │   └── worksheet_parser_test.exs
        ├── styles_test.exs
        └── zip_archive_test.exs
    └── xlsx_reader_test.exs


/.credo.exs:
--------------------------------------------------------------------------------
  1 | # This file contains the configuration for Credo and you are probably reading
  2 | # this after creating it with `mix credo.gen.config`.
  3 | #
  4 | # If you find anything wrong or unclear in this file, please report an
  5 | # issue on GitHub: https://github.com/rrrene/credo/issues
  6 | #
  7 | %{
  8 |   #
  9 |   # You can have as many configs as you like in the `configs:` field.
 10 |   configs: [
 11 |     %{
 12 |       #
 13 |       # Run any exec using `mix credo -C <name>`. If no exec name is given
 14 |       # "default" is used.
 15 |       #
 16 |       name: "default",
 17 |       #
 18 |       # These are the files included in the analysis:
 19 |       files: %{
 20 |         #
 21 |         # You can give explicit globs or simply directories.
 22 |         # In the latter case `**/*.{ex,exs}` will be used.
 23 |         #
 24 |         included: ["lib/", "src/", "test/", "web/", "apps/"],
 25 |         excluded: [~r"/_build/", ~r"/deps/", ~r"/node_modules/"]
 26 |       },
 27 |       #
 28 |       # Load and configure plugins here:
 29 |       #
 30 |       plugins: [],
 31 |       #
 32 |       # If you create your own checks, you must specify the source files for
 33 |       # them here, so they can be loaded by Credo before running the analysis.
 34 |       #
 35 |       requires: [],
 36 |       #
 37 |       # If you want to enforce a style guide and need a more traditional linting
 38 |       # experience, you can change `strict` to `true` below:
 39 |       #
 40 |       strict: false,
 41 |       #
 42 |       # If you want to use uncolored output by default, you can change `color`
 43 |       # to `false` below:
 44 |       #
 45 |       color: true,
 46 |       #
 47 |       # You can customize the parameters of any check by adding a second element
 48 |       # to the tuple.
 49 |       #
 50 |       # To disable a check put `false` as second element:
 51 |       #
 52 |       #     {Credo.Check.Design.DuplicatedCode, false}
 53 |       #
 54 |       checks: [
 55 |         #
 56 |         ## Consistency Checks
 57 |         #
 58 |         {Credo.Check.Consistency.ExceptionNames, []},
 59 |         {Credo.Check.Consistency.LineEndings, []},
 60 |         {Credo.Check.Consistency.ParameterPatternMatching, []},
 61 |         {Credo.Check.Consistency.SpaceAroundOperators, []},
 62 |         {Credo.Check.Consistency.SpaceInParentheses, []},
 63 |         {Credo.Check.Consistency.TabsOrSpaces, []},
 64 | 
 65 |         #
 66 |         ## Design Checks
 67 |         #
 68 |         # You can customize the priority of any check
 69 |         # Priority values are: `low, normal, high, higher`
 70 |         #
 71 |         {Credo.Check.Design.AliasUsage,
 72 |          [priority: :low, if_nested_deeper_than: 2, if_called_more_often_than: 0]},
 73 |         # You can also customize the exit_status of each check.
 74 |         # If you don't want TODO comments to cause `mix credo` to fail, just
 75 |         # set this value to 0 (zero).
 76 |         #
 77 |         {Credo.Check.Design.TagTODO, [exit_status: 2]},
 78 |         {Credo.Check.Design.TagFIXME, []},
 79 | 
 80 |         #
 81 |         ## Readability Checks
 82 |         #
 83 |         {Credo.Check.Readability.AliasOrder, []},
 84 |         {Credo.Check.Readability.FunctionNames, []},
 85 |         {Credo.Check.Readability.LargeNumbers, []},
 86 |         {Credo.Check.Readability.MaxLineLength, [priority: :low, max_length: 120]},
 87 |         {Credo.Check.Readability.ModuleAttributeNames, []},
 88 |         {Credo.Check.Readability.ModuleDoc, []},
 89 |         {Credo.Check.Readability.ModuleNames, []},
 90 |         {Credo.Check.Readability.ParenthesesInCondition, []},
 91 |         {Credo.Check.Readability.ParenthesesOnZeroArityDefs, []},
 92 |         {Credo.Check.Readability.PredicateFunctionNames, []},
 93 |         {Credo.Check.Readability.PreferImplicitTry, []},
 94 |         {Credo.Check.Readability.RedundantBlankLines, []},
 95 |         {Credo.Check.Readability.Semicolons, []},
 96 |         {Credo.Check.Readability.SpaceAfterCommas, []},
 97 |         {Credo.Check.Readability.StringSigils, []},
 98 |         {Credo.Check.Readability.TrailingBlankLine, []},
 99 |         {Credo.Check.Readability.TrailingWhiteSpace, []},
100 |         # TODO: enable by default in Credo 1.1
101 |         {Credo.Check.Readability.UnnecessaryAliasExpansion, false},
102 |         {Credo.Check.Readability.VariableNames, []},
103 | 
104 |         #
105 |         ## Refactoring Opportunities
106 |         #
107 |         {Credo.Check.Refactor.CondStatements, []},
108 |         {Credo.Check.Refactor.CyclomaticComplexity, []},
109 |         {Credo.Check.Refactor.FunctionArity, []},
110 |         {Credo.Check.Refactor.LongQuoteBlocks, []},
111 |         {Credo.Check.Refactor.MapInto, false},
112 |         {Credo.Check.Refactor.MatchInCondition, []},
113 |         {Credo.Check.Refactor.NegatedConditionsInUnless, []},
114 |         {Credo.Check.Refactor.NegatedConditionsWithElse, []},
115 |         {Credo.Check.Refactor.Nesting, []},
116 |         {Credo.Check.Refactor.UnlessWithElse, []},
117 |         {Credo.Check.Refactor.WithClauses, []},
118 | 
119 |         #
120 |         ## Warnings
121 |         #
122 |         {Credo.Check.Warning.BoolOperationOnSameValues, []},
123 |         {Credo.Check.Warning.ExpensiveEmptyEnumCheck, []},
124 |         {Credo.Check.Warning.IExPry, []},
125 |         {Credo.Check.Warning.IoInspect, []},
126 |         {Credo.Check.Warning.LazyLogging, false},
127 |         {Credo.Check.Warning.OperationOnSameValues, []},
128 |         {Credo.Check.Warning.OperationWithConstantResult, []},
129 |         {Credo.Check.Warning.RaiseInsideRescue, []},
130 |         {Credo.Check.Warning.UnusedEnumOperation, []},
131 |         {Credo.Check.Warning.UnusedFileOperation, []},
132 |         {Credo.Check.Warning.UnusedKeywordOperation, []},
133 |         {Credo.Check.Warning.UnusedListOperation, []},
134 |         {Credo.Check.Warning.UnusedPathOperation, []},
135 |         {Credo.Check.Warning.UnusedRegexOperation, []},
136 |         {Credo.Check.Warning.UnusedStringOperation, []},
137 |         {Credo.Check.Warning.UnusedTupleOperation, []},
138 | 
139 |         #
140 |         # Controversial and experimental checks (opt-in, just replace `false` with `[]`)
141 |         #
142 |         {Credo.Check.Consistency.MultiAliasImportRequireUse, false},
143 |         {Credo.Check.Consistency.UnusedVariableNames, false},
144 |         {Credo.Check.Design.DuplicatedCode, false},
145 |         {Credo.Check.Readability.AliasAs, false},
146 |         {Credo.Check.Readability.MultiAlias, false},
147 |         {Credo.Check.Readability.Specs, false},
148 |         {Credo.Check.Readability.SinglePipe, false},
149 |         {Credo.Check.Refactor.ABCSize, false},
150 |         {Credo.Check.Refactor.AppendSingleItem, false},
151 |         {Credo.Check.Refactor.DoubleBooleanNegation, false},
152 |         {Credo.Check.Refactor.ModuleDependencies, false},
153 |         {Credo.Check.Refactor.PipeChainStart, false},
154 |         {Credo.Check.Refactor.VariableRebinding, false},
155 |         {Credo.Check.Warning.MapGetUnsafePass, false},
156 |         {Credo.Check.Warning.UnsafeToAtom, false}
157 | 
158 |         #
159 |         # Custom checks can be created using `mix credo.gen.check`.
160 |         #
161 |       ]
162 |     }
163 |   ]
164 | }
165 | 


--------------------------------------------------------------------------------
/.formatter.exs:
--------------------------------------------------------------------------------
1 | # Used by "mix format"
2 | [
3 |   inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
4 | ]
5 | 


--------------------------------------------------------------------------------
/.github/workflows/elixir.yml:
--------------------------------------------------------------------------------
 1 | name: CI
 2 | 
 3 | on: push
 4 | 
 5 | jobs:
 6 |   unit-test:
 7 |     runs-on: ubuntu-latest
 8 |     name: OTP ${{matrix.otp}} / Elixir ${{matrix.elixir}}
 9 |     env:
10 |       MIX_ENV: test
11 |     strategy:
12 |       fail-fast: false
13 |       matrix:
14 |         include:
15 |           - elixir: 1.15.6
16 |             otp: 25.3.2.6
17 |           - elixir: 1.15.6
18 |             otp: 24.3.4.13
19 |     steps:
20 |       - name: Checkout
21 |         uses: actions/checkout@v4
22 |       - name: Install Elixir and Erlang
23 |         uses: erlef/setup-beam@v1
24 |         with:
25 |           elixir-version: ${{ matrix.elixir }}
26 |           otp-version: ${{ matrix.otp }}
27 |       - name: Restore deps and _build cache
28 |         uses: actions/cache@v3
29 |         with:
30 |           path: |
31 |             deps
32 |             _build
33 |           key: ${{ runner.os }}-${{ matrix.elixir }}-${{ matrix.otp }}-${{ hashFiles('**/mix.lock') }}
34 |           restore-keys: |
35 |             ${{ runner.os }}-${{ matrix.elixir }}-${{ matrix.otp }}-
36 |       - name: Install dependencies
37 |         run: mix deps.get
38 |       - name: Compile deps
39 |         run: mix deps.compile
40 |       - name: Run tests
41 |         run: mix test
42 |       - name: Check format
43 |         run: mix format --check-formatted
44 |       - name: Check quality
45 |         run: mix credo --all --strict || true
46 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # The directory Mix will write compiled artifacts to.
 2 | /_build/
 3 | 
 4 | # If you run "mix test --cover", coverage assets end up here.
 5 | /cover/
 6 | 
 7 | # The directory Mix downloads your dependencies sources to.
 8 | /deps/
 9 | 
10 | # Where third-party dependencies like ExDoc output generated docs.
11 | /doc/
12 | 
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 | 
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 | 
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 | 
22 | # Ignore package tarball (built via "mix hex.build").
23 | xlsx_reader-*.tar
24 | 
25 | .DS_Store
26 | 
27 | # Ignore generated benchmark files
28 | /benchmark/files/*.xlsx
29 | /benchmark/output/*.benchee
30 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | 
  3 | ## [0.8.8] - 2025-03-01
  4 | 
  5 | - Relax `:saxy` dependency
  6 | 
  7 | ## [0.8.7] - 2024-07-14
  8 | 
  9 | - Fix issue with some empty cell elements being returned as `:expect_formula`, they are now returned as empty strings
 10 | 
 11 | ## [0.8.6] - 2024-06-28
 12 | 
 13 | - Fix handling of cell type/style when some cell elements were missing attributes
 14 | - Handle date and datetime values encoded as numeric cell types
 15 | 
 16 | ## [0.8.5] - 2024-06-02
 17 | 
 18 | - Handle files without shared strings or styles relationships.
 19 | 
 20 | ## [0.8.4] - 2024-04-28
 21 | 
 22 | - Upgrade ex_doc
 23 | - Fix issue with some empty cell elements being returned as `:expect_chars`, they are now returned as empty strings.
 24 | 
 25 | ## [0.8.3] - 2024-04-19
 26 | 
 27 | - Improve handling of UTF-8/16/32 encoding
 28 | 
 29 | ## [0.8.2] - 2024-04-06
 30 | 
 31 | - Add `exclude_hidden_sheets?` option
 32 | - Return `#ERROR` value instead of crashing in case of cell conversion
 33 |   error
 34 | 
 35 | ## [0.8.1] - 2024-01-11
 36 | 
 37 | - Add support for shared formulas
 38 | 
 39 | ## [0.8.0] - 2023-12-11
 40 | 
 41 | - Add `cell_data_format` option to return data as `Cell` structs instead of values
 42 | 
 43 | ## [0.7.0] - 2023-10-15
 44 | 
 45 | - Improve ZIP file error handling
 46 | - Update Saxy XML parser
 47 | - Improve UTF-16 support
 48 | 
 49 | ## [0.6.0] - 2022-10-30
 50 | 
 51 | - Update Saxy XML parser
 52 | 
 53 | ## [0.5.0] - 2022-06-12
 54 | 
 55 | - Require Elixir 1.10 to fix publishing of documentation
 56 | 
 57 | ## [0.4.3] - 2021-02-08
 58 | 
 59 | - Improve compatibility with XLSX writers (Excel for Mac, …) which completely omit empty rows in worksheets
 60 | 
 61 | ## [0.4.2] - 2021-02-09
 62 | 
 63 | - Add `skip_row?` callback
 64 | 
 65 | ## [0.4.1] - 2020-10-15
 66 | 
 67 | - Add support for `decimal ~> 2.0`
 68 | 
 69 | ## [0.4.0] - 2020-06-23
 70 | 
 71 | - Add `:supported_custom_format` option to `XlsxReader.open/2`
 72 | - Support ISO 8601 and US date/time custom format by default
 73 | 
 74 | ## [0.3.0] - 2020-05-07
 75 | 
 76 | - Add `:only` and `:except` options to `XlsxReader.sheets/2` and `XlsxReader.async_sheets/3`
 77 | 
 78 | ## [0.2.0] - 2020-04-27
 79 | 
 80 | - Add `XlsxReader.async_sheets/3`
 81 | 
 82 | ## [0.1.4] - 2020-04-24
 83 | 
 84 | - Speed-up shared string and styles lookups
 85 | 
 86 | ## [0.1.3] - 2020-02-26
 87 | 
 88 | - Improve compatibility with XLSX writers (Excel, Elixslx, …) which completely omit empty cells in worksheets
 89 | 
 90 | ## [0.1.2] - 2019-12-30
 91 | 
 92 | - Add `String` number type to disable numeric conversions
 93 | 
 94 | ## [0.1.1] - 2019-12-20
 95 | 
 96 | - Improve handling of whitespace in shared strings
 97 | 
 98 | ## [0.1.0] - 2019-12-16
 99 | 
100 | - Initial release
101 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ![XlsxReader logo](https://raw.githubusercontent.com/xavier/xlsx_reader/master/assets/logo.png)
  2 | 
  3 | # XlsxReader
  4 | 
  5 | ![Build status](https://github.com/xavier/xlsx_reader/workflows/CI/badge.svg)
  6 | 
  7 | An XLSX reader in Elixir.
  8 | 
  9 | Features:
 10 | 
 11 | - Accepts XLSX data located on the file system or in memory
 12 | - Automatic type conversions (numbers, date & times, booleans)
 13 | - Optional support for arbitrary precision [decimal](https://github.com/ericmj/decimal) numbers
 14 | - Straightforward architecture: no ETS tables, no race-conditions, no manual resource management
 15 | 
 16 | The docs can be found at [https://hexdocs.pm/xlsx_reader](https://hexdocs.pm/xlsx_reader).
 17 | 
 18 | ## Installation
 19 | 
 20 | Add `xlsx_reader` as a dependency in your `mix.exs`:
 21 | 
 22 | ```elixir
 23 | def deps do
 24 |   [
 25 |     {:xlsx_reader, "~> 0.8.0"}
 26 |   ]
 27 | end
 28 | ```
 29 | 
 30 | Run `mix deps.get` in your shell to fetch and compile XlsxReader.
 31 | 
 32 | ## Examples
 33 | 
 34 | ### Loading from the file system
 35 | 
 36 | ```elixir
 37 | 
 38 | {:ok, package} = XlsxReader.open("test.xlsx")
 39 | 
 40 | XlsxReader.sheet_names(package)
 41 | # ["Sheet 1", "Sheet 2", "Sheet 3"]
 42 | 
 43 | {:ok, rows} = XlsxReader.sheet(package, "Sheet 1")
 44 | # [
 45 | #   ["Date", "Temperature"],
 46 | #   [~D[2019-11-01], 8.4],
 47 | #   [~D[2019-11-02], 7.5],
 48 | #   ...
 49 | # ]
 50 | ```
 51 | 
 52 | ### Loading from memory
 53 | 
 54 | ```elixir
 55 | blob = File.read!("test.xlsx")
 56 | 
 57 | {:ok, package} = XlsxReader.open(blob, source: :binary)
 58 | ```
 59 | 
 60 | ### Loading all sheets at once
 61 | 
 62 | ```elixir
 63 | {:ok, sheets} = XlsxReader.sheets(package)
 64 | # [
 65 | #   {"Sheet 1", [["Date", "Temperature"], ...]},
 66 | #   {"Sheet 2", [...]},
 67 | #   ...
 68 | # ]
 69 | ```
 70 | 
 71 | ### Loading sheets selectively
 72 | 
 73 | ```elixir
 74 | {:ok, sheets} = XlsxReader.sheets(package, only: ["Parameters", ~r/Sheet \d+/], except: ["Sheet 2"])
 75 | # [
 76 | #   {"Parameters", [...]},
 77 | #   {"Sheet 1", [...]},
 78 | #   {"Sheet 3", [...]},
 79 | #   {"Sheet 4", [...]},
 80 | #   ...
 81 | # ]
 82 | ```
 83 | 
 84 | ### Loading all sheets at once concurrently
 85 | 
 86 | ```elixir
 87 | {:ok, sheets} = XlsxReader.async_sheets(package)
 88 | # [
 89 | #   {"Sheet 1", [["Date", "Temperature"], ...]},
 90 | #   {"Sheet 2", [...]},
 91 | #   ...
 92 | # ]
 93 | ```
 94 | 
 95 | ### Using arbitrary precision numbers
 96 | 
 97 | ```elixir
 98 | {:ok, rows} = XlsxReader.sheet(package, "Sheet 1", number_type: Decimal)
 99 | # [
100 | #   ["Date", "Temperature"],
101 | #   [~D[2019-11-01], %Decimal{coef: 84, exp: -1, sign: 1}],
102 | #   [~D[2019-11-02], %Decimal{coef: 75, exp: -1, sign: 1}],
103 | #   ...
104 | # ]
105 | ```
106 | 
107 | ### Access cell formulas
108 | 
109 | ```elixir
110 | {:ok, rows} = XlsxReader.sheet(package, "Sheet 1", cell_data_format: :cell)
111 | # [
112 | #   [%Cell{value: 1234.0, formula: "SUM(B1, B10)", ref: "A1"}, ...],
113 | #   ...
114 | # ]
115 | ```
116 | 
117 | ## Development
118 | 
119 | ### Benchmarking
120 | 
121 | 1. `mix run benchmark/init.exs` to create the benchmarking dataset
122 | 2. `mix run benchmark/run.exs` to run the [Benchee](https://github.com/bencheeorg/benchee) suite
123 | 
124 | ## Contributors
125 | 
126 | In order of appearance:
127 | 
128 | - Xavier Defrang ([xavier](https://github.com/xavier))
129 | - Darragh Enright ([darraghenright](https://github.com/darraghenright))
130 | - Patryk Woziński ([patrykwozinski](https://github.com/patrykwozinski))
131 | - Evaldo Bratti ([evaldobratti](https://github.com/evaldobratti))
132 | - Zach Liss ([ZachLiss](https://github.com/ZachLiss))
133 | - [Paranojik](https://github.com/paranojik)
134 | - Juan Barrios ([03juan](https://github.com/03juan))
135 | - Dylan Harness ([dharness](https://github.com/dharness))
136 | - Victor Rodrigues ([rodrigues](https://github.com/rodrigues))
137 | - Jose Valim ([josevalim](https://github.com/josevalim))
138 | - Vinicius Moraes ([ding-an-sich](https://github.com/ding-an-sich))
139 | - [Gladear](https://github.com/gladear)
140 | 
141 | ## License
142 | 
143 | Copyright 2020 Xavier Defrang
144 | 
145 | Licensed under the Apache License, Version 2.0 (the "License");
146 | you may not use this file except in compliance with the License.
147 | You may obtain a copy of the License at
148 | 
149 | http://www.apache.org/licenses/LICENSE-2.0
150 | 
151 | Unless required by applicable law or agreed to in writing, software
152 | distributed under the License is distributed on an "AS IS" BASIS,
153 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
154 | See the License for the specific language governing permissions and
155 | limitations under the License.
156 | 


--------------------------------------------------------------------------------
/assets/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xavier/xlsx_reader/411a48e8234286d89e5a64fef18918e0b10e437c/assets/logo.png


--------------------------------------------------------------------------------
/assets/logo_hires.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xavier/xlsx_reader/411a48e8234286d89e5a64fef18918e0b10e437c/assets/logo_hires.png


--------------------------------------------------------------------------------
/benchmark/files/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xavier/xlsx_reader/411a48e8234286d89e5a64fef18918e0b10e437c/benchmark/files/.gitkeep


--------------------------------------------------------------------------------
/benchmark/init.exs:
--------------------------------------------------------------------------------
 1 | defmodule Generator do
 2 |   def generate_workbook(sheets, rows, cols, length) do
 3 |     %Elixlsx.Workbook{
 4 |       sheets: Enum.map(1..sheets, &generate_sheet(&1, rows, cols, length))
 5 |     }
 6 |   end
 7 | 
 8 |   def generate_sheet(index, rows, cols, length) do
 9 |     %Elixlsx.Sheet{
10 |       name: "Sheet #{index}",
11 |       rows:
12 |         for _row <- 1..rows do
13 |           Enum.map(1..cols, fn _ -> generate_string(length) end)
14 |         end
15 |     }
16 |   end
17 | 
18 |   def generate_string(length) do
19 |     length
20 |     |> :crypto.strong_rand_bytes()
21 |     |> Base.encode32()
22 |     |> binary_part(0, length)
23 |   end
24 | end
25 | 
26 | benchmarks = [
27 |   {"benchmark/files/01_small.xlsx", 4, 10, 8, 10},
28 |   {"benchmark/files/02_medium.xlsx", 8, 1024, 16, 32},
29 |   {"benchmark/files/03_large.xlsx", 16, 4096, 32, 48}
30 | ]
31 | 
32 | Enum.each(benchmarks, fn {file, sheets, rows, cols, length} ->
33 |   IO.puts("Generating #{file}…")
34 |   Elixlsx.write_to(Generator.generate_workbook(sheets, rows, cols, length), file)
35 | end)
36 | 


--------------------------------------------------------------------------------
/benchmark/run.exs:
--------------------------------------------------------------------------------
 1 | defmodule Benchmark do
 2 |   def files(), do: Path.wildcard("benchmark/files/*.xlsx")
 3 | 
 4 |   def run(files) do
 5 |     timeout = 60_000
 6 | 
 7 |     Benchee.run(
 8 |       %{
 9 |         "XlsxReader.sheets/2" => fn package ->
10 |           XlsxReader.sheets(package)
11 |         end,
12 |         "XlsxReader.async_sheets/3 - ordered" => fn package ->
13 |           XlsxReader.async_sheets(package, [], timeout: timeout)
14 |         end,
15 |         "XlsxReader.async_sheets/3 - unordered" => fn package ->
16 |           XlsxReader.async_sheets(package, [], ordered: false, timeout: timeout)
17 |         end
18 |       },
19 |       inputs: for(file <- files, do: {Path.basename(file), file}),
20 |       before_scenario: fn file ->
21 |         IO.puts("Opening #{file}...")
22 |         {:ok, package} = XlsxReader.open(file)
23 |         package
24 |       end,
25 |       time: 10,
26 |       memory_time: 2,
27 |       print: [configuration: false],
28 |       save: [path: "benchmark/output/save.benchee", tag: "previous"],
29 |       load: "benchmark/output/save.benchee"
30 |     )
31 |   end
32 | end
33 | 
34 | case Benchmark.files() do
35 |   [] ->
36 |     IO.puts("Benchmarking data is missing. Please first run: mix run benchmark/init.exs")
37 |     System.halt(1)
38 | 
39 |   files ->
40 |     Benchmark.run(files)
41 | end
42 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader.ex:
--------------------------------------------------------------------------------
  1 | defmodule XlsxReader do
  2 |   @moduledoc """
  3 | 
  4 |   Opens XLSX workbooks and reads its worksheets.
  5 | 
  6 |   ## Example
  7 | 
  8 |   ```elixir
  9 |   {:ok, package} = XlsxReader.open("test.xlsx")
 10 | 
 11 |   XlsxReader.sheet_names(package)
 12 |   # ["Sheet 1", "Sheet 2", "Sheet 3"]
 13 | 
 14 |   {:ok, rows} = XlsxReader.sheet(package, "Sheet 1")
 15 |   # [
 16 |   #   ["Date", "Temperature"],
 17 |   #   [~D[2019-11-01], 8.4],
 18 |   #   [~D[2019-11-02], 7.5],
 19 |   #   ...
 20 |   # ]
 21 |   ```
 22 | 
 23 |   ## Sheet contents
 24 | 
 25 |   Sheets are loaded on-demand by `sheet/3` and `sheets/2`.
 26 | 
 27 |   The sheet contents is returned as a list of lists:
 28 | 
 29 |   ```elixir
 30 |   [
 31 |     ["A1", "B1", "C1" | _],
 32 |     ["A2", "B2", "C2" | _],
 33 |     ["A3", "B3", "C3" | _],
 34 |     | _
 35 |   ]
 36 |   ```
 37 | 
 38 |   The behavior of the sheet parser can be customized for each
 39 |   individual sheet, see `sheet/3`.
 40 | 
 41 |   ## Cell types
 42 | 
 43 |   This library takes a best effort approach for determining cell types.
 44 |   In order of priority, the actual type of an XLSX cell value is determined using:
 45 | 
 46 |   1. basic cell properties (e.g. boolean)
 47 |   2. predefined known styles (e.g. default money/date formats)
 48 |   3. introspection of the [custom format string](https://support.microsoft.com/en-us/office/number-format-codes-5026bbd6-04bc-48cd-bf33-80f18b4eae68) associated with the cell
 49 | 
 50 |   ### Custom formats supported by default
 51 | 
 52 |   * percentages
 53 |   * ISO 8601 date/time (y-m-d)
 54 |   * US date/time (m/d/y)
 55 |   * European date/time (d/m/y)
 56 | 
 57 |   ### Additional custom formats support
 58 | 
 59 |   If the spreadsheet you need to process contains some unusual cell formatting, you
 60 |   may provide hints to map format strings to a known cell type.
 61 | 
 62 |   The hints are given as a list of `{matcher, type}` tuples. The matcher is either a
 63 |   string or regex to match against the custom format string. The supported types are:
 64 | 
 65 |   * `:string`
 66 |   * `:number`
 67 |   * `:percentage`
 68 |   * `:date`
 69 |   * `:time`
 70 |   * `:date_time`
 71 |   * `:unsupported` (used for explicitly unsupported styles and formats)
 72 | 
 73 |   ### Conversion errors
 74 | 
 75 |   Cell data which could not be converted using the detected format is returned as the `"#ERROR"` placeholder.
 76 | 
 77 |   #### Example
 78 | 
 79 |   ```elixir
 80 |   [
 81 |     {"mmm yy", :date},
 82 |     {~r/mmm? yy hh:mm/, :date_time},
 83 |     {"[$CHF]0.00", :number}
 84 |   ]
 85 |   ```
 86 | 
 87 |   To find out what custom formats are in use in the workbook, you can inspect `package.workbook.custom_formats`:
 88 | 
 89 |   ```elixir
 90 |   # num_fmt_id => format string
 91 |   %{
 92 |     "0" => "General",
 93 |     "59" => "dd/mm/yyyy",
 94 |     "60" => "dd/mm/yyyy hh:mm",
 95 |     "61" => "hh:mm",
 96 |     "62" => "0.0%",
 97 |     "63" => "[$CHF]0.00"
 98 |   }
 99 |   ```
100 | 
101 |   """
102 | 
103 |   alias XlsxReader.{PackageLoader, ZipArchive}
104 | 
105 |   @typedoc """
106 |   Source for the XLSX file: file system (`:path`) or in-memory (`:binary`)
107 |   """
108 |   @type source :: :path | :binary
109 | 
110 |   @typedoc """
111 |   Option to specify the XLSX file source
112 |   """
113 |   @type open_option ::
114 |           {:exclude_hidden_sheets?, boolean()}
115 |           | {:source, source()}
116 |           | {:supported_custom_formats, XlsxReader.Styles.supported_custom_formats()}
117 | 
118 |   @typedoc """
119 |   List of cell values
120 |   """
121 |   @type row :: list(any())
122 | 
123 |   @typedoc """
124 |   List of rows
125 |   """
126 |   @type rows :: list(row())
127 | 
128 |   @typedoc """
129 |   Sheet name
130 |   """
131 |   @type sheet_name :: String.t()
132 | 
133 |   @typedoc """
134 |   Error tuple with message describing the cause of the error
135 |   """
136 |   @type error :: {:error, String.t()}
137 | 
138 |   @doc """
139 | 
140 |   Opens an XLSX file located on the file system (default) or from memory.
141 | 
142 |   ## Examples
143 | 
144 |   ### Opening XLSX file on the file system
145 | 
146 |   ```elixir
147 |   {:ok, package} = XlsxReader.open("test.xlsx")
148 |   ```
149 | 
150 |   ### Opening XLSX file from memory
151 | 
152 |   ```elixir
153 |   blob = File.read!("test.xlsx")
154 | 
155 |   {:ok, package} = XlsxReader.open(blob, source: :binary)
156 |   ```
157 | 
158 |   ## Options
159 | 
160 |     * `source`: `:path` (on the file system, default) or `:binary` (in memory)
161 |     * `supported_custom_formats`: a list of `{regex | string, type}` tuples (see "Additional custom formats support")
162 |     * `exclude_hidden_sheets?`: Whether to exclude hidden sheets in the workbook
163 | 
164 |   """
165 |   @spec open(String.t() | binary(), [open_option()]) ::
166 |           {:ok, XlsxReader.Package.t()} | error()
167 |   def open(file, options \\ []) do
168 |     file
169 |     |> ZipArchive.handle(Keyword.get(options, :source, :path))
170 |     |> PackageLoader.open(
171 |       Keyword.take(options, [:supported_custom_formats, :exclude_hidden_sheets?])
172 |     )
173 |   end
174 | 
175 |   @doc """
176 | 
177 |   Lists the names of the sheets in the package's workbook
178 | 
179 |   """
180 |   @spec sheet_names(XlsxReader.Package.t()) :: [sheet_name()]
181 |   def sheet_names(package) do
182 |     for %{name: name} <- package.workbook.sheets, do: name
183 |   end
184 | 
185 |   @doc """
186 | 
187 |   Loads the sheet with the given name (see `sheet_names/1`)
188 | 
189 |   ## Options
190 | 
191 |     * `type_conversion` - boolean (default: `true`)
192 |     * `blank_value` - placeholder value for empty cells (default: `""`)
193 |     * `empty_rows` - include empty rows (default: `true`)
194 |     * `number_type` - type used for numeric conversion :`Integer`, `Decimal` or `Float` (default: `Float`)
195 |     * `skip_row?`: function callback that determines if a row should be skipped.
196 |        Takes precedence over `blank_value` and `empty_rows`.
197 |        Defaults to `nil` (keeping the behaviour of `blank_value` and `empty_rows`).
198 |     * `cell_data_format`: Controls the format of the cell data. Can be `:value` (default, returns the cell value only) or `:cell` (returns instances of `XlsxReader.Cell`).
199 | 
200 |   The `Decimal` type requires the [decimal](https://github.com/ericmj/decimal) library.
201 | 
202 |   ## Examples
203 | 
204 |   ### Skipping rows
205 | 
206 |   When using the `skip_row?` callback, rows are ignored in the parser which is more memory efficient.
207 | 
208 |   ```elixir
209 |   # Skip all rows for which all the values are either blank or "-"
210 |   XlsxReader.sheet(package, "Sheet1", skip_row?: fn row ->
211 |     Enum.all?(row, & String.trim(&1) in ["", "-"])
212 |   end)
213 | 
214 |   # Skip all rows for which the first column contains the text "disabled"
215 |   XlsxReader.sheet(package, "Sheet1", skip_row?: fn [column | _] ->
216 |     column == "disabled"
217 |   end)
218 |   ```
219 | 
220 |   """
221 |   @spec sheet(XlsxReader.Package.t(), sheet_name(), Keyword.t()) :: {:ok, rows()} | error()
222 |   def sheet(package, sheet_name, options \\ []) do
223 |     PackageLoader.load_sheet_by_name(package, sheet_name, options)
224 |   end
225 | 
226 |   @doc """
227 | 
228 |   Loads all the sheets in the workbook.
229 | 
230 |   On success, returns `{:ok, [{sheet_name, rows}, ...]}`.
231 | 
232 |   ## Filtering options
233 | 
234 |     * `only` - include the sheets whose name matches the filter
235 |     * `except` - exclude the sheets whose name matches the filter
236 | 
237 |   Sheets can filtered by name using:
238 | 
239 |     * a string (e.g. `"Exact Match"`)
240 |     * a regex (e.g. `~r/Sheet \d+/`)
241 |     * a list of string and/or regexes (e.g. `["Parameters", ~r/Sheet [12]/]`)
242 | 
243 |   ## Sheet options
244 | 
245 |   See `sheet/2`.
246 | 
247 |   """
248 |   @spec sheets(XlsxReader.Package.t(), Keyword.t()) ::
249 |           {:ok, list({sheet_name(), rows()})} | error()
250 |   def sheets(package, options \\ []) do
251 |     package.workbook.sheets
252 |     |> filter_sheets_by_name(
253 |       sheet_filter_option(options, :only),
254 |       sheet_filter_option(options, :except)
255 |     )
256 |     |> Enum.reduce_while([], fn sheet, acc ->
257 |       case PackageLoader.load_sheet_by_rid(package, sheet.rid, options) do
258 |         {:ok, rows} ->
259 |           {:cont, [{sheet.name, rows} | acc]}
260 | 
261 |         error ->
262 |           {:halt, error}
263 |       end
264 |     end)
265 |     |> case do
266 |       sheets when is_list(sheets) ->
267 |         {:ok, Enum.reverse(sheets)}
268 | 
269 |       error ->
270 |         error
271 |     end
272 |   end
273 | 
274 |   @doc """
275 | 
276 |   Loads all the sheets in the workbook concurrently.
277 | 
278 |   On success, returns `{:ok, [{sheet_name, rows}, ...]}`.
279 | 
280 |   When processing files with multiple sheets, `async_sheets/3` is ~3x faster than `sheets/2`
281 |   but it comes with a caveat. `async_sheets/3` uses `Task.async_stream/3` under the hood and thus
282 |   runs each concurrent task with a timeout. If you expect your dataset to be of a significant size,
283 |   you may want to increase it from the default 10000ms (see "Concurrency options" below).
284 | 
285 |   If the order in which the sheets are returned is not relevant for your application, you can
286 |   pass `ordered: false` (see "Concurrency options" below) for a modest speed gain.
287 | 
288 |   ## Filtering options
289 | 
290 |   See `sheets/2`.
291 | 
292 |   ## Sheet options
293 | 
294 |   See `sheet/2`.
295 | 
296 |   ## Concurrency options
297 | 
298 |     * `max_concurrency` - maximum number of tasks to run at the same time (default: `System.schedulers_online/0`)
299 |     * `ordered` - maintain order consistent with `sheet_names/1` (default: `true`)
300 |     * `timeout` - maximum duration in milliseconds to process a sheet (default: `10_000`)
301 | 
302 |   """
303 |   def async_sheets(package, sheet_options \\ [], task_options \\ []) do
304 |     max_concurrency = Keyword.get(task_options, :max_concurrency, System.schedulers_online())
305 |     ordered = Keyword.get(task_options, :ordered, true)
306 |     timeout = Keyword.get(task_options, :timeout, 10_000)
307 | 
308 |     package.workbook.sheets
309 |     |> filter_sheets_by_name(
310 |       sheet_filter_option(sheet_options, :only),
311 |       sheet_filter_option(sheet_options, :except)
312 |     )
313 |     |> Task.async_stream(
314 |       fn sheet ->
315 |         case PackageLoader.load_sheet_by_rid(package, sheet.rid, sheet_options) do
316 |           {:ok, rows} ->
317 |             {:ok, {sheet.name, rows}}
318 | 
319 |           error ->
320 |             error
321 |         end
322 |       end,
323 |       max_concurrency: max_concurrency,
324 |       ordered: ordered,
325 |       timeout: timeout,
326 |       on_timeout: :kill_task
327 |     )
328 |     |> Enum.reduce_while({:ok, []}, fn
329 |       {:ok, {:ok, entry}}, {:ok, acc} ->
330 |         {:cont, {:ok, [entry | acc]}}
331 | 
332 |       {:ok, error}, _acc ->
333 |         {:halt, {:error, error}}
334 | 
335 |       {:exit, :timeout}, _acc ->
336 |         {:halt, {:error, "timeout exceeded"}}
337 | 
338 |       {:exit, reason}, _acc ->
339 |         {:halt, {:error, reason}}
340 |     end)
341 |     |> case do
342 |       {:ok, list} ->
343 |         if ordered,
344 |           do: {:ok, Enum.reverse(list)},
345 |           else: {:ok, list}
346 | 
347 |       error ->
348 |         error
349 |     end
350 |   end
351 | 
352 |   ## Sheet filter
353 | 
354 |   def sheet_filter_option(options, key),
355 |     do: options |> Keyword.get(key, []) |> List.wrap()
356 | 
357 |   defp filter_sheets_by_name(sheets, [], []), do: sheets
358 | 
359 |   defp filter_sheets_by_name(sheets, only, except) do
360 |     Enum.filter(sheets, fn %{name: name} ->
361 |       filter_only?(name, only) && !filter_except?(name, except)
362 |     end)
363 |   end
364 | 
365 |   defp filter_only?(_name, []), do: true
366 |   defp filter_only?(name, filters), do: Enum.any?(filters, &filter_match?(name, &1))
367 | 
368 |   defp filter_except?(_name, []), do: false
369 |   defp filter_except?(name, filters), do: Enum.any?(filters, &filter_match?(name, &1))
370 | 
371 |   defp filter_match?(name, %Regex{} = regex), do: String.match?(name, regex)
372 |   defp filter_match?(exact_match, exact_match) when is_binary(exact_match), do: true
373 |   defp filter_match?(_, _), do: false
374 | end
375 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/array.ex:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.Array do
 2 |   @moduledoc false
 3 | 
 4 |   @type t :: :array.array()
 5 |   @type t(type) :: :array.array(type)
 6 | 
 7 |   def from_list(list) do
 8 |     :array.from_list(list, nil)
 9 |   end
10 | 
11 |   def insert(array, index, value) do
12 |     :array.set(index, value, array)
13 |   end
14 | 
15 |   def lookup(array, index, default \\ nil) do
16 |     case :array.get(index, array) do
17 |       :undefined ->
18 |         default
19 | 
20 |       value ->
21 |         value
22 |     end
23 |   end
24 | end
25 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/cell.ex:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.Cell do
 2 |   @moduledoc """
 3 |   Cell structure.
 4 | 
 5 |   This structure contains the information of a cell in a sheet.
 6 | 
 7 |   - `value` - The value of the cell
 8 |   - `formula` - The formula used in the cell, if any
 9 |   - `ref` - The cell reference, like 'A1', 'B2', etc.
10 | 
11 |   This structure is used when the `cell_data_format` option is set to `:cell`.
12 |   """
13 | 
14 |   defstruct [:value, :formula, :ref]
15 | 
16 |   @typedoc """
17 |   XLSX cell data
18 |   """
19 |   @type t :: %__MODULE__{
20 |           value: term(),
21 |           formula: String.t() | nil,
22 |           ref: String.t()
23 |         }
24 | end
25 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/cell_reference.ex:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.CellReference do
 2 |   @moduledoc false
 3 | 
 4 |   @spec parse(String.t()) :: {pos_integer(), pos_integer()} | :error
 5 |   def parse(reference) when not is_nil(reference) do
 6 |     case Regex.run(~r/\A([A-Z]+)(\d+)\z/, reference, capture: :all_but_first) do
 7 |       [letters, digits] ->
 8 |         {column_number(letters), String.to_integer(digits)}
 9 | 
10 |       _ ->
11 |         :error
12 |     end
13 |   end
14 | 
15 |   defp column_number(letters) do
16 |     letters
17 |     |> String.to_charlist()
18 |     |> Enum.reduce(0, fn character_code, column_number ->
19 |       column_number * 26 + (character_code - ?A) + 1
20 |     end)
21 |   end
22 | end
23 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/conversion.ex:
--------------------------------------------------------------------------------
  1 | defmodule XlsxReader.Conversion do
  2 |   @moduledoc """
  3 | 
  4 |   Conversion of cell values to Elixir types.
  5 | 
  6 |   """
  7 | 
  8 |   @typedoc """
  9 |   Date system identified by its reference year
 10 |   """
 11 |   @type date_system :: 1900 | 1904
 12 | 
 13 |   @typedoc """
 14 |   Supported number types identified by module name
 15 |   """
 16 |   @type number_type :: Integer | Float | Decimal | String
 17 | 
 18 |   @typedoc """
 19 |   Supported number value types
 20 |   """
 21 |   @type number_value :: integer() | float() | Decimal.t() | String.t()
 22 | 
 23 |   @doc """
 24 | 
 25 |   Converts the string representation of a truth value into to a boolean.
 26 | 
 27 |   Cells with type attribute `"b"` store boolean values as a single digit: `"1"` or `"0"`.
 28 | 
 29 |   ## Examples
 30 | 
 31 |       iex> XlsxReader.Conversion.to_boolean("1")
 32 |       {:ok, true}
 33 | 
 34 |       iex> XlsxReader.Conversion.to_boolean("0")
 35 |       {:ok, false}
 36 | 
 37 |       iex> XlsxReader.Conversion.to_boolean("true")
 38 |       :error
 39 | 
 40 |   """
 41 |   @spec to_boolean(String.t()) :: {:ok, boolean()} | :error
 42 |   def to_boolean("1"), do: {:ok, true}
 43 |   def to_boolean("0"), do: {:ok, false}
 44 |   def to_boolean(_), do: :error
 45 | 
 46 |   @doc """
 47 | 
 48 |   Converts a string into the given number type.
 49 | 
 50 |   Supported number types are: `Integer`, `Float`, `String` or `Decimal` (requires the [decimal](https://github.com/ericmj/decimal) library)
 51 | 
 52 |   ## Examples
 53 | 
 54 |       iex> XlsxReader.Conversion.to_number("123", Integer)
 55 |       {:ok, 123}
 56 | 
 57 |       iex> XlsxReader.Conversion.to_number("-123.45", Float)
 58 |       {:ok, -123.45}
 59 | 
 60 |       iex> XlsxReader.Conversion.to_number("0.12345e3", Float)
 61 |       {:ok, 123.45}
 62 | 
 63 |       iex> XlsxReader.Conversion.to_number("-123.45", Decimal)
 64 |       {:ok, %Decimal{coef: 12345, exp: -2, sign: -1}}
 65 | 
 66 |       iex> XlsxReader.Conversion.to_number("0.12345E3", Decimal)
 67 |       {:ok, %Decimal{coef: 12345, exp: -2, sign: 1}}
 68 | 
 69 |       iex> XlsxReader.Conversion.to_number("-123.45", String)
 70 |       {:ok, "-123.45"}
 71 | 
 72 |       iex> XlsxReader.Conversion.to_number("0.12345e3", String)
 73 |       {:ok, "0.12345e3"}
 74 | 
 75 |       iex> XlsxReader.Conversion.to_number("123.0", Integer)
 76 |       :error
 77 | 
 78 |   """
 79 |   @spec to_number(String.t(), number_type()) :: {:ok, number_value()} | :error
 80 | 
 81 |   def to_number(string, Integer) do
 82 |     to_integer(string)
 83 |   end
 84 | 
 85 |   def to_number(string, Float) do
 86 |     to_float(string)
 87 |   end
 88 | 
 89 |   def to_number(string, Decimal) do
 90 |     to_decimal(string)
 91 |   end
 92 | 
 93 |   def to_number(string, String) do
 94 |     {:ok, string}
 95 |   end
 96 | 
 97 |   @doc """
 98 | 
 99 |   Converts a string into a float.
100 | 
101 |   ## Examples
102 | 
103 |       iex> XlsxReader.Conversion.to_float("123")
104 |       {:ok, 123.0}
105 | 
106 |       iex> XlsxReader.Conversion.to_float("-123.45")
107 |       {:ok, -123.45}
108 | 
109 |       iex> XlsxReader.Conversion.to_float("0.12345e3")
110 |       {:ok, 123.45}
111 | 
112 |       iex> XlsxReader.Conversion.to_float("0.12345E3")
113 |       {:ok, 123.45}
114 | 
115 |       iex> XlsxReader.Conversion.to_float("bogus")
116 |       :error
117 | 
118 |   """
119 |   @spec to_float(String.t()) :: {:ok, float()} | :error
120 |   def to_float(string) do
121 |     case Float.parse(string) do
122 |       {number, ""} ->
123 |         {:ok, number}
124 | 
125 |       _ ->
126 |         :error
127 |     end
128 |   end
129 | 
130 |   @doc """
131 | 
132 |   Converts a string into an arbitrary precision [decimal](https://github.com/ericmj/decimal).
133 | 
134 |   ## Examples
135 | 
136 |       iex> XlsxReader.Conversion.to_decimal("123")
137 |       {:ok, %Decimal{coef: 123, exp: 0, sign: 1}}
138 | 
139 |       iex> XlsxReader.Conversion.to_decimal("-123.45")
140 |       {:ok, %Decimal{coef: 12345, exp: -2, sign: -1}}
141 | 
142 |       iex> XlsxReader.Conversion.to_decimal("0.12345e3")
143 |       {:ok, %Decimal{coef: 12345, exp: -2, sign: 1}}
144 | 
145 |       iex> XlsxReader.Conversion.to_decimal("0.12345E3")
146 |       {:ok, %Decimal{coef: 12345, exp: -2, sign: 1}}
147 | 
148 |       iex> XlsxReader.Conversion.to_decimal("bogus")
149 |       :error
150 | 
151 |   """
152 |   @spec to_decimal(String.t()) :: {:ok, Decimal.t()} | :error
153 |   def to_decimal(string) do
154 |     case Decimal.parse(string) do
155 |       {:ok, decimal} ->
156 |         {:ok, decimal}
157 | 
158 |       {decimal, ""} ->
159 |         {:ok, decimal}
160 | 
161 |       _ ->
162 |         :error
163 |     end
164 |   end
165 | 
166 |   @doc """
167 | 
168 |   Converts a string into an integer.
169 | 
170 |   ## Examples
171 | 
172 |       iex> XlsxReader.Conversion.to_integer("123")
173 |       {:ok, 123}
174 | 
175 |       iex> XlsxReader.Conversion.to_integer("-123")
176 |       {:ok, -123}
177 | 
178 |       iex> XlsxReader.Conversion.to_integer("123.45")
179 |       :error
180 | 
181 |       iex> XlsxReader.Conversion.to_integer("bogus")
182 |       :error
183 | 
184 |   """
185 |   @spec to_integer(String.t()) :: {:ok, integer()} | :error
186 |   def to_integer(string) do
187 |     case Integer.parse(string) do
188 |       {number, ""} ->
189 |         {:ok, number}
190 | 
191 |       _ ->
192 |         :error
193 |     end
194 |   end
195 | 
196 |   # This is why we can't have nice things: http://www.cpearson.com/excel/datetime.htm
197 |   @base_date_system_1900 ~D[1899-12-30]
198 |   @base_date_system_1904 ~D[1904-01-01]
199 | 
200 |   @doc """
201 |   Returns the base date for the given date system.
202 | 
203 |   ## Examples
204 | 
205 |       iex> XlsxReader.Conversion.base_date(1900)
206 |       ~D[1899-12-30]
207 | 
208 |       iex> XlsxReader.Conversion.base_date(1904)
209 |       ~D[1904-01-01]
210 | 
211 |       iex> XlsxReader.Conversion.base_date(2019)
212 |       :error
213 | 
214 |   """
215 |   @spec base_date(date_system()) :: Date.t() | :error
216 |   def base_date(1900), do: @base_date_system_1900
217 |   def base_date(1904), do: @base_date_system_1904
218 |   def base_date(_date_system), do: :error
219 | 
220 |   @doc """
221 | 
222 |   Converts a serial date into a `Date`.
223 | 
224 |   ## Examples
225 | 
226 |       iex> XlsxReader.Conversion.to_date("40396")
227 |       {:ok, ~D[2010-08-06]}
228 | 
229 |       iex> XlsxReader.Conversion.to_date("43783")
230 |       {:ok, ~D[2019-11-14]}
231 | 
232 |       iex> XlsxReader.Conversion.to_date("1", ~D[1999-12-31])
233 |       {:ok, ~D[2000-01-01]}
234 | 
235 |       iex> XlsxReader.Conversion.to_date("-1", ~D[1999-12-31])
236 |       :error
237 | 
238 |   """
239 |   @spec to_date(String.t(), Date.t()) :: {:ok, Date.t()} | :error
240 |   def to_date(string, base_date \\ @base_date_system_1900) do
241 |     case split_serial_date(string) do
242 |       {:ok, days, _fraction_of_24} when days > 0.0 ->
243 |         {:ok, Date.add(base_date, days)}
244 | 
245 |       {:ok, _days, _fraction_of_24} ->
246 |         :error
247 | 
248 |       error ->
249 |         error
250 |     end
251 |   end
252 | 
253 |   @doc """
254 | 
255 |   Converts a serial date to a `NaiveDateTime`.
256 | 
257 |   ## Examples
258 | 
259 |       iex> XlsxReader.Conversion.to_date_time("43783.0")
260 |       {:ok, ~N[2019-11-14 00:00:00]}
261 | 
262 |       iex> XlsxReader.Conversion.to_date_time("43783.760243055556")
263 |       {:ok, ~N[2019-11-14 18:14:45]}
264 | 
265 |       iex> XlsxReader.Conversion.to_date_time("0.4895833333333333")
266 |       {:ok, ~N[1899-12-30 11:45:00]}
267 | 
268 |       iex> XlsxReader.Conversion.to_date_time("1.760243055556", ~D[1999-12-31])
269 |       {:ok, ~N[2000-01-01 18:14:45]}
270 | 
271 |       iex> XlsxReader.Conversion.to_date_time("-30.760243055556", ~D[1999-12-31])
272 |       :error
273 | 
274 |   """
275 |   @spec to_date_time(String.t(), Date.t()) :: {:ok, NaiveDateTime.t()} | :error
276 |   def to_date_time(string, base_date \\ @base_date_system_1900) do
277 |     with {:ok, days, fraction_of_24} when days >= 0.0 <- split_serial_date(string),
278 |          date <- Date.add(base_date, days),
279 |          {:ok, time} <- fraction_of_24_to_time(fraction_of_24) do
280 |       NaiveDateTime.new(date, time)
281 |     else
282 |       {:ok, _, _} ->
283 |         :error
284 | 
285 |       {:error, _} ->
286 |         :error
287 | 
288 |       error ->
289 |         error
290 |     end
291 |   end
292 | 
293 |   ## Private
294 | 
295 |   # Splits a serial date into `{:ok, days_since_base_date, time_as_fraction_of_24}`
296 |   @spec split_serial_date(String.t()) :: {:ok, integer(), float()} | :error
297 |   defp split_serial_date(string) do
298 |     with {:ok, value} <- to_float(string) do
299 |       days = Float.floor(value)
300 |       {:ok, trunc(days), value - days}
301 |     end
302 |   end
303 | 
304 |   @seconds_per_day 60 * 60 * 24
305 | 
306 |   @spec fraction_of_24_to_time(float()) :: {:ok, Time.t()} | {:error, atom()}
307 |   defp fraction_of_24_to_time(fraction_of_24) do
308 |     seconds = round(fraction_of_24 * @seconds_per_day)
309 | 
310 |     Time.new(
311 |       seconds |> div(3600),
312 |       seconds |> div(60) |> rem(60),
313 |       seconds |> rem(60)
314 |     )
315 |   end
316 | end
317 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/number.ex:
--------------------------------------------------------------------------------
 1 | defprotocol XlsxReader.Number do
 2 |   @moduledoc false
 3 |   def multiply(number, factor)
 4 | end
 5 | 
 6 | defimpl XlsxReader.Number, for: Integer do
 7 |   def multiply(number, factor), do: number * factor
 8 | end
 9 | 
10 | defimpl XlsxReader.Number, for: Float do
11 |   def multiply(number, factor), do: number * factor
12 | end
13 | 
14 | defimpl XlsxReader.Number, for: Decimal do
15 |   def multiply(number, factor), do: Decimal.mult(number, factor)
16 | end
17 | 
18 | defimpl XlsxReader.Number, for: String do
19 |   def multiply(number, _factor), do: number
20 | end
21 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/package.ex:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.Package do
 2 |   @moduledoc """
 3 | 
 4 |   XSLX Package structure.
 5 | 
 6 |   This structure is initialized by `XlsxReader.open/2` and is used to access
 7 |   the contents of the file
 8 | 
 9 |   It should not be manipulated directly.
10 | 
11 |   """
12 | 
13 |   @enforce_keys [:zip_handle, :workbook]
14 |   defstruct zip_handle: nil, workbook: nil
15 | 
16 |   @typedoc """
17 |   XLSX package
18 |   """
19 |   @type t :: %__MODULE__{
20 |           zip_handle: XlsxReader.ZipArchive.zip_handle(),
21 |           workbook: XlsxReader.Workbook.t()
22 |         }
23 | end
24 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/package_loader.ex:
--------------------------------------------------------------------------------
  1 | defmodule XlsxReader.PackageLoader do
  2 |   @moduledoc false
  3 | 
  4 |   # Loads the content of an XLSX file.
  5 |   #
  6 |   # An XLSX file is ZIP archive containing XML files linked to each other
  7 |   # using relationships defined in `_rels/*.xml.rels` files.
  8 | 
  9 |   alias XlsxReader.Parsers.{
 10 |     RelationshipsParser,
 11 |     SharedStringsParser,
 12 |     StylesParser,
 13 |     Utils,
 14 |     WorkbookParser,
 15 |     WorksheetParser
 16 |   }
 17 | 
 18 |   alias XlsxReader.ZipArchive
 19 | 
 20 |   @typedoc """
 21 |   Source for the XLSX file: file system (`:path`) or in-memory (`:binary`)
 22 |   """
 23 |   @type source :: :path | :binary
 24 | 
 25 |   @typedoc """
 26 |   Option to specify the XLSX file source
 27 |   """
 28 |   @type open_option ::
 29 |           {:exclude_hidden_sheets?, boolean()}
 30 |           | {:source, source()}
 31 |           | {:supported_custom_formats, [{String.t() | Regex.t(), atom()}]}
 32 | 
 33 |   @doc """
 34 | 
 35 |   Opens an XLSX package.
 36 | 
 37 |   It verifies the contents of the archive and preloads the workbook sheet list
 38 |   and relationships as well as the shared strings and style information required
 39 |   to load the sheet data.
 40 | 
 41 |   To load the actual sheet data, see `load_sheet_by_rid/3` and `load_sheet_by_name/3`.
 42 | 
 43 |   """
 44 |   @spec open(XlsxReader.ZipArchive.zip_handle()) ::
 45 |           {:ok, XlsxReader.Package.t()} | XlsxReader.error()
 46 |   def open(zip_handle, options \\ []) do
 47 |     with :ok <- check_contents(zip_handle),
 48 |          {:ok, workbook} <- load_workbook_xml(zip_handle, options),
 49 |          {:ok, workbook_rels} <- load_workbook_xml_rels(zip_handle) do
 50 |       package =
 51 |         %XlsxReader.Package{
 52 |           zip_handle: zip_handle,
 53 |           workbook: %{workbook | rels: workbook_rels}
 54 |         }
 55 |         |> load_shared_strings
 56 |         |> load_styles(Keyword.get(options, :supported_custom_formats, []))
 57 | 
 58 |       {:ok, package}
 59 |     end
 60 |   end
 61 | 
 62 |   @doc """
 63 |   Loads a single sheet identified by relationship id (`rId`)
 64 | 
 65 |   ## Options
 66 | 
 67 |   See `XlsxReader.sheet/2`.
 68 | 
 69 |   """
 70 |   @spec load_sheet_by_rid(XlsxReader.Package.t(), String.t(), Keyword.t()) ::
 71 |           {:ok, XlsxReader.row()} | XlsxReader.error()
 72 |   def load_sheet_by_rid(package, rid, options \\ []) do
 73 |     case fetch_rel_target(package.workbook.rels, :sheets, rid) do
 74 |       {:ok, target} ->
 75 |         load_worksheet_xml(package, xl_path(target), options)
 76 | 
 77 |       :error ->
 78 |         {:error, "sheet relationship not found"}
 79 |     end
 80 |   end
 81 | 
 82 |   @doc """
 83 |   Loads a single sheet identified by name
 84 | 
 85 |   ## Options
 86 | 
 87 |   See `XlsxReader.sheet/2`.
 88 | 
 89 |   """
 90 |   @spec load_sheet_by_name(XlsxReader.Package.t(), String.t(), Keyword.t()) ::
 91 |           {:ok, XlsxReader.row()} | XlsxReader.error()
 92 |   def load_sheet_by_name(package, name, options \\ []) do
 93 |     case find_sheet_by_name(package, name) do
 94 |       %{rid: rid} ->
 95 |         load_sheet_by_rid(package, rid, options)
 96 | 
 97 |       nil ->
 98 |         {:error, "sheet #{inspect(name)} not found"}
 99 |     end
100 |   end
101 | 
102 |   ##
103 | 
104 |   @workbook_xml "xl/workbook.xml"
105 |   @workbook_xml_rels "xl/_rels/workbook.xml.rels"
106 | 
107 |   @required_files [
108 |     "[Content_Types].xml",
109 |     @workbook_xml,
110 |     @workbook_xml_rels
111 |   ]
112 | 
113 |   defp check_contents(zip_handle) do
114 |     with {:ok, files} <- ZipArchive.list(zip_handle) do
115 |       if Enum.all?(@required_files, &Enum.member?(files, &1)),
116 |         do: :ok,
117 |         else: {:error, "invalid xlsx file"}
118 |     end
119 |   end
120 | 
121 |   defp load_workbook_xml(zip_handle, options) do
122 |     options = Keyword.take(options, [:exclude_hidden_sheets?])
123 | 
124 |     with {:ok, xml} <- extract_xml(zip_handle, @workbook_xml) do
125 |       WorkbookParser.parse(xml, options)
126 |     end
127 |   end
128 | 
129 |   defp load_workbook_xml_rels(zip_handle) do
130 |     with {:ok, xml} <- extract_xml(zip_handle, @workbook_xml_rels) do
131 |       RelationshipsParser.parse(xml)
132 |     end
133 |   end
134 | 
135 |   defp load_shared_strings(package) do
136 |     with {:ok, file} <- single_rel_target(package.workbook.rels.shared_strings),
137 |          {:ok, xml} <- extract_xml(package.zip_handle, file),
138 |          {:ok, shared_strings} <- SharedStringsParser.parse(xml) do
139 |       %{package | workbook: %{package.workbook | shared_strings: shared_strings}}
140 |     else
141 |       {:error, :no_rel_target} ->
142 |         package
143 |     end
144 |   end
145 | 
146 |   defp load_styles(package, supported_custom_formats) do
147 |     with {:ok, file} <- single_rel_target(package.workbook.rels.styles),
148 |          {:ok, xml} <- extract_xml(package.zip_handle, file),
149 |          {:ok, style_types, custom_formats} <- StylesParser.parse(xml, supported_custom_formats) do
150 |       %{
151 |         package
152 |         | workbook: %{package.workbook | style_types: style_types, custom_formats: custom_formats}
153 |       }
154 |     else
155 |       {:error, :no_rel_target} ->
156 |         package
157 |     end
158 |   end
159 | 
160 |   defp single_rel_target(rels) do
161 |     case Map.values(rels) do
162 |       [target] ->
163 |         {:ok, xl_path(target)}
164 | 
165 |       [] ->
166 |         {:error, :no_rel_target}
167 | 
168 |       targets ->
169 |         {:error, "expected a single rel target, got #{inspect(targets)}"}
170 |     end
171 |   end
172 | 
173 |   defp load_worksheet_xml(package, file, options) do
174 |     with {:ok, xml} <- extract_xml(package.zip_handle, file) do
175 |       WorksheetParser.parse(xml, package.workbook, options)
176 |     end
177 |   end
178 | 
179 |   defp extract_xml(zip_handle, file) do
180 |     with {:ok, xml} <- ZipArchive.extract(zip_handle, file) do
181 |       Utils.ensure_utf8(xml)
182 |     end
183 |   end
184 | 
185 |   defp xl_path(relative_path), do: Path.join("xl", relative_path)
186 | 
187 |   defp find_sheet_by_name(package, name) do
188 |     Enum.find(package.workbook.sheets, fn %{name: n} -> name == n end)
189 |   end
190 | 
191 |   defp fetch_rel_target(rels, type, rid) do
192 |     with {:ok, paths} <- Map.fetch(rels, type) do
193 |       Map.fetch(paths, rid)
194 |     end
195 |   end
196 | end
197 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/parsers/relationships_parser.ex:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.Parsers.RelationshipsParser do
 2 |   @moduledoc false
 3 | 
 4 |   # Parses SpreadsheetML workbook relationships.
 5 |   #
 6 |   # The relationships determine the exact location of the shared strings, styles,
 7 |   # themes and worksheet files within the archive.
 8 | 
 9 |   alias XlsxReader.Parsers.Utils
10 | 
11 |   @behaviour Saxy.Handler
12 | 
13 |   def parse(xml) do
14 |     Saxy.parse_string(xml, __MODULE__, %{
15 |       shared_strings: %{},
16 |       styles: %{},
17 |       themes: %{},
18 |       sheets: %{}
19 |     })
20 |   end
21 | 
22 |   @namespace "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
23 | 
24 |   @types %{
25 |     "#{@namespace}/sharedStrings" => :shared_strings,
26 |     "#{@namespace}/styles" => :styles,
27 |     "#{@namespace}/theme" => :themes,
28 |     "#{@namespace}/worksheet" => :sheets
29 |   }
30 | 
31 |   @impl Saxy.Handler
32 |   def handle_event(:start_document, _prolog, state) do
33 |     {:ok, state}
34 |   end
35 | 
36 |   @impl Saxy.Handler
37 |   def handle_event(:end_document, _data, state) do
38 |     {:ok, state}
39 |   end
40 | 
41 |   @impl Saxy.Handler
42 |   def handle_event(:start_element, {"Relationship", attributes}, state) do
43 |     with %{id: id, target: target, type: type} <- extract_relationship_attributes(attributes),
44 |          {:ok, key} <- Map.fetch(@types, type) do
45 |       {:ok, Map.update!(state, key, fn rels -> Map.put_new(rels, id, target) end)}
46 |     else
47 |       _ ->
48 |         {:ok, state}
49 |     end
50 |   end
51 | 
52 |   @impl Saxy.Handler
53 |   def handle_event(:start_element, _element, state) do
54 |     {:ok, state}
55 |   end
56 | 
57 |   @impl Saxy.Handler
58 |   def handle_event(:end_element, _name, state) do
59 |     {:ok, state}
60 |   end
61 | 
62 |   @impl Saxy.Handler
63 |   def handle_event(:characters, _chars, state) do
64 |     {:ok, state}
65 |   end
66 | 
67 |   ##
68 | 
69 |   @relationship_attributes_mapping %{
70 |     "Id" => :id,
71 |     "Target" => :target,
72 |     "Type" => :type
73 |   }
74 | 
75 |   defp extract_relationship_attributes(attributes) do
76 |     Utils.map_attributes(attributes, @relationship_attributes_mapping)
77 |   end
78 | end
79 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/parsers/shared_strings_parser.ex:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.Parsers.SharedStringsParser do
 2 |   @moduledoc false
 3 | 
 4 |   # Parses SpreadsheetML shared strings definitions.
 5 |   #
 6 |   # The parser builds a list of shared strings.
 7 |   #
 8 |   # Worksheets only contain numbers: the value of cells containing text is
 9 |   # numeric index to the array of shared strings.
10 | 
11 |   @behaviour Saxy.Handler
12 | 
13 |   alias XlsxReader.Array
14 |   alias XlsxReader.Parsers.Utils
15 | 
16 |   defmodule State do
17 |     @moduledoc false
18 | 
19 |     defstruct current_string: nil,
20 |               strings: [],
21 |               expect_chars: false,
22 |               preserve_space: false
23 |   end
24 | 
25 |   def parse(xml) do
26 |     Saxy.parse_string(xml, __MODULE__, %State{})
27 |   end
28 | 
29 |   @impl Saxy.Handler
30 |   def handle_event(:start_document, _prolog, state) do
31 |     {:ok, state}
32 |   end
33 | 
34 |   @impl Saxy.Handler
35 |   def handle_event(:end_document, _data, state) do
36 |     {:ok, Array.from_list(Enum.reverse(state.strings))}
37 |   end
38 | 
39 |   @impl Saxy.Handler
40 |   def handle_event(:start_element, {"si", _attributes}, state) do
41 |     {:ok, %{state | current_string: ""}}
42 |   end
43 | 
44 |   @impl Saxy.Handler
45 |   def handle_event(:start_element, {"t", attributes}, state) do
46 |     {:ok,
47 |      %{
48 |        state
49 |        | expect_chars: true,
50 |          preserve_space: Utils.get_attribute(attributes, "xml:space") == "preserve"
51 |      }}
52 |   end
53 | 
54 |   @impl Saxy.Handler
55 |   def handle_event(:start_element, _element, state) do
56 |     {:ok, state}
57 |   end
58 | 
59 |   @impl Saxy.Handler
60 |   def handle_event(:end_element, "t", state) do
61 |     {:ok, %{state | expect_chars: false, preserve_space: false}}
62 |   end
63 | 
64 |   @impl Saxy.Handler
65 |   def handle_event(:end_element, "si", state) do
66 |     {:ok, %{state | current_string: nil, strings: [state.current_string | state.strings]}}
67 |   end
68 | 
69 |   @impl Saxy.Handler
70 |   def handle_event(:end_element, _name, state) do
71 |     {:ok, state}
72 |   end
73 | 
74 |   @impl Saxy.Handler
75 |   def handle_event(:characters, chars, %{expect_chars: true} = state) do
76 |     {:ok, %{state | current_string: state.current_string <> preserve_space(state, chars)}}
77 |   end
78 | 
79 |   @impl Saxy.Handler
80 |   def handle_event(:characters, _chars, %{expect_chars: false} = state) do
81 |     {:ok, state}
82 |   end
83 | 
84 |   ##
85 |   defp preserve_space(%{preserve_space: true}, string), do: string
86 |   defp preserve_space(%{preserve_space: false}, string), do: String.trim(string)
87 | end
88 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/parsers/styles_parser.ex:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.Parsers.StylesParser do
 2 |   @moduledoc false
 3 | 
 4 |   # Parses SpreadsheetML style definitions.
 5 |   #
 6 |   # It extracts the relevant subset of style definitions in order to build
 7 |   # a `style_types` array which is used to look up the cell value format
 8 |   # for type conversions.
 9 | 
10 |   @behaviour Saxy.Handler
11 | 
12 |   alias XlsxReader.{Array, Styles}
13 |   alias XlsxReader.Parsers.Utils
14 | 
15 |   defmodule State do
16 |     @moduledoc false
17 |     defstruct collect_xf: false,
18 |               style_types: [],
19 |               custom_formats: %{},
20 |               supported_custom_formats: []
21 |   end
22 | 
23 |   def parse(xml, supported_custom_formats \\ []) do
24 |     with {:ok, state} <-
25 |            Saxy.parse_string(xml, __MODULE__, %State{
26 |              supported_custom_formats: supported_custom_formats
27 |            }) do
28 |       {:ok, state.style_types, state.custom_formats}
29 |     end
30 |   end
31 | 
32 |   @impl Saxy.Handler
33 |   def handle_event(:start_document, _prolog, state) do
34 |     {:ok, state}
35 |   end
36 | 
37 |   @impl Saxy.Handler
38 |   def handle_event(:end_document, _data, state) do
39 |     {:ok, state}
40 |   end
41 | 
42 |   @impl Saxy.Handler
43 |   def handle_event(:start_element, {"numFmt", attributes}, state) do
44 |     num_fmt_id = Utils.get_attribute(attributes, "numFmtId")
45 |     format_code = Utils.get_attribute(attributes, "formatCode")
46 |     {:ok, %{state | custom_formats: Map.put(state.custom_formats, num_fmt_id, format_code)}}
47 |   end
48 | 
49 |   @impl Saxy.Handler
50 |   def handle_event(:start_element, {"cellXfs", _attributes}, state) do
51 |     {:ok, %{state | collect_xf: true}}
52 |   end
53 | 
54 |   @impl Saxy.Handler
55 |   def handle_event(:start_element, {"xf", attributes}, %{collect_xf: true} = state) do
56 |     num_fmt_id = Utils.get_attribute(attributes, "numFmtId")
57 | 
58 |     {:ok,
59 |      %{
60 |        state
61 |        | style_types: [
62 |            Styles.get_style_type(
63 |              num_fmt_id,
64 |              state.custom_formats,
65 |              state.supported_custom_formats
66 |            )
67 |            | state.style_types
68 |          ]
69 |      }}
70 |   end
71 | 
72 |   @impl Saxy.Handler
73 |   def handle_event(:start_element, _element, state) do
74 |     {:ok, state}
75 |   end
76 | 
77 |   @impl Saxy.Handler
78 |   def handle_event(:end_element, "cellXfs", state) do
79 |     {:ok,
80 |      %{state | collect_xf: false, style_types: Array.from_list(Enum.reverse(state.style_types))}}
81 |   end
82 | 
83 |   @impl Saxy.Handler
84 |   def handle_event(:end_element, _name, state) do
85 |     {:ok, state}
86 |   end
87 | 
88 |   @impl Saxy.Handler
89 |   def handle_event(:characters, _chars, state) do
90 |     {:ok, state}
91 |   end
92 | end
93 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/parsers/utils.ex:
--------------------------------------------------------------------------------
  1 | defmodule XlsxReader.Parsers.Utils do
  2 |   @moduledoc false
  3 | 
  4 |   # Utility functions used by the XML parser modules
  5 | 
  6 |   @type xml_attribute :: {String.t(), String.t()}
  7 |   @type xml_attributes :: [xml_attribute]
  8 | 
  9 |   @doc """
 10 | 
 11 |   Get value of attribute by name
 12 | 
 13 |   ## Examples
 14 | 
 15 |       iex> XlsxReader.Parsers.Utils.get_attribute([{"a", "x"}, {"b", "y"}, {"c", "y"}], "a")
 16 |       "x"
 17 | 
 18 |       iex> XlsxReader.Parsers.Utils.get_attribute([{"a", "x"}, {"b", "y"}, {"c", "y"}], "b")
 19 |       "y"
 20 | 
 21 |       iex> XlsxReader.Parsers.Utils.get_attribute([{"a", "x"}, {"b", "y"}, {"c", "z"}], "c")
 22 |       "z"
 23 | 
 24 |       iex> XlsxReader.Parsers.Utils.get_attribute([{"a", "x"}, {"b", "y"}, {"c", "z"}], "d")
 25 |       nil
 26 | 
 27 |       iex> XlsxReader.Parsers.Utils.get_attribute([{"a", "x"}, {"b", "y"}, {"c", "z"}], "d", "default")
 28 |       "default"
 29 | 
 30 |   """
 31 |   @spec get_attribute(xml_attributes(), String.t(), nil | String.t()) ::
 32 |           nil | String.t()
 33 |   def get_attribute(attributes, name, default \\ nil)
 34 |   def get_attribute([], _name, default), do: default
 35 |   def get_attribute([{name, value} | _], name, _default), do: value
 36 |   def get_attribute([_ | rest], name, default), do: get_attribute(rest, name, default)
 37 | 
 38 |   @doc """
 39 | 
 40 |   Extracts XML attributes into to map based on the given mapping
 41 | 
 42 |   ## Examples
 43 | 
 44 |       iex> XlsxReader.Parsers.Utils.map_attributes([{"a", "x"}, {"b", "y"}], %{"a" => :foo, "b" => :bar, "c" => :baz})
 45 |       %{foo: "x", bar: "y"}
 46 | 
 47 |   """
 48 | 
 49 |   @spec map_attributes(xml_attributes(), map(), map()) :: map()
 50 |   def map_attributes(attributes, mapping, initial \\ %{}) do
 51 |     Enum.reduce(attributes, initial, fn {name, value}, acc ->
 52 |       case Map.fetch(mapping, name) do
 53 |         {:ok, key} ->
 54 |           Map.put(acc, key, value)
 55 | 
 56 |         :error ->
 57 |           acc
 58 |       end
 59 |     end)
 60 |   end
 61 | 
 62 |   @doc """
 63 | 
 64 |   Returns an UTF-8 binary which is the only character encoding supported by the XML parser.
 65 | 
 66 |   Converts to UTF-8 from UTF-16BE/LE if a BOM is detected.
 67 | 
 68 |   ## Examples
 69 | 
 70 |       iex> XlsxReader.Parsers.Utils.ensure_utf8("UTF-8")
 71 |       {:ok, "UTF-8"}
 72 | 
 73 |       iex> XlsxReader.Parsers.Utils.ensure_utf8("\uFEFFUTF-8 with BOM")
 74 |       {:ok, "UTF-8 with BOM"}
 75 | 
 76 |       iex> XlsxReader.Parsers.Utils.ensure_utf8(<<0xff, 0xfe, 0x55, 0x00, 0x54, 0x00, 0x46, 0x00, 0x2d, 0x00, 0x31, 0x00, 0x36, 0x00, 0x4c, 0x00, 0x45, 0x00>>)
 77 |       {:ok, "UTF-16LE"}
 78 | 
 79 |       iex> XlsxReader.Parsers.Utils.ensure_utf8(<<0xfe, 0xff, 0x00, 0x55, 0x00, 0x54, 0x00, 0x46, 0x00, 0x2d, 0x00, 0x31, 0x00, 0x36, 0x00, 0x42, 0x00, 0x45>>)
 80 |       {:ok, "UTF-16BE"}
 81 | 
 82 |       iex> XlsxReader.Parsers.Utils.ensure_utf8(<<0xff, 0xfe, 0x00>>)
 83 |       {:error, "incomplete UTF-16LE binary"}
 84 | 
 85 |   """
 86 |   @spec ensure_utf8(binary()) :: {:ok, String.t()} | {:error, String.t()}
 87 |   def ensure_utf8(string) do
 88 |     case :unicode.bom_to_encoding(string) do
 89 |       {:latin1, 0} ->
 90 |         # No BOM found, assumes UTF-8
 91 |         {:ok, string}
 92 | 
 93 |       {:utf8, bom_length} ->
 94 |         # BOM found with UTF-8 encoding
 95 |         {:ok, strip_bom(string, bom_length)}
 96 | 
 97 |       {encoding, bom_length} ->
 98 |         # BOM found with UTF-16/32 encoding given as an {encoding, endianess} tuple
 99 |         string |> strip_bom(bom_length) |> convert_to_utf8(encoding)
100 |     end
101 |   end
102 | 
103 |   defp strip_bom(string, bom_length) do
104 |     :binary.part(string, {bom_length, byte_size(string) - bom_length})
105 |   end
106 | 
107 |   defp convert_to_utf8(string, encoding) do
108 |     case :unicode.characters_to_binary(string, encoding) do
109 |       utf8 when is_binary(utf8) ->
110 |         {:ok, utf8}
111 | 
112 |       {:error, _, _} ->
113 |         {:error, "error converting #{format_encoding(encoding)} binary to UTF-8"}
114 | 
115 |       {:incomplete, _, _} ->
116 |         {:error, "incomplete #{format_encoding(encoding)} binary"}
117 |     end
118 |   end
119 | 
120 |   defp format_encoding({:utf16, endianess}), do: "UTF-16#{format_endianess(endianess)}"
121 |   defp format_encoding({:utf32, endianess}), do: "UTF-32#{format_endianess(endianess)}"
122 | 
123 |   def format_endianess(:big), do: "BE"
124 |   def format_endianess(:little), do: "LE"
125 | end
126 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/parsers/workbook_parser.ex:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.Parsers.WorkbookParser do
 2 |   @moduledoc false
 3 | 
 4 |   # Parses SpreadsheetML workbooks.
 5 |   #
 6 |   # The `workbook.xml` contains the worksheet list and their relationship identifier (`rId`).
 7 |   # The workbook may also contain a hint regarding the [date system](https://docs.microsoft.com/en-us/office/troubleshoot/excel/1900-and-1904-date-system) in use.
 8 |   #
 9 | 
10 |   @behaviour Saxy.Handler
11 | 
12 |   alias XlsxReader.Conversion
13 |   alias XlsxReader.Parsers.Utils
14 | 
15 |   @doc """
16 |   Parses a workbook XML document.
17 | 
18 |   ## Options
19 |     * `:exclude_hidden_sheets?` - Whether to exclude hidden sheets in the workbook
20 |   """
21 |   def parse(xml, options \\ []) do
22 |     exclude_hidden_sheets? = Keyword.get(options, :exclude_hidden_sheets?, false)
23 | 
24 |     Saxy.parse_string(xml, __MODULE__, %XlsxReader.Workbook{
25 |       options: %{exclude_hidden_sheets?: exclude_hidden_sheets?}
26 |     })
27 |   end
28 | 
29 |   @impl Saxy.Handler
30 |   def handle_event(:start_document, _prolog, workbook) do
31 |     {:ok, workbook}
32 |   end
33 | 
34 |   @impl Saxy.Handler
35 |   def handle_event(:end_document, _data, workbook) do
36 |     {:ok, %{workbook | base_date: workbook.base_date || Conversion.base_date(1900)}}
37 |   end
38 | 
39 |   @impl Saxy.Handler
40 |   def handle_event(:start_element, {"workbookPr", attributes}, workbook) do
41 |     {:ok, %{workbook | base_date: attributes |> date_system() |> Conversion.base_date()}}
42 |   end
43 | 
44 |   @impl Saxy.Handler
45 |   def handle_event(:start_element, {"sheet", attributes}, workbook) do
46 |     is_hidden? = attributes |> Utils.get_attribute("state") === "hidden"
47 |     skip_sheet? = workbook.options.exclude_hidden_sheets? && is_hidden?
48 | 
49 |     case skip_sheet? do
50 |       true -> {:ok, workbook}
51 |       false -> {:ok, %{workbook | sheets: [build_sheet(attributes) | workbook.sheets]}}
52 |     end
53 |   end
54 | 
55 |   @impl Saxy.Handler
56 |   def handle_event(:start_element, _element, workbook) do
57 |     {:ok, workbook}
58 |   end
59 | 
60 |   @impl Saxy.Handler
61 |   def handle_event(:end_element, "sheets", workbook) do
62 |     {:ok, %{workbook | sheets: Enum.reverse(workbook.sheets)}}
63 |   end
64 | 
65 |   @impl Saxy.Handler
66 |   def handle_event(:end_element, _name, workbook) do
67 |     {:ok, workbook}
68 |   end
69 | 
70 |   @impl Saxy.Handler
71 |   def handle_event(:characters, _chars, workbook) do
72 |     {:ok, workbook}
73 |   end
74 | 
75 |   ##
76 | 
77 |   @sheet_attributes %{
78 |     "name" => :name,
79 |     "r:id" => :rid,
80 |     "sheetId" => :sheet_id
81 |   }
82 | 
83 |   defp build_sheet(attributes) do
84 |     Utils.map_attributes(attributes, @sheet_attributes, %XlsxReader.Sheet{})
85 |   end
86 | 
87 |   defp date_system(attributes) do
88 |     if Utils.get_attribute(attributes, "date1904", "0") == "1",
89 |       do: 1904,
90 |       else: 1900
91 |   end
92 | end
93 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/parsers/worksheet_parser.ex:
--------------------------------------------------------------------------------
  1 | defmodule XlsxReader.Parsers.WorksheetParser do
  2 |   @moduledoc false
  3 | 
  4 |   # Parses SpreadsheetML worksheets.
  5 | 
  6 |   @behaviour Saxy.Handler
  7 | 
  8 |   alias XlsxReader.{Cell, CellReference, Conversion, Number}
  9 |   alias XlsxReader.Parsers.Utils
 10 | 
 11 |   defmodule State do
 12 |     @moduledoc false
 13 |     @enforce_keys [:workbook, :type_conversion, :blank_value]
 14 |     defstruct workbook: nil,
 15 |               rows: [],
 16 |               row: nil,
 17 |               current_row: nil,
 18 |               expected_row: 1,
 19 |               expected_column: nil,
 20 |               cell_ref: nil,
 21 |               cell_type: nil,
 22 |               cell_style: nil,
 23 |               value: nil,
 24 |               formula: nil,
 25 |               shared_formula_index: nil,
 26 |               shared_formulas: :array.new(),
 27 |               type_conversion: nil,
 28 |               blank_value: nil,
 29 |               empty_rows: nil,
 30 |               number_type: nil,
 31 |               skip_row?: nil,
 32 |               cell_data_format: :value
 33 |   end
 34 | 
 35 |   @doc """
 36 |   Parse the given worksheet XML in the context of the given workbook.
 37 | 
 38 |   ## Options
 39 | 
 40 |     * `type_conversion`: boolean (default: `true`)
 41 |     * `blank_value`: placeholder value for empty cells (default: `""`)
 42 |     * `empty_rows`: include empty rows (default: `true`)
 43 |     * `number_type` - type used for numeric conversion : `String` (no conversion), `Integer`, 'Decimal' or `Float`  (default: `Float`)
 44 |     * `skip_row?`: function callback that determines if a row should be skipped or not.
 45 |        Overwrites `blank_value` and `empty_rows` on the matter of skipping rows.
 46 |        Defaults to `nil` (keeping the behaviour of `blank_value` and `empty_rows`).
 47 |     * `cell_data_format`: Controls the format of the cell data. Can be `:value` (default, returns the cell value only) or `:cell` (returns instances of `XlsxReader.Cell`).
 48 | 
 49 |   """
 50 |   def parse(xml, workbook, options \\ []) do
 51 |     Saxy.parse_string(xml, __MODULE__, %State{
 52 |       workbook: workbook,
 53 |       type_conversion: Keyword.get(options, :type_conversion, true),
 54 |       blank_value: Keyword.get(options, :blank_value, ""),
 55 |       empty_rows: Keyword.get(options, :empty_rows, true),
 56 |       number_type: Keyword.get(options, :number_type, Float),
 57 |       skip_row?: Keyword.get(options, :skip_row?),
 58 |       cell_data_format: Keyword.get(options, :cell_data_format, :value)
 59 |     })
 60 |   end
 61 | 
 62 |   @impl Saxy.Handler
 63 |   def handle_event(:start_document, _prolog, state) do
 64 |     {:ok, state}
 65 |   end
 66 | 
 67 |   @impl Saxy.Handler
 68 |   def handle_event(:end_document, _data, state) do
 69 |     {:ok, state.rows}
 70 |   end
 71 | 
 72 |   @impl Saxy.Handler
 73 |   def handle_event(:start_element, {"row", attributes}, state) do
 74 |     # Some XLSX writers (Excel, Elixlsx, …) completely omit `<row>` or `<c>` elements when empty.
 75 |     # As we build the sheet, we'll keep track of the expected row and column number and
 76 |     # fill the blanks as needed usingthe coordinates indicated in the row or cell reference.
 77 | 
 78 |     current_row =
 79 |       case Utils.get_attribute(attributes, "r") do
 80 |         nil ->
 81 |           state.expected_row
 82 | 
 83 |         value ->
 84 |           String.to_integer(value)
 85 |       end
 86 | 
 87 |     {:ok,
 88 |      %{
 89 |        state
 90 |        | row: [],
 91 |          current_row: current_row,
 92 |          expected_column: 1
 93 |      }}
 94 |   end
 95 | 
 96 |   def handle_event(:start_element, {"c", attributes}, state) do
 97 |     {:ok, new_cell(state, extract_cell_attributes(attributes))}
 98 |   end
 99 | 
100 |   def handle_event(:start_element, {"v", _attributes}, state) do
101 |     {:ok, expect_value(state)}
102 |   end
103 | 
104 |   def handle_event(:start_element, {"t", _attributes}, state) do
105 |     {:ok, expect_value(state)}
106 |   end
107 | 
108 |   def handle_event(:start_element, {"f", attributes}, state) do
109 |     type = Utils.get_attribute(attributes, "t")
110 |     ref = Utils.get_attribute(attributes, "ref")
111 | 
112 |     case {type, ref} do
113 |       {"shared", ref} when is_binary(ref) ->
114 |         string_index = Utils.get_attribute(attributes, "si")
115 |         {:ok, expect_shared_formula(state, string_index)}
116 | 
117 |       _ ->
118 |         {:ok, expect_formula(state)}
119 |     end
120 |   end
121 | 
122 |   @impl Saxy.Handler
123 |   def handle_event(:start_element, _element, state) do
124 |     {:ok, state}
125 |   end
126 | 
127 |   @impl Saxy.Handler
128 |   def handle_event(:end_element, "c", state) do
129 |     {:ok, add_cell_to_row(state)}
130 |   end
131 | 
132 |   @impl Saxy.Handler
133 |   def handle_event(:end_element, "f", %{formula: nil} = state) do
134 |     formula = lookup_shared_formula(state, state.shared_formula_index)
135 |     {:ok, store_formula(state, formula)}
136 |   end
137 | 
138 |   @impl Saxy.Handler
139 |   def handle_event(:end_element, "row", state) do
140 |     if skip_row?(state) do
141 |       {:ok, skip_row(state)}
142 |     else
143 |       {:ok, emit_row(state)}
144 |     end
145 |   end
146 | 
147 |   @impl Saxy.Handler
148 |   def handle_event(:end_element, "sheetData", state) do
149 |     {:ok, restore_rows_order(state)}
150 |   end
151 | 
152 |   @impl Saxy.Handler
153 |   def handle_event(:end_element, _name, state) do
154 |     {:ok, state}
155 |   end
156 | 
157 |   @impl Saxy.Handler
158 |   def handle_event(:characters, chars, %{value: :expect_chars} = state) do
159 |     {:ok, store_value(state, chars)}
160 |   end
161 | 
162 |   @impl Saxy.Handler
163 |   def handle_event(:characters, chars, %{value: :expect_formula} = state) do
164 |     {:ok, store_formula(state, chars)}
165 |   end
166 | 
167 |   @impl Saxy.Handler
168 |   def handle_event(:characters, chars, %{value: :expect_shared_formula} = state) do
169 |     state = store_shared_formula(state, state.shared_formula_index, chars)
170 |     {:ok, store_formula(state, chars)}
171 |   end
172 | 
173 |   @impl Saxy.Handler
174 |   def handle_event(:characters, _chars, state) do
175 |     {:ok, state}
176 |   end
177 | 
178 |   ##
179 | 
180 |   ## State machine
181 | 
182 |   defp new_cell(state, cell_attributes) do
183 |     state
184 |     |> Map.merge(cell_attributes)
185 |     |> handle_omitted_cells()
186 |   end
187 | 
188 |   defp expect_value(state) do
189 |     %{state | value: :expect_chars}
190 |   end
191 | 
192 |   defp expect_formula(state) do
193 |     %{state | value: :expect_formula}
194 |   end
195 | 
196 |   defp expect_shared_formula(state, string_index) do
197 |     {:ok, index} = Conversion.to_integer(string_index)
198 |     shared_formulas = state.shared_formulas |> XlsxReader.Array.insert(index, nil)
199 | 
200 |     %{
201 |       state
202 |       | value: :expect_shared_formula,
203 |         shared_formulas: shared_formulas,
204 |         shared_formula_index: index
205 |     }
206 |   end
207 | 
208 |   defp store_value(state, value) do
209 |     %{state | value: value}
210 |   end
211 | 
212 |   defp store_formula(state, formula) do
213 |     %{state | formula: formula}
214 |   end
215 | 
216 |   defp store_shared_formula(state, index, formula) do
217 |     shared_formulas = state.shared_formulas |> XlsxReader.Array.insert(index, formula)
218 |     %{state | shared_formulas: shared_formulas}
219 |   end
220 | 
221 |   defp add_cell_to_row(state) do
222 |     %{
223 |       state
224 |       | row: [format_cell_data(state) | state.row],
225 |         cell_ref: nil,
226 |         cell_type: nil,
227 |         value: nil,
228 |         formula: nil
229 |     }
230 |   end
231 | 
232 |   defp skip_row?(%{skip_row?: skip_row?, row: row}) when is_function(skip_row?) do
233 |     skip_row?.(row)
234 |   end
235 | 
236 |   defp skip_row?(%{empty_rows: false} = state), do: empty_row?(state)
237 | 
238 |   defp skip_row?(_state), do: false
239 | 
240 |   defp empty_row?(state) do
241 |     Enum.all?(state.row, fn value -> value == state.blank_value end)
242 |   end
243 | 
244 |   defp skip_row(state) do
245 |     %{state | row: nil, expected_row: state.current_row + 1}
246 |   end
247 | 
248 |   defp emit_row(state) do
249 |     state = handle_omitted_rows(state)
250 |     row = state.row |> sanitize_row() |> Enum.reverse()
251 | 
252 |     %{
253 |       state
254 |       | row: nil,
255 |         rows: [row | state.rows],
256 |         expected_row: state.current_row + 1
257 |     }
258 |   end
259 | 
260 |   defp sanitize_row(row) do
261 |     Enum.map(row, fn
262 |       # If the <c> element has no text child node, we didn't receive any :characters event
263 |       # and the current value still contains the placeholder used by the parser
264 |       :expect_chars -> ""
265 |       :expect_formula -> ""
266 |       # Otherwise assume that the row contains an actual value
267 |       value -> value
268 |     end)
269 |   end
270 | 
271 |   defp restore_rows_order(state) do
272 |     %{state | rows: Enum.reverse(state.rows)}
273 |   end
274 | 
275 |   ## Omitted rows / cells
276 | 
277 |   defp handle_omitted_rows(%{empty_rows: true} = state) do
278 |     omitted_rows = state.current_row - state.expected_row
279 | 
280 |     if omitted_rows > 0 do
281 |       blank_row = List.duplicate(state.blank_value, length(state.row))
282 |       %{state | rows: prepend_n_times(state.rows, blank_row, omitted_rows)}
283 |     else
284 |       state
285 |     end
286 |   end
287 | 
288 |   defp handle_omitted_rows(state), do: state
289 | 
290 |   defp handle_omitted_cells(state) do
291 |     # Using the current cell reference and the expected column:
292 |     # 1. fill any missing cell
293 |     # 2. determine the next expected column
294 |     with %{cell_ref: cell_ref} when not is_nil(cell_ref) <- state,
295 |          {column, _row} <- CellReference.parse(cell_ref) do
296 |       omitted_cells = column - state.expected_column
297 | 
298 |       state
299 |       |> add_omitted_cells_to_row(omitted_cells)
300 |       |> Map.put(:expected_column, column + 1)
301 |     else
302 |       _ ->
303 |         state
304 |     end
305 |   end
306 | 
307 |   defp add_omitted_cells_to_row(state, n) do
308 |     %{state | row: prepend_n_times(state.row, state.blank_value, n)}
309 |   end
310 | 
311 |   defp prepend_n_times(list, _value, 0), do: list
312 | 
313 |   defp prepend_n_times(list, value, n) when n > 0,
314 |     do: prepend_n_times([value | list], value, n - 1)
315 | 
316 |   ## Cell format handling
317 | 
318 |   defp extract_cell_attributes(attributes) do
319 |     # Initialize current cell attributes
320 |     Utils.map_attributes(
321 |       attributes,
322 |       %{
323 |         "r" => :cell_ref,
324 |         "s" => :cell_style,
325 |         "t" => :cell_type
326 |       },
327 |       # Make we start from a blank slate to prevent reusing the previous cell data
328 |       # if one of the attribute is missing
329 |       %{cell_ref: nil, cell_style: nil, cell_type: nil}
330 |     )
331 |   end
332 | 
333 |   defp format_cell_data(state) do
334 |     value = convert_current_cell_value(state)
335 | 
336 |     case state.cell_data_format do
337 |       :cell -> %Cell{value: value, formula: state.formula, ref: state.cell_ref}
338 |       :value -> value
339 |       _ -> value
340 |     end
341 |   end
342 | 
343 |   defp convert_current_cell_value(%State{type_conversion: false} = state) do
344 |     case {state.cell_type, state.value} do
345 |       {_, nil} ->
346 |         state.blank_value
347 | 
348 |       {"s", value} ->
349 |         lookup_shared_string(state, value)
350 | 
351 |       {_, value} ->
352 |         value
353 |     end
354 |   end
355 | 
356 |   # credo:disable-for-lines:54 Credo.Check.Refactor.CyclomaticComplexity
357 |   defp convert_current_cell_value(%State{type_conversion: true} = state) do
358 |     style_type = lookup_current_cell_style_type(state)
359 | 
360 |     case {state.cell_type, style_type, state.value} do
361 |       # Blank
362 | 
363 |       {_, _, value} when is_nil(value) or value == "" ->
364 |         state.blank_value
365 | 
366 |       # Strings
367 | 
368 |       {"s", _, value} ->
369 |         lookup_shared_string(state, value)
370 | 
371 |       {"inlineStr", _, value} ->
372 |         value
373 | 
374 |       {nil, :string, value} ->
375 |         value
376 | 
377 |       {"b", _, value} ->
378 |         value |> Conversion.to_boolean() |> handle_conversion_error
379 | 
380 |       # Numbers
381 | 
382 |       {"n", :date, value} ->
383 |         value |> Conversion.to_date(state.workbook.base_date) |> handle_conversion_error()
384 | 
385 |       {"n", type, value} when type in [:time, :date_time] ->
386 |         value |> Conversion.to_date_time(state.workbook.base_date) |> handle_conversion_error()
387 | 
388 |       {"n", _, value} ->
389 |         value |> Conversion.to_number(state.number_type) |> handle_conversion_error()
390 | 
391 |       {nil, :number, value} ->
392 |         value |> Conversion.to_number(state.number_type) |> handle_conversion_error()
393 | 
394 |       {_, :percentage, value} ->
395 |         case Conversion.to_number(value, state.number_type) do
396 |           {:ok, number} ->
397 |             Number.multiply(number, 100)
398 | 
399 |           _ ->
400 |             "#ERROR"
401 |         end
402 | 
403 |       # Dates/times
404 | 
405 |       {nil, :date, value} ->
406 |         value |> Conversion.to_date(state.workbook.base_date) |> handle_conversion_error()
407 | 
408 |       {nil, type, value} when type in [:time, :date_time] ->
409 |         value |> Conversion.to_date_time(state.workbook.base_date) |> handle_conversion_error()
410 | 
411 |       # Fall back
412 | 
413 |       {_, _, value} ->
414 |         value
415 |     end
416 |   end
417 | 
418 |   defp handle_conversion_error({:ok, value}), do: value
419 |   defp handle_conversion_error(_error), do: "#ERROR"
420 | 
421 |   defp lookup_current_cell_style_type(state) do
422 |     if state.cell_style,
423 |       do: lookup_index(state.workbook.style_types, state.cell_style),
424 |       else: nil
425 |   end
426 | 
427 |   defp lookup_shared_string(state, value) do
428 |     lookup_index(state.workbook.shared_strings, value)
429 |   end
430 | 
431 |   defp lookup_shared_formula(state, index) do
432 |     state.shared_formulas |> XlsxReader.Array.lookup(index)
433 |   end
434 | 
435 |   defp lookup_index(nil, _string_index), do: nil
436 | 
437 |   defp lookup_index(table, string_index) do
438 |     {:ok, index} = Conversion.to_integer(string_index)
439 |     XlsxReader.Array.lookup(table, index)
440 |   end
441 | end
442 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/sheet.ex:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.Sheet do
 2 |   @moduledoc """
 3 | 
 4 |   Worksheet structure.
 5 | 
 6 |   This structure only contains the information useful to identify and retrieve the sheet actual data.
 7 | 
 8 |   - `name` - name of the sheet
 9 |   - `rid` - relationship ID used to retrieve the corresponding sheet in the archive
10 |   - `sheet_id` - unique identifier of the sheet withing the workbook (unused by XlsxReader)
11 | 
12 |   To access the sheet cells, see `XlsxReader.sheet/3` and `XlsxReader.sheets/2`.
13 | 
14 |   """
15 | 
16 |   defstruct [:name, :rid, :sheet_id]
17 | 
18 |   @typedoc """
19 |   XLSX worksheet metadata
20 |   """
21 |   @type t :: %__MODULE__{
22 |           name: String.t(),
23 |           rid: String.t(),
24 |           sheet_id: String.t()
25 |         }
26 | end
27 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/styles.ex:
--------------------------------------------------------------------------------
  1 | defmodule XlsxReader.Styles do
  2 |   @moduledoc """
  3 |   Utility functions and types to deal with cell styles
  4 |   """
  5 | 
  6 |   @typedoc """
  7 |   Knwon cell styles for which type conversion is supported
  8 |   """
  9 |   @type known_style_type ::
 10 |           :string | :number | :percentage | :date | :time | :date_time | :unsupported
 11 |   @typedoc """
 12 |   Cell styles for which type conversion is supported
 13 |   """
 14 |   @type style_type :: known_style_type() | String.t()
 15 |   @type style_types :: XlsxReader.Array.t(style_type())
 16 |   @type custom_formats :: %{optional(String.t()) => String.t()}
 17 |   @typedoc """
 18 |   Matches the text representation of a cell value
 19 |   """
 20 |   @type custom_format_matcher :: String.t() | Regex.t()
 21 |   @type supported_custom_formats :: [{custom_format_matcher(), known_style_type()}]
 22 | 
 23 |   @known_styles %{
 24 |     # General
 25 |     "0" => :number,
 26 |     # 0
 27 |     "1" => :number,
 28 |     # 0.00
 29 |     "2" => :number,
 30 |     # #,##0
 31 |     "3" => :number,
 32 |     # #,##0.00
 33 |     "4" => :number,
 34 |     # $#,##0_);($#,##0)
 35 |     "5" => :unsupported,
 36 |     # $#,##0_);[Red]($#,##0)
 37 |     "6" => :unsupported,
 38 |     # $#,##0.00_);($#,##0.00)
 39 |     "7" => :unsupported,
 40 |     # $#,##0.00_);[Red]($#,##0.00)
 41 |     "8" => :unsupported,
 42 |     # 0%
 43 |     "9" => :percentage,
 44 |     # 0.00%
 45 |     "10" => :percentage,
 46 |     # 0.00E+00
 47 |     "11" => :number,
 48 |     # # ?/?
 49 |     "12" => :unsupported,
 50 |     # # ??/??
 51 |     "13" => :unsupported,
 52 |     # mm-dd-yy
 53 |     "14" => :date,
 54 |     # d-mmm-yy
 55 |     "15" => :date,
 56 |     # d-mmm
 57 |     "16" => :date,
 58 |     # mmm-yy
 59 |     "17" => :date,
 60 |     # h:mm AM/PM
 61 |     "18" => :time,
 62 |     # h:mm:ss AM/PM
 63 |     "19" => :time,
 64 |     # h:mm
 65 |     "20" => :time,
 66 |     # h:mm:ss
 67 |     "21" => :time,
 68 |     # m/d/yy h:mm
 69 |     "22" => :date_time,
 70 |     # #,##0 ;(#,##0)
 71 |     "37" => :unsupported,
 72 |     # #,##0 ;[Red](#,##0)
 73 |     "38" => :unsupported,
 74 |     # #,##0.00;(#,##0.00)
 75 |     "39" => :unsupported,
 76 |     # #,##0.00;[Red](#,##0.00)
 77 |     "40" => :unsupported,
 78 |     # mm:ss
 79 |     "45" => :time,
 80 |     # [h]:mm:ss
 81 |     "46" => :time,
 82 |     # mmss.0
 83 |     "47" => :time,
 84 |     # ##0.0E+0
 85 |     "48" => :number,
 86 |     # @
 87 |     "49" => :unsupported
 88 |   }
 89 | 
 90 |   @default_supported_custom_formats [
 91 |     {"0.0%", :percentage},
 92 |     {~r/\Add?\/mm?\/yy(?:yy)\z/, :date},
 93 |     {~r/\Add?\/mm?\/yy(?:yy) hh?:mm?\z/, :date_time},
 94 |     {"yyyy-mm-dd", :date},
 95 |     {~r/\Ayyyy-mm-dd[T\s]hh?:mm:ssZ?\z/, :date_time},
 96 |     {"m/d/yyyy", :date},
 97 |     {"m/d/yyyy h:mm", :date_time},
 98 |     {"hh:mm", :time}
 99 |   ]
100 | 
101 |   @doc """
102 |   Guesses the type of a cell based on its style.
103 | 
104 |   The type is:
105 | 
106 |   1. looked-up from a list of "standard" styles, or
107 |   2. guessed from a list of default supported custom formats, or
108 |   3. guessed from a list of user-provided supported custom formats.
109 | 
110 |   If no type could be guessed, returns `nil`.
111 | 
112 |   """
113 |   @spec get_style_type(String.t(), custom_formats(), supported_custom_formats()) ::
114 |           style_type() | nil
115 |   def get_style_type(num_fmt_id, custom_formats \\ %{}, supported_custom_formats \\ []) do
116 |     get_known_style(num_fmt_id) ||
117 |       get_custom_style(num_fmt_id, custom_formats, supported_custom_formats)
118 |   end
119 | 
120 |   defp get_known_style(num_fmt_id),
121 |     do: Map.get(@known_styles, num_fmt_id)
122 | 
123 |   defp get_custom_style(num_fmt_id, custom_formats, supported_custom_formats) do
124 |     get_style_type_from_custom_format(
125 |       num_fmt_id,
126 |       custom_formats,
127 |       @default_supported_custom_formats
128 |     ) ||
129 |       get_style_type_from_custom_format(
130 |         num_fmt_id,
131 |         custom_formats,
132 |         supported_custom_formats
133 |       )
134 |   end
135 | 
136 |   defp get_style_type_from_custom_format(num_fmt_id, custom_formats, supported_custom_format) do
137 |     custom_formats
138 |     |> Map.get(num_fmt_id)
139 |     |> custom_format_to_style_type(supported_custom_format)
140 |   end
141 | 
142 |   defp custom_format_to_style_type(nil, _), do: nil
143 |   defp custom_format_to_style_type(_custom_format, []), do: nil
144 | 
145 |   defp custom_format_to_style_type(custom_format, [{%Regex{} = regex, style_type} | others]) do
146 |     if Regex.match?(regex, custom_format),
147 |       do: style_type,
148 |       else: custom_format_to_style_type(custom_format, others)
149 |   end
150 | 
151 |   defp custom_format_to_style_type(custom_format, [{custom_format, style_type} | _others]),
152 |     do: style_type
153 | 
154 |   defp custom_format_to_style_type(custom_format, [_ | others]),
155 |     do: custom_format_to_style_type(custom_format, others)
156 | end
157 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/workbook.ex:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.Workbook do
 2 |   @moduledoc """
 3 | 
 4 |   Workbook structure.
 5 | 
 6 |   - `sheets` - list of sheet metadata
 7 |   - `rels` - workbook relationships
 8 |   - `shared_strings` - list of shared strings
 9 |   - `style_types` - List of types indexed by style
10 |   - `custom_formats` - Map of custom formats declared for this document
11 |   - `base_date` - base date for all serial dates in the workbook
12 |   - `options` - Map of options for the workbook. Currently includes:
13 |     - `exclude_hidden_sheets?`: Whether to exclude hidden sheets in the workbook
14 | 
15 |   """
16 | 
17 |   defstruct sheets: [],
18 |             rels: nil,
19 |             shared_strings: nil,
20 |             style_types: nil,
21 |             custom_formats: nil,
22 |             base_date: nil,
23 |             options: %{
24 |               exclude_hidden_sheets?: false
25 |             }
26 | 
27 |   @typedoc """
28 |   XLSX workbook
29 |   """
30 |   @type t :: %__MODULE__{
31 |           sheets: [XlsxReader.Sheet.t()],
32 |           rels: nil | map(),
33 |           shared_strings: nil | XlsxReader.Array.t(String.t()),
34 |           style_types: nil | XlsxReader.Styles.style_types(),
35 |           custom_formats: map(),
36 |           base_date: nil | Date.t(),
37 |           options: %{exclude_hidden_sheets?: boolean()}
38 |         }
39 | end
40 | 


--------------------------------------------------------------------------------
/lib/xlsx_reader/zip_archive.ex:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.ZipArchive do
 2 |   @moduledoc false
 3 | 
 4 |   # Zip archive utility functions.
 5 |   #
 6 |   # To allow for transparent handling of archives located on disk or in memory,
 7 |   # you must first obtain a handle with `handle/2` which can then be used to
 8 |   # access the contents of the archive.
 9 | 
10 |   @type source :: String.t() | binary()
11 |   @type source_type :: :path | :binary
12 |   @type zip_handle :: {:path, String.t()} | {:binary, binary()}
13 | 
14 |   @doc """
15 | 
16 |   Returns a `zip_handle` to be used by `list/1` and `extract/2`
17 | 
18 |   """
19 |   @spec handle(source(), source_type()) :: zip_handle()
20 |   def handle(source, type) when type in [:path, :binary],
21 |     do: {type, source}
22 | 
23 |   @doc """
24 | 
25 |   Lists the content of the archive.
26 | 
27 |   """
28 |   @spec list(zip_handle()) :: {:ok, [String.t()]} | XlsxReader.error()
29 |   def list(zip_handle) do
30 |     with {:ok, zip} <- source(zip_handle),
31 |          {:ok, entries} <- :zip.list_dir(zip) do
32 |       {:ok, collect_files(entries)}
33 |     else
34 |       error ->
35 |         translate_zip_error(error)
36 |     end
37 |   end
38 | 
39 |   @doc """
40 | 
41 |   Extracts a file from the archive
42 | 
43 |   """
44 |   @spec extract(zip_handle(), String.t()) :: {:ok, binary()} | XlsxReader.error()
45 |   def extract(zip_handle, file) do
46 |     with {:ok, zip} <- source(zip_handle),
47 |          {:ok, [{_, contents}]} <- :zip.extract(zip, extract_options(file)) do
48 |       {:ok, contents}
49 |     else
50 |       {:ok, []} ->
51 |         {:error, "file #{inspect(file)} not found in archive"}
52 | 
53 |       error ->
54 |         translate_zip_error(error)
55 |     end
56 |   end
57 | 
58 |   ##
59 | 
60 |   defp source({:path, path}) do
61 |     {:ok, String.to_charlist(path)}
62 |   end
63 | 
64 |   defp source({:binary, binary}) do
65 |     {:ok, binary}
66 |   end
67 | 
68 |   defp collect_files(entries) do
69 |     entries
70 |     |> Enum.reduce([], fn entry, acc ->
71 |       case entry do
72 |         {:zip_file, path, _, _, _, _} ->
73 |           [to_string(path) | acc]
74 | 
75 |         _ ->
76 |           acc
77 |       end
78 |     end)
79 |     |> Enum.sort()
80 |   end
81 | 
82 |   def extract_options(file) do
83 |     [{:file_list, [String.to_charlist(file)]}, :memory]
84 |   end
85 | 
86 |   defp translate_zip_error({:error, :enoent}) do
87 |     {:error, "file not found"}
88 |   end
89 | 
90 |   defp translate_zip_error({:error, code})
91 |        when code in [:einval, :bad_eocd, :bad_central_directory, :eisdir] do
92 |     {:error, "invalid zip file"}
93 |   end
94 | end
95 | 


--------------------------------------------------------------------------------
/mix.exs:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.MixProject do
 2 |   use Mix.Project
 3 | 
 4 |   def project do
 5 |     [
 6 |       app: :xlsx_reader,
 7 |       version: "0.8.8",
 8 |       elixir: "~> 1.10",
 9 |       start_permanent: Mix.env() == :prod,
10 |       deps: deps(),
11 |       description: description(),
12 |       package: package(),
13 |       dialyzer: [
14 |         plt_ignore_apps: [:saxy]
15 |       ],
16 |       # Docs
17 |       homepage_url: "https://github.com/xavier/xlsx_reader",
18 |       source_url: "https://github.com/xavier/xlsx_reader",
19 |       docs: [
20 |         main: "XlsxReader",
21 |         logo: "assets/logo.png",
22 |         extras: ["README.md"]
23 |       ]
24 |     ]
25 |   end
26 | 
27 |   # Run "mix help compile.app" to learn about applications.
28 |   def application do
29 |     [
30 |       extra_applications: [:logger]
31 |     ]
32 |   end
33 | 
34 |   # Run "mix help deps" to learn about dependencies.
35 |   defp deps do
36 |     [
37 |       {:saxy, "~> 1.5"},
38 |       {:credo, "~> 1.4.0", only: [:dev, :test], runtime: false},
39 |       {:decimal, "~> 1.0 or ~> 2.0", optional: true},
40 |       {:dialyxir, "~> 1.0.0", only: :dev, runtime: false},
41 |       {:ex_doc, "~> 0.22", only: :dev, runtime: false},
42 |       {:elixlsx, "~> 0.4.0", only: [:dev, :test], runtime: false},
43 |       {:benchee, "~> 1.0", only: :dev}
44 |     ]
45 |   end
46 | 
47 |   defp description do
48 |     "XLSX file reader for Elixir"
49 |   end
50 | 
51 |   defp package do
52 |     %{
53 |       licenses: ["Apache-2.0"],
54 |       links: %{"GitHub" => "https://github.com/xavier/xlsx_reader"}
55 |     }
56 |   end
57 | end
58 | 


--------------------------------------------------------------------------------
/mix.lock:
--------------------------------------------------------------------------------
 1 | %{
 2 |   "benchee": {:hex, :benchee, "1.0.1", "66b211f9bfd84bd97e6d1beaddf8fc2312aaabe192f776e8931cb0c16f53a521", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}], "hexpm", "3ad58ae787e9c7c94dd7ceda3b587ec2c64604563e049b2a0e8baafae832addb"},
 3 |   "bunt": {:hex, :bunt, "0.2.0", "951c6e801e8b1d2cbe58ebbd3e616a869061ddadcc4863d0a2182541acae9a38", [:mix], [], "hexpm", "7af5c7e09fe1d40f76c8e4f9dd2be7cebd83909f31fee7cd0e9eadc567da8353"},
 4 |   "credo": {:hex, :credo, "1.4.0", "92339d4cbadd1e88b5ee43d427b639b68a11071b6f73854e33638e30a0ea11f5", [:mix], [{:bunt, "~> 0.2.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "1fd3b70dce216574ce3c18bdf510b57e7c4c85c2ec9cad4bff854abaf7e58658"},
 5 |   "decimal": {:hex, :decimal, "1.8.1", "a4ef3f5f3428bdbc0d35374029ffcf4ede8533536fa79896dd450168d9acdf3c", [:mix], [], "hexpm", "3cb154b00225ac687f6cbd4acc4b7960027c757a5152b369923ead9ddbca7aec"},
 6 |   "deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
 7 |   "dialyxir": {:hex, :dialyxir, "1.0.0", "6a1fa629f7881a9f5aaf3a78f094b2a51a0357c843871b8bc98824e7342d00a5", [:mix], [{:erlex, ">= 0.2.6", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm", "aeb06588145fac14ca08d8061a142d52753dbc2cf7f0d00fc1013f53f8654654"},
 8 |   "earmark": {:hex, :earmark, "1.4.5", "62ffd3bd7722fb7a7b1ecd2419ea0b458c356e7168c1f5d65caf09b4fbdd13c8", [:mix], [], "hexpm"},
 9 |   "earmark_parser": {:hex, :earmark_parser, "1.4.39", "424642f8335b05bb9eb611aa1564c148a8ee35c9c8a8bba6e129d51a3e3c6769", [:mix], [], "hexpm", "06553a88d1f1846da9ef066b87b57c6f605552cfbe40d20bd8d59cc6bde41944"},
10 |   "elixlsx": {:hex, :elixlsx, "0.4.2", "37dd3ada960eb1fd32ddb8736a984787a9a22734ebb305cde0c437805938dee3", [:mix], [], "hexpm", "6e42e53f193275adeafd1252f8c07cb0dabf50da356b4d75b12a8ed8e5322733"},
11 |   "erlex": {:hex, :erlex, "0.2.6", "c7987d15e899c7a2f34f5420d2a2ea0d659682c06ac607572df55a43753aa12e", [:mix], [], "hexpm", "2ed2e25711feb44d52b17d2780eabf998452f6efda104877a3881c2f8c0c0c75"},
12 |   "ex_doc": {:hex, :ex_doc, "0.32.1", "21e40f939515373bcdc9cffe65f3b3543f05015ac6c3d01d991874129d173420", [:mix], [{:earmark_parser, "~> 1.4.39", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_c, ">= 0.1.1", [hex: :makeup_c, repo: "hexpm", optional: true]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1", [hex: :makeup_erlang, repo: "hexpm", optional: false]}], "hexpm", "5142c9db521f106d61ff33250f779807ed2a88620e472ac95dc7d59c380113da"},
13 |   "jason": {:hex, :jason, "1.2.0", "10043418c42d2493d0ee212d3fddd25d7ffe484380afad769a0a38795938e448", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "116747dbe057794c3a3e4e143b7c8390b29f634e16c78a7f59ba75bfa6852e7f"},
14 |   "makeup": {:hex, :makeup, "1.1.1", "fa0bc768698053b2b3869fa8a62616501ff9d11a562f3ce39580d60860c3a55e", [:mix], [{:nimble_parsec, "~> 1.2.2 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "5dc62fbdd0de44de194898b6710692490be74baa02d9d108bc29f007783b0b48"},
15 |   "makeup_elixir": {:hex, :makeup_elixir, "0.16.2", "627e84b8e8bf22e60a2579dad15067c755531fea049ae26ef1020cad58fe9578", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "41193978704763f6bbe6cc2758b84909e62984c7752b3784bd3c218bb341706b"},
16 |   "makeup_erlang": {:hex, :makeup_erlang, "0.1.1", "3fcb7f09eb9d98dc4d208f49cc955a34218fc41ff6b84df7c75b3e6e533cc65f", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "174d0809e98a4ef0b3309256cbf97101c6ec01c4ab0b23e926a9e17df2077cbb"},
17 |   "nimble_parsec": {:hex, :nimble_parsec, "1.4.0", "51f9b613ea62cfa97b25ccc2c1b4216e81df970acd8e16e8d1bdc58fef21370d", [:mix], [], "hexpm", "9c565862810fb383e9838c1dd2d7d2c437b3d13b267414ba6af33e50d2d1cf28"},
18 |   "saxy": {:hex, :saxy, "1.5.0", "0141127f2d042856f135fb2d94e0beecda7a2306f47546dbc6411fc5b07e28bf", [:mix], [], "hexpm", "ea7bb6328fbd1f2aceffa3ec6090bfb18c85aadf0f8e5030905e84235861cf89"},
19 | }
20 | 


--------------------------------------------------------------------------------
/test/compatibility_test.exs:
--------------------------------------------------------------------------------
  1 | # credo:disable-for-this-file Credo.Check.Readability.LargeNumbers
  2 | defmodule CompatibilityTest do
  3 |   use ExUnit.Case
  4 | 
  5 |   describe "elixlsx" do
  6 |     test "file generated by elixlsx" do
  7 |       test_row = [
  8 |         "string1",
  9 |         "",
 10 |         nil,
 11 |         :empty,
 12 |         "string1",
 13 |         "string2",
 14 |         123,
 15 |         true,
 16 |         false
 17 |       ]
 18 | 
 19 |       workbook = %Elixlsx.Workbook{
 20 |         sheets: [
 21 |           %Elixlsx.Sheet{
 22 |             name: "sheet1",
 23 |             rows: [
 24 |               test_row
 25 |             ]
 26 |           },
 27 |           %Elixlsx.Sheet{name: "sheet2", rows: []}
 28 |         ]
 29 |       }
 30 | 
 31 |       assert {:ok, {_filename, zip_binary}} = Elixlsx.write_to_memory(workbook, "test.xlsx")
 32 | 
 33 |       assert {:ok, package} = XlsxReader.open(zip_binary, source: :binary)
 34 | 
 35 |       assert ["sheet1", "sheet2"] = XlsxReader.sheet_names(package)
 36 | 
 37 |       assert {:ok,
 38 |               [
 39 |                 [
 40 |                   "string1",
 41 |                   "",
 42 |                   nil,
 43 |                   nil,
 44 |                   "string1",
 45 |                   "string2",
 46 |                   123.0,
 47 |                   true,
 48 |                   false
 49 |                 ]
 50 |               ]} = XlsxReader.sheet(package, "sheet1", blank_value: nil)
 51 | 
 52 |       assert {:ok, []} = XlsxReader.sheet(package, "sheet2")
 53 |     end
 54 | 
 55 |     test "sheets with dates and datetimes" do
 56 |       s1 =
 57 |         Elixlsx.Sheet.with_name("1")
 58 |         |> Elixlsx.Sheet.set_cell("A1", {{2015, 11, 30}, {21, 20, 38}}, datetime: true)
 59 | 
 60 |       s2 =
 61 |         Elixlsx.Sheet.with_name("2")
 62 |         |> Elixlsx.Sheet.set_cell("A1", {{2015, 11, 30}, {21, 20, 38}}, yyyymmdd: true)
 63 | 
 64 |       wk = %Elixlsx.Workbook{sheets: [s1, s2]}
 65 | 
 66 |       {:ok, {_filename, bin}} = Elixlsx.write_to_memory(wk, "test.xlsx")
 67 |       {:ok, package} = XlsxReader.open(bin, source: :binary)
 68 |       {:ok, sheets} = XlsxReader.sheets(package)
 69 | 
 70 |       assert [{"1", [[~N[2015-11-30 21:20:38]]]}, {"2", [[~D[2015-11-30]]]}] = sheets
 71 |     end
 72 |   end
 73 | 
 74 |   test "google_spreadsheet.xlsx" do
 75 |     assert {:ok, package} =
 76 |              XlsxReader.open(
 77 |                TestFixtures.path("google_spreadsheet.xlsx"),
 78 |                supported_custom_formats: [{"mmmm d", :date}]
 79 |              )
 80 | 
 81 |     assert ["Sheet1"] = XlsxReader.sheet_names(package)
 82 | 
 83 |     assert {:ok,
 84 |             [
 85 |               ["integer", 123.0],
 86 |               ["float", 123.456],
 87 |               ["percentage", 12.5],
 88 |               ["date", ~D[2019-11-15]],
 89 |               ["time", ~N[1899-12-30 11:45:00]],
 90 |               ["ticked\n", true],
 91 |               ["unticked", false],
 92 |               ["image", ""]
 93 |             ]} = XlsxReader.sheet(package, "Sheet1")
 94 |   end
 95 | 
 96 |   test "merged.xlsx" do
 97 |     assert {:ok, package} = XlsxReader.open(TestFixtures.path("merged.xlsx"))
 98 | 
 99 |     assert ["merged"] = XlsxReader.sheet_names(package)
100 | 
101 |     assert {:ok,
102 |             [
103 |               ["horizontal", "", "vertical"],
104 |               ["horizontal + vertical", "", ""],
105 |               ["", "", "none"]
106 |             ]} = XlsxReader.sheet(package, "merged")
107 |   end
108 | 
109 |   test "file with omitted row elements" do
110 |     assert {:ok, package} = XlsxReader.open(TestFixtures.path("omitted_row.xlsx"))
111 | 
112 |     assert {:ok, [["", ""], ["", "b2"]]} = XlsxReader.sheet(package, "Sheet1", empty_rows: true)
113 |     assert {:ok, [["", "b2"]]} = XlsxReader.sheet(package, "Sheet1", empty_rows: false)
114 |   end
115 | 
116 |   test "cells with missing attributes" do
117 |     # The worksheet has a mix of "s", "t" and no attributes
118 |     assert {:ok, package} = XlsxReader.open(TestFixtures.path("cells_missing_attributes.xlsx"))
119 | 
120 |     assert {
121 |              :ok,
122 |              [
123 |                [
124 |                  "Number",
125 |                  "Name",
126 |                  "Effective Date",
127 |                  "ID Number",
128 |                  "Operator",
129 |                  "County",
130 |                  "State",
131 |                  "Product",
132 |                  "Description",
133 |                  "Acres"
134 |                ],
135 |                [
136 |                  "Number",
137 |                  "Name",
138 |                  # Date with s="5" is converted
139 |                  ~D[2024-07-01],
140 |                  # This cell has no attributes at all, it's treated as a string
141 |                  # and not converted to a date because all cell attributes are
142 |                  # properly reset
143 |                  "5575789630",
144 |                  "Operator",
145 |                  "County",
146 |                  "State",
147 |                  "Product",
148 |                  "Description",
149 |                  "Acres"
150 |                ]
151 |              ]
152 |            } = XlsxReader.sheet(package, "Sheet 1")
153 |   end
154 | end
155 | 


--------------------------------------------------------------------------------
/test/fixtures/cells_missing_attributes.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xavier/xlsx_reader/411a48e8234286d89e5a64fef18918e0b10e437c/test/fixtures/cells_missing_attributes.xlsx


--------------------------------------------------------------------------------
/test/fixtures/custom_dates.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xavier/xlsx_reader/411a48e8234286d89e5a64fef18918e0b10e437c/test/fixtures/custom_dates.xlsx


--------------------------------------------------------------------------------
/test/fixtures/google_spreadsheet.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xavier/xlsx_reader/411a48e8234286d89e5a64fef18918e0b10e437c/test/fixtures/google_spreadsheet.xlsx


--------------------------------------------------------------------------------
/test/fixtures/has_formulas.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xavier/xlsx_reader/411a48e8234286d89e5a64fef18918e0b10e437c/test/fixtures/has_formulas.xlsx


--------------------------------------------------------------------------------
/test/fixtures/hidden_sheets.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xavier/xlsx_reader/411a48e8234286d89e5a64fef18918e0b10e437c/test/fixtures/hidden_sheets.xlsx


--------------------------------------------------------------------------------
/test/fixtures/merged.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xavier/xlsx_reader/411a48e8234286d89e5a64fef18918e0b10e437c/test/fixtures/merged.xlsx


--------------------------------------------------------------------------------
/test/fixtures/not_a_zip.zip:
--------------------------------------------------------------------------------
1 | PKBOGUS
2 | 


--------------------------------------------------------------------------------
/test/fixtures/omitted_row.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xavier/xlsx_reader/411a48e8234286d89e5a64fef18918e0b10e437c/test/fixtures/omitted_row.xlsx


--------------------------------------------------------------------------------
/test/fixtures/package/[Content_Types].xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
 3 |   <Default ContentType="application/xml" Extension="xml"/>
 4 |   <Default ContentType="application/vnd.openxmlformats-package.relationships+xml" Extension="rels"/>
 5 |   <Default ContentType="image/jpg" Extension="jpeg"/>
 6 |   <Default ContentType="image/png" Extension="png"/>
 7 |   <Default ContentType="image/bmp" Extension="bmp"/>
 8 |   <Default ContentType="image/gif" Extension="gif"/>
 9 |   <Default ContentType="image/tif" Extension="tif"/>
10 |   <Default ContentType="application/pdf" Extension="pdf"/>
11 |   <Default ContentType="application/movie" Extension="mov"/>
12 |   <Default ContentType="application/vnd.openxmlformats-officedocument.vmlDrawing" Extension="vml"/>
13 |   <Default ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" Extension="xlsx"/>
14 |   <Override ContentType="application/vnd.openxmlformats-package.core-properties+xml" PartName="/docProps/core.xml"/>
15 |   <Override ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml" PartName="/docProps/app.xml"/>
16 |   <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml" PartName="/xl/workbook.xml"/>
17 |   <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml" PartName="/xl/sharedStrings.xml"/>
18 |   <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml" PartName="/xl/styles.xml"/>
19 |   <Override ContentType="application/vnd.openxmlformats-officedocument.theme+xml" PartName="/xl/theme/theme1.xml"/>
20 |   <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml" PartName="/xl/worksheets/sheet1.xml"/>
21 |   <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml" PartName="/xl/worksheets/sheet2.xml"/>
22 |   <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml" PartName="/xl/worksheets/sheet3.xml"/>
23 | </Types>
24 | 


--------------------------------------------------------------------------------
/test/fixtures/package/_rels/.rels:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
3 |   <Relationship Id="rId1" Target="docProps/core.xml" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties"/>
4 |   <Relationship Id="rId2" Target="docProps/app.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties"/>
5 |   <Relationship Id="rId3" Target="xl/workbook.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"/>
6 | </Relationships>
7 | 


--------------------------------------------------------------------------------
/test/fixtures/package/docProps/app.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"/>
3 | 


--------------------------------------------------------------------------------
/test/fixtures/package/docProps/core.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>
3 | 


--------------------------------------------------------------------------------
/test/fixtures/package/xl/_rels/workbook.xml.rels:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
 3 |   <Relationship Id="rId1" Target="sharedStrings.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings"/>
 4 |   <Relationship Id="rId2" Target="styles.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles"/>
 5 |   <Relationship Id="rId3" Target="theme/theme1.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme"/>
 6 |   <Relationship Id="rId4" Target="worksheets/sheet1.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"/>
 7 |   <Relationship Id="rId5" Target="worksheets/sheet2.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"/>
 8 |   <Relationship Id="rId6" Target="worksheets/sheet3.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"/>
 9 | </Relationships>
10 | 


--------------------------------------------------------------------------------
/test/fixtures/package/xl/sharedStrings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <sst uniqueCount="22" xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
 3 |   <si>
 4 |     <t>A</t>
 5 |   </si>
 6 |   <si>
 7 |     <t>B</t>
 8 |   </si>
 9 |   <si>
10 |     <t>C</t>
11 |   </si>
12 |   <si>
13 |     <t>D</t>
14 |   </si>
15 |   <si>
16 |     <t>E</t>
17 |   </si>
18 |   <si>
19 |     <t>F</t>
20 |   </si>
21 |   <si>
22 |     <t>G</t>
23 |   </si>
24 |   <si>
25 |     <t xml:space="preserve">some </t>
26 |   </si>
27 |   <si>
28 |     <t>test</t>
29 |   </si>
30 |   <si>
31 |     <t>date</t>
32 |   </si>
33 |   <si>
34 |     <t>datetime</t>
35 |   </si>
36 |   <si>
37 |     <t>time</t>
38 |   </si>
39 |   <si>
40 |     <t>percentage</t>
41 |   </si>
42 |   <si>
43 |     <t>money chf</t>
44 |   </si>
45 |   <si>
46 |     <t>money usd</t>
47 |   </si>
48 |   <si>
49 |     <t>9999,99 USD</t>
50 |   </si>
51 |   <si>
52 |     <t>ticked</t>
53 |   </si>
54 |   <si>
55 |     <t>not ticked</t>
56 |   </si>
57 |   <si>
58 |     <t>hyperlink</t>
59 |   </si>
60 |   <si>
61 |     <r>
62 |       <rPr>
63 |         <u val="single"/>
64 |         <sz val="10"/>
65 |         <color indexed="14"/>
66 |         <rFont val="Helvetica Neue"/>
67 |       </rPr>
68 |       <t>https://elixir-lang.org/</t>
69 |     </r>
70 |   </si>
71 |   <si>
72 |     <t xml:space="preserve"> </t>
73 |   </si>
74 |   <si>
75 |     <t xml:space="preserve">-</t>
76 |   </si>
77 | </sst>
78 | 


--------------------------------------------------------------------------------
/test/fixtures/package/xl/styles.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
  3 |   <numFmts count="6">
  4 |     <numFmt formatCode="General" numFmtId="0"/>
  5 |     <numFmt formatCode="dd/mm/yyyy" numFmtId="59"/>
  6 |     <numFmt formatCode="dd/mm/yyyy hh:mm" numFmtId="60"/>
  7 |     <numFmt formatCode="hh:mm" numFmtId="61"/>
  8 |     <numFmt formatCode="0.0%" numFmtId="62"/>
  9 |     <numFmt formatCode="[$CHF]0.00" numFmtId="63"/>
 10 |   </numFmts>
 11 |   <fonts count="5">
 12 |     <font>
 13 |       <sz val="10"/>
 14 |       <color indexed="8"/>
 15 |       <name val="Helvetica Neue"/>
 16 |     </font>
 17 |     <font>
 18 |       <sz val="12"/>
 19 |       <color indexed="8"/>
 20 |       <name val="Helvetica Neue"/>
 21 |     </font>
 22 |     <font>
 23 |       <sz val="13"/>
 24 |       <color indexed="8"/>
 25 |       <name val="Helvetica Neue"/>
 26 |     </font>
 27 |     <font>
 28 |       <b val="1"/>
 29 |       <sz val="10"/>
 30 |       <color indexed="8"/>
 31 |       <name val="Helvetica Neue"/>
 32 |     </font>
 33 |     <font>
 34 |       <u val="single"/>
 35 |       <sz val="10"/>
 36 |       <color indexed="14"/>
 37 |       <name val="Helvetica Neue"/>
 38 |     </font>
 39 |   </fonts>
 40 |   <fills count="5">
 41 |     <fill>
 42 |       <patternFill patternType="none"/>
 43 |     </fill>
 44 |     <fill>
 45 |       <patternFill patternType="gray125"/>
 46 |     </fill>
 47 |     <fill>
 48 |       <patternFill patternType="solid">
 49 |         <fgColor indexed="9"/>
 50 |         <bgColor auto="1"/>
 51 |       </patternFill>
 52 |     </fill>
 53 |     <fill>
 54 |       <patternFill patternType="solid">
 55 |         <fgColor indexed="12"/>
 56 |         <bgColor auto="1"/>
 57 |       </patternFill>
 58 |     </fill>
 59 |     <fill>
 60 |       <patternFill patternType="solid">
 61 |         <fgColor indexed="13"/>
 62 |         <bgColor auto="1"/>
 63 |       </patternFill>
 64 |     </fill>
 65 |   </fills>
 66 |   <borders count="8">
 67 |     <border>
 68 |       <left/>
 69 |       <right/>
 70 |       <top/>
 71 |       <bottom/>
 72 |       <diagonal/>
 73 |     </border>
 74 |     <border>
 75 |       <left style="thin">
 76 |         <color indexed="10"/>
 77 |       </left>
 78 |       <right style="thin">
 79 |         <color indexed="10"/>
 80 |       </right>
 81 |       <top style="thin">
 82 |         <color indexed="10"/>
 83 |       </top>
 84 |       <bottom style="thin">
 85 |         <color indexed="11"/>
 86 |       </bottom>
 87 |       <diagonal/>
 88 |     </border>
 89 |     <border>
 90 |       <left style="thin">
 91 |         <color indexed="10"/>
 92 |       </left>
 93 |       <right style="thin">
 94 |         <color indexed="11"/>
 95 |       </right>
 96 |       <top style="thin">
 97 |         <color indexed="11"/>
 98 |       </top>
 99 |       <bottom style="thin">
100 |         <color indexed="10"/>
101 |       </bottom>
102 |       <diagonal/>
103 |     </border>
104 |     <border>
105 |       <left style="thin">
106 |         <color indexed="11"/>
107 |       </left>
108 |       <right style="thin">
109 |         <color indexed="10"/>
110 |       </right>
111 |       <top style="thin">
112 |         <color indexed="11"/>
113 |       </top>
114 |       <bottom style="thin">
115 |         <color indexed="10"/>
116 |       </bottom>
117 |       <diagonal/>
118 |     </border>
119 |     <border>
120 |       <left style="thin">
121 |         <color indexed="10"/>
122 |       </left>
123 |       <right style="thin">
124 |         <color indexed="10"/>
125 |       </right>
126 |       <top style="thin">
127 |         <color indexed="11"/>
128 |       </top>
129 |       <bottom style="thin">
130 |         <color indexed="10"/>
131 |       </bottom>
132 |       <diagonal/>
133 |     </border>
134 |     <border>
135 |       <left style="thin">
136 |         <color indexed="10"/>
137 |       </left>
138 |       <right style="thin">
139 |         <color indexed="11"/>
140 |       </right>
141 |       <top style="thin">
142 |         <color indexed="10"/>
143 |       </top>
144 |       <bottom style="thin">
145 |         <color indexed="10"/>
146 |       </bottom>
147 |       <diagonal/>
148 |     </border>
149 |     <border>
150 |       <left style="thin">
151 |         <color indexed="11"/>
152 |       </left>
153 |       <right style="thin">
154 |         <color indexed="10"/>
155 |       </right>
156 |       <top style="thin">
157 |         <color indexed="10"/>
158 |       </top>
159 |       <bottom style="thin">
160 |         <color indexed="10"/>
161 |       </bottom>
162 |       <diagonal/>
163 |     </border>
164 |     <border>
165 |       <left style="thin">
166 |         <color indexed="10"/>
167 |       </left>
168 |       <right style="thin">
169 |         <color indexed="10"/>
170 |       </right>
171 |       <top style="thin">
172 |         <color indexed="10"/>
173 |       </top>
174 |       <bottom style="thin">
175 |         <color indexed="10"/>
176 |       </bottom>
177 |       <diagonal/>
178 |     </border>
179 |   </borders>
180 |   <cellStyleXfs count="1">
181 |     <xf applyAlignment="1" applyBorder="0" applyFill="0" applyFont="1" applyNumberFormat="0" applyProtection="0" fontId="0" numFmtId="0">
182 |       <alignment vertical="top" wrapText="1"/>
183 |     </xf>
184 |   </cellStyleXfs>
185 |   <cellXfs count="25">
186 |     <xf applyAlignment="1" applyBorder="0" applyFill="0" applyFont="1" applyNumberFormat="0" applyProtection="0" fontId="0" numFmtId="0">
187 |       <alignment vertical="top" wrapText="1"/>
188 |     </xf>
189 |     <xf applyAlignment="1" applyBorder="0" applyFill="0" applyFont="1" applyNumberFormat="1" applyProtection="0" fontId="0" numFmtId="0">
190 |       <alignment vertical="top" wrapText="1"/>
191 |     </xf>
192 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="1" fillId="2" fontId="3" numFmtId="49">
193 |       <alignment vertical="top" wrapText="1"/>
194 |     </xf>
195 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="2" fillId="3" fontId="3" numFmtId="0">
196 |       <alignment vertical="top" wrapText="1"/>
197 |     </xf>
198 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="3" fillId="4" fontId="0" numFmtId="0">
199 |       <alignment vertical="top" wrapText="1"/>
200 |     </xf>
201 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="4" fillId="4" fontId="0" numFmtId="0">
202 |       <alignment vertical="top" wrapText="1"/>
203 |     </xf>
204 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="5" fillId="3" fontId="3" numFmtId="0">
205 |       <alignment vertical="top" wrapText="1"/>
206 |     </xf>
207 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="6" fillId="4" fontId="0" numFmtId="0">
208 |       <alignment vertical="top" wrapText="1"/>
209 |     </xf>
210 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="7" fillId="4" fontId="0" numFmtId="0">
211 |       <alignment vertical="top" wrapText="1"/>
212 |     </xf>
213 |     <xf applyAlignment="1" applyBorder="0" applyFill="0" applyFont="1" applyNumberFormat="1" applyProtection="0" fontId="0" numFmtId="0">
214 |       <alignment vertical="top" wrapText="1"/>
215 |     </xf>
216 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="0" applyProtection="0" borderId="1" fillId="2" fontId="3" numFmtId="0">
217 |       <alignment vertical="top" wrapText="1"/>
218 |     </xf>
219 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="2" fillId="3" fontId="3" numFmtId="49">
220 |       <alignment vertical="top" wrapText="1"/>
221 |     </xf>
222 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="3" fillId="4" fontId="0" numFmtId="49">
223 |       <alignment vertical="top" wrapText="1"/>
224 |     </xf>
225 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="0" applyProtection="0" borderId="4" fillId="4" fontId="0" numFmtId="0">
226 |       <alignment vertical="top" wrapText="1"/>
227 |     </xf>
228 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="0" applyProtection="0" borderId="5" fillId="3" fontId="3" numFmtId="0">
229 |       <alignment vertical="top" wrapText="1"/>
230 |     </xf>
231 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="0" applyProtection="0" borderId="6" fillId="4" fontId="0" numFmtId="0">
232 |       <alignment vertical="top" wrapText="1"/>
233 |     </xf>
234 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="0" applyProtection="0" borderId="7" fillId="4" fontId="0" numFmtId="0">
235 |       <alignment vertical="top" wrapText="1"/>
236 |     </xf>
237 |     <xf applyAlignment="1" applyBorder="0" applyFill="0" applyFont="1" applyNumberFormat="1" applyProtection="0" fontId="0" numFmtId="0">
238 |       <alignment vertical="top" wrapText="1"/>
239 |     </xf>
240 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="3" fillId="4" fontId="0" numFmtId="59">
241 |       <alignment vertical="top" wrapText="1"/>
242 |     </xf>
243 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="5" fillId="3" fontId="3" numFmtId="49">
244 |       <alignment vertical="top" wrapText="1"/>
245 |     </xf>
246 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="6" fillId="4" fontId="0" numFmtId="60">
247 |       <alignment vertical="top" wrapText="1"/>
248 |     </xf>
249 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="6" fillId="4" fontId="0" numFmtId="61">
250 |       <alignment vertical="top" wrapText="1"/>
251 |     </xf>
252 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="6" fillId="4" fontId="0" numFmtId="62">
253 |       <alignment vertical="top" wrapText="1"/>
254 |     </xf>
255 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="6" fillId="4" fontId="0" numFmtId="63">
256 |       <alignment vertical="top" wrapText="1"/>
257 |     </xf>
258 |     <xf applyAlignment="1" applyBorder="1" applyFill="1" applyFont="1" applyNumberFormat="1" applyProtection="0" borderId="6" fillId="4" fontId="0" numFmtId="49">
259 |       <alignment vertical="top" wrapText="1"/>
260 |     </xf>
261 |   </cellXfs>
262 |   <cellStyles count="1">
263 |     <cellStyle builtinId="0" name="Normal" xfId="0"/>
264 |   </cellStyles>
265 |   <dxfs count="0"/>
266 |   <tableStyles count="0"/>
267 |   <colors>
268 |     <indexedColors>
269 |       <rgbColor rgb="ff000000"/>
270 |       <rgbColor rgb="ffffffff"/>
271 |       <rgbColor rgb="ffff0000"/>
272 |       <rgbColor rgb="ff00ff00"/>
273 |       <rgbColor rgb="ff0000ff"/>
274 |       <rgbColor rgb="ffffff00"/>
275 |       <rgbColor rgb="ffff00ff"/>
276 |       <rgbColor rgb="ff00ffff"/>
277 |       <rgbColor rgb="ff000000"/>
278 |       <rgbColor rgb="ffbdc0bf"/>
279 |       <rgbColor rgb="ffa5a5a5"/>
280 |       <rgbColor rgb="ff3f3f3f"/>
281 |       <rgbColor rgb="ffdbdbdb"/>
282 |       <rgbColor rgb="ffffffff"/>
283 |       <rgbColor rgb="ff0000ff"/>
284 |     </indexedColors>
285 |   </colors>
286 | </styleSheet>
287 | 


--------------------------------------------------------------------------------
/test/fixtures/package/xl/theme/theme1.xml:
--------------------------------------------------------------------------------
   1 | <?xml version="1.0" encoding="UTF-8"?>
   2 | <a:theme name="Blank" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
   3 |   <a:themeElements>
   4 |     <a:clrScheme name="Blank">
   5 |       <a:dk1>
   6 |         <a:srgbClr val="000000"/>
   7 |       </a:dk1>
   8 |       <a:lt1>
   9 |         <a:srgbClr val="FFFFFF"/>
  10 |       </a:lt1>
  11 |       <a:dk2>
  12 |         <a:srgbClr val="A7A7A7"/>
  13 |       </a:dk2>
  14 |       <a:lt2>
  15 |         <a:srgbClr val="535353"/>
  16 |       </a:lt2>
  17 |       <a:accent1>
  18 |         <a:srgbClr val="00A2FF"/>
  19 |       </a:accent1>
  20 |       <a:accent2>
  21 |         <a:srgbClr val="16E7CF"/>
  22 |       </a:accent2>
  23 |       <a:accent3>
  24 |         <a:srgbClr val="61D836"/>
  25 |       </a:accent3>
  26 |       <a:accent4>
  27 |         <a:srgbClr val="FAE232"/>
  28 |       </a:accent4>
  29 |       <a:accent5>
  30 |         <a:srgbClr val="FF644E"/>
  31 |       </a:accent5>
  32 |       <a:accent6>
  33 |         <a:srgbClr val="EF5FA7"/>
  34 |       </a:accent6>
  35 |       <a:hlink>
  36 |         <a:srgbClr val="0000FF"/>
  37 |       </a:hlink>
  38 |       <a:folHlink>
  39 |         <a:srgbClr val="FF00FF"/>
  40 |       </a:folHlink>
  41 |     </a:clrScheme>
  42 |     <a:fontScheme name="Blank">
  43 |       <a:majorFont>
  44 |         <a:latin typeface="Helvetica Neue"/>
  45 |         <a:ea typeface="Helvetica Neue"/>
  46 |         <a:cs typeface="Helvetica Neue"/>
  47 |       </a:majorFont>
  48 |       <a:minorFont>
  49 |         <a:latin typeface="Helvetica Neue"/>
  50 |         <a:ea typeface="Helvetica Neue"/>
  51 |         <a:cs typeface="Helvetica Neue"/>
  52 |       </a:minorFont>
  53 |     </a:fontScheme>
  54 |     <a:fmtScheme name="Blank">
  55 |       <a:fillStyleLst>
  56 |         <a:solidFill>
  57 |           <a:schemeClr val="phClr"/>
  58 |         </a:solidFill>
  59 |         <a:gradFill rotWithShape="1">
  60 |           <a:gsLst>
  61 |             <a:gs pos="0">
  62 |               <a:schemeClr val="phClr">
  63 |                 <a:tint val="50000"/>
  64 |                 <a:satMod val="300000"/>
  65 |               </a:schemeClr>
  66 |             </a:gs>
  67 |             <a:gs pos="35000">
  68 |               <a:schemeClr val="phClr">
  69 |                 <a:tint val="37000"/>
  70 |                 <a:satMod val="300000"/>
  71 |               </a:schemeClr>
  72 |             </a:gs>
  73 |             <a:gs pos="100000">
  74 |               <a:schemeClr val="phClr">
  75 |                 <a:tint val="15000"/>
  76 |                 <a:satMod val="350000"/>
  77 |               </a:schemeClr>
  78 |             </a:gs>
  79 |           </a:gsLst>
  80 |           <a:lin ang="16200000" scaled="1"/>
  81 |         </a:gradFill>
  82 |         <a:gradFill rotWithShape="1">
  83 |           <a:gsLst>
  84 |             <a:gs pos="0">
  85 |               <a:schemeClr val="phClr">
  86 |                 <a:tint val="100000"/>
  87 |                 <a:shade val="100000"/>
  88 |                 <a:satMod val="129999"/>
  89 |               </a:schemeClr>
  90 |             </a:gs>
  91 |             <a:gs pos="100000">
  92 |               <a:schemeClr val="phClr">
  93 |                 <a:tint val="50000"/>
  94 |                 <a:shade val="100000"/>
  95 |                 <a:satMod val="350000"/>
  96 |               </a:schemeClr>
  97 |             </a:gs>
  98 |           </a:gsLst>
  99 |           <a:lin ang="16200000" scaled="0"/>
 100 |         </a:gradFill>
 101 |       </a:fillStyleLst>
 102 |       <a:lnStyleLst>
 103 |         <a:ln algn="ctr" cap="flat" cmpd="sng" w="9525">
 104 |           <a:solidFill>
 105 |             <a:schemeClr val="phClr">
 106 |               <a:shade val="95000"/>
 107 |               <a:satMod val="104999"/>
 108 |             </a:schemeClr>
 109 |           </a:solidFill>
 110 |           <a:prstDash val="solid"/>
 111 |         </a:ln>
 112 |         <a:ln algn="ctr" cap="flat" cmpd="sng" w="25400">
 113 |           <a:solidFill>
 114 |             <a:schemeClr val="phClr"/>
 115 |           </a:solidFill>
 116 |           <a:prstDash val="solid"/>
 117 |         </a:ln>
 118 |         <a:ln algn="ctr" cap="flat" cmpd="sng" w="38100">
 119 |           <a:solidFill>
 120 |             <a:schemeClr val="phClr"/>
 121 |           </a:solidFill>
 122 |           <a:prstDash val="solid"/>
 123 |         </a:ln>
 124 |       </a:lnStyleLst>
 125 |       <a:effectStyleLst>
 126 |         <a:effectStyle>
 127 |           <a:effectLst/>
 128 |         </a:effectStyle>
 129 |         <a:effectStyle>
 130 |           <a:effectLst/>
 131 |         </a:effectStyle>
 132 |         <a:effectStyle>
 133 |           <a:effectLst/>
 134 |         </a:effectStyle>
 135 |       </a:effectStyleLst>
 136 |       <a:bgFillStyleLst>
 137 |         <a:solidFill>
 138 |           <a:schemeClr val="phClr"/>
 139 |         </a:solidFill>
 140 |         <a:gradFill rotWithShape="1">
 141 |           <a:gsLst>
 142 |             <a:gs pos="0">
 143 |               <a:schemeClr val="phClr">
 144 |                 <a:tint val="40000"/>
 145 |                 <a:satMod val="350000"/>
 146 |               </a:schemeClr>
 147 |             </a:gs>
 148 |             <a:gs pos="40000">
 149 |               <a:schemeClr val="phClr">
 150 |                 <a:tint val="45000"/>
 151 |                 <a:shade val="99000"/>
 152 |                 <a:satMod val="350000"/>
 153 |               </a:schemeClr>
 154 |             </a:gs>
 155 |             <a:gs pos="100000">
 156 |               <a:schemeClr val="phClr">
 157 |                 <a:shade val="20000"/>
 158 |                 <a:satMod val="255000"/>
 159 |               </a:schemeClr>
 160 |             </a:gs>
 161 |           </a:gsLst>
 162 |           <a:path path="circle">
 163 |             <a:fillToRect b="180000" l="50000" r="50000" t="-80000"/>
 164 |           </a:path>
 165 |         </a:gradFill>
 166 |         <a:gradFill rotWithShape="1">
 167 |           <a:gsLst>
 168 |             <a:gs pos="0">
 169 |               <a:schemeClr val="phClr">
 170 |                 <a:tint val="80000"/>
 171 |                 <a:satMod val="300000"/>
 172 |               </a:schemeClr>
 173 |             </a:gs>
 174 |             <a:gs pos="100000">
 175 |               <a:schemeClr val="phClr">
 176 |                 <a:shade val="30000"/>
 177 |                 <a:satMod val="200000"/>
 178 |               </a:schemeClr>
 179 |             </a:gs>
 180 |           </a:gsLst>
 181 |           <a:path path="circle">
 182 |             <a:fillToRect b="50000" l="50000" r="50000" t="50000"/>
 183 |           </a:path>
 184 |         </a:gradFill>
 185 |       </a:bgFillStyleLst>
 186 |     </a:fmtScheme>
 187 |   </a:themeElements>
 188 |   <a:objectDefaults>
 189 |     <a:spDef>
 190 |       <a:spPr>
 191 |         <a:solidFill>
 192 |           <a:srgbClr val="FFFFFF"/>
 193 |         </a:solidFill>
 194 |         <a:ln cap="flat" w="25400">
 195 |           <a:solidFill>
 196 |             <a:schemeClr val="accent1"/>
 197 |           </a:solidFill>
 198 |           <a:prstDash val="solid"/>
 199 |           <a:round/>
 200 |         </a:ln>
 201 |         <a:effectLst/>
 202 |         <a:sp3d/>
 203 |       </a:spPr>
 204 |       <a:bodyPr anchor="ctr" bIns="50800" horzOverflow="overflow" lIns="50800" numCol="1" rIns="50800" rot="0" rtlCol="0" spcCol="38100" spcFirstLastPara="1" tIns="50800" upright="0" vert="horz" vertOverflow="overflow" wrap="square">
 205 |         <a:spAutoFit/>
 206 |       </a:bodyPr>
 207 |       <a:lstStyle>
 208 |         <a:defPPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="0" marL="0" marR="0" rtl="0">
 209 |           <a:lnSpc>
 210 |             <a:spcPct val="100000"/>
 211 |           </a:lnSpc>
 212 |           <a:spcBef>
 213 |             <a:spcPts val="0"/>
 214 |           </a:spcBef>
 215 |           <a:spcAft>
 216 |             <a:spcPts val="0"/>
 217 |           </a:spcAft>
 218 |           <a:buClrTx/>
 219 |           <a:buSzTx/>
 220 |           <a:buFontTx/>
 221 |           <a:buNone/>
 222 |           <a:tabLst/>
 223 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1100" u="none">
 224 |             <a:ln>
 225 |               <a:noFill/>
 226 |             </a:ln>
 227 |             <a:solidFill>
 228 |               <a:srgbClr val="000000"/>
 229 |             </a:solidFill>
 230 |             <a:effectLst/>
 231 |             <a:uFillTx/>
 232 |             <a:latin typeface="+mn-lt"/>
 233 |             <a:ea typeface="+mn-ea"/>
 234 |             <a:cs typeface="+mn-cs"/>
 235 |             <a:sym typeface="Helvetica Neue"/>
 236 |           </a:defRPr>
 237 |         </a:defPPr>
 238 |         <a:lvl1pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 239 |           <a:lnSpc>
 240 |             <a:spcPct val="100000"/>
 241 |           </a:lnSpc>
 242 |           <a:spcBef>
 243 |             <a:spcPts val="0"/>
 244 |           </a:spcBef>
 245 |           <a:spcAft>
 246 |             <a:spcPts val="0"/>
 247 |           </a:spcAft>
 248 |           <a:buClrTx/>
 249 |           <a:buSzTx/>
 250 |           <a:buFontTx/>
 251 |           <a:buNone/>
 252 |           <a:tabLst/>
 253 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 254 |             <a:ln>
 255 |               <a:noFill/>
 256 |             </a:ln>
 257 |             <a:solidFill>
 258 |               <a:srgbClr val="000000"/>
 259 |             </a:solidFill>
 260 |             <a:effectLst/>
 261 |             <a:uFillTx/>
 262 |           </a:defRPr>
 263 |         </a:lvl1pPr>
 264 |         <a:lvl2pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 265 |           <a:lnSpc>
 266 |             <a:spcPct val="100000"/>
 267 |           </a:lnSpc>
 268 |           <a:spcBef>
 269 |             <a:spcPts val="0"/>
 270 |           </a:spcBef>
 271 |           <a:spcAft>
 272 |             <a:spcPts val="0"/>
 273 |           </a:spcAft>
 274 |           <a:buClrTx/>
 275 |           <a:buSzTx/>
 276 |           <a:buFontTx/>
 277 |           <a:buNone/>
 278 |           <a:tabLst/>
 279 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 280 |             <a:ln>
 281 |               <a:noFill/>
 282 |             </a:ln>
 283 |             <a:solidFill>
 284 |               <a:srgbClr val="000000"/>
 285 |             </a:solidFill>
 286 |             <a:effectLst/>
 287 |             <a:uFillTx/>
 288 |           </a:defRPr>
 289 |         </a:lvl2pPr>
 290 |         <a:lvl3pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 291 |           <a:lnSpc>
 292 |             <a:spcPct val="100000"/>
 293 |           </a:lnSpc>
 294 |           <a:spcBef>
 295 |             <a:spcPts val="0"/>
 296 |           </a:spcBef>
 297 |           <a:spcAft>
 298 |             <a:spcPts val="0"/>
 299 |           </a:spcAft>
 300 |           <a:buClrTx/>
 301 |           <a:buSzTx/>
 302 |           <a:buFontTx/>
 303 |           <a:buNone/>
 304 |           <a:tabLst/>
 305 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 306 |             <a:ln>
 307 |               <a:noFill/>
 308 |             </a:ln>
 309 |             <a:solidFill>
 310 |               <a:srgbClr val="000000"/>
 311 |             </a:solidFill>
 312 |             <a:effectLst/>
 313 |             <a:uFillTx/>
 314 |           </a:defRPr>
 315 |         </a:lvl3pPr>
 316 |         <a:lvl4pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 317 |           <a:lnSpc>
 318 |             <a:spcPct val="100000"/>
 319 |           </a:lnSpc>
 320 |           <a:spcBef>
 321 |             <a:spcPts val="0"/>
 322 |           </a:spcBef>
 323 |           <a:spcAft>
 324 |             <a:spcPts val="0"/>
 325 |           </a:spcAft>
 326 |           <a:buClrTx/>
 327 |           <a:buSzTx/>
 328 |           <a:buFontTx/>
 329 |           <a:buNone/>
 330 |           <a:tabLst/>
 331 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 332 |             <a:ln>
 333 |               <a:noFill/>
 334 |             </a:ln>
 335 |             <a:solidFill>
 336 |               <a:srgbClr val="000000"/>
 337 |             </a:solidFill>
 338 |             <a:effectLst/>
 339 |             <a:uFillTx/>
 340 |           </a:defRPr>
 341 |         </a:lvl4pPr>
 342 |         <a:lvl5pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 343 |           <a:lnSpc>
 344 |             <a:spcPct val="100000"/>
 345 |           </a:lnSpc>
 346 |           <a:spcBef>
 347 |             <a:spcPts val="0"/>
 348 |           </a:spcBef>
 349 |           <a:spcAft>
 350 |             <a:spcPts val="0"/>
 351 |           </a:spcAft>
 352 |           <a:buClrTx/>
 353 |           <a:buSzTx/>
 354 |           <a:buFontTx/>
 355 |           <a:buNone/>
 356 |           <a:tabLst/>
 357 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 358 |             <a:ln>
 359 |               <a:noFill/>
 360 |             </a:ln>
 361 |             <a:solidFill>
 362 |               <a:srgbClr val="000000"/>
 363 |             </a:solidFill>
 364 |             <a:effectLst/>
 365 |             <a:uFillTx/>
 366 |           </a:defRPr>
 367 |         </a:lvl5pPr>
 368 |         <a:lvl6pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 369 |           <a:lnSpc>
 370 |             <a:spcPct val="100000"/>
 371 |           </a:lnSpc>
 372 |           <a:spcBef>
 373 |             <a:spcPts val="0"/>
 374 |           </a:spcBef>
 375 |           <a:spcAft>
 376 |             <a:spcPts val="0"/>
 377 |           </a:spcAft>
 378 |           <a:buClrTx/>
 379 |           <a:buSzTx/>
 380 |           <a:buFontTx/>
 381 |           <a:buNone/>
 382 |           <a:tabLst/>
 383 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 384 |             <a:ln>
 385 |               <a:noFill/>
 386 |             </a:ln>
 387 |             <a:solidFill>
 388 |               <a:srgbClr val="000000"/>
 389 |             </a:solidFill>
 390 |             <a:effectLst/>
 391 |             <a:uFillTx/>
 392 |           </a:defRPr>
 393 |         </a:lvl6pPr>
 394 |         <a:lvl7pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 395 |           <a:lnSpc>
 396 |             <a:spcPct val="100000"/>
 397 |           </a:lnSpc>
 398 |           <a:spcBef>
 399 |             <a:spcPts val="0"/>
 400 |           </a:spcBef>
 401 |           <a:spcAft>
 402 |             <a:spcPts val="0"/>
 403 |           </a:spcAft>
 404 |           <a:buClrTx/>
 405 |           <a:buSzTx/>
 406 |           <a:buFontTx/>
 407 |           <a:buNone/>
 408 |           <a:tabLst/>
 409 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 410 |             <a:ln>
 411 |               <a:noFill/>
 412 |             </a:ln>
 413 |             <a:solidFill>
 414 |               <a:srgbClr val="000000"/>
 415 |             </a:solidFill>
 416 |             <a:effectLst/>
 417 |             <a:uFillTx/>
 418 |           </a:defRPr>
 419 |         </a:lvl7pPr>
 420 |         <a:lvl8pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 421 |           <a:lnSpc>
 422 |             <a:spcPct val="100000"/>
 423 |           </a:lnSpc>
 424 |           <a:spcBef>
 425 |             <a:spcPts val="0"/>
 426 |           </a:spcBef>
 427 |           <a:spcAft>
 428 |             <a:spcPts val="0"/>
 429 |           </a:spcAft>
 430 |           <a:buClrTx/>
 431 |           <a:buSzTx/>
 432 |           <a:buFontTx/>
 433 |           <a:buNone/>
 434 |           <a:tabLst/>
 435 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 436 |             <a:ln>
 437 |               <a:noFill/>
 438 |             </a:ln>
 439 |             <a:solidFill>
 440 |               <a:srgbClr val="000000"/>
 441 |             </a:solidFill>
 442 |             <a:effectLst/>
 443 |             <a:uFillTx/>
 444 |           </a:defRPr>
 445 |         </a:lvl8pPr>
 446 |         <a:lvl9pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 447 |           <a:lnSpc>
 448 |             <a:spcPct val="100000"/>
 449 |           </a:lnSpc>
 450 |           <a:spcBef>
 451 |             <a:spcPts val="0"/>
 452 |           </a:spcBef>
 453 |           <a:spcAft>
 454 |             <a:spcPts val="0"/>
 455 |           </a:spcAft>
 456 |           <a:buClrTx/>
 457 |           <a:buSzTx/>
 458 |           <a:buFontTx/>
 459 |           <a:buNone/>
 460 |           <a:tabLst/>
 461 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 462 |             <a:ln>
 463 |               <a:noFill/>
 464 |             </a:ln>
 465 |             <a:solidFill>
 466 |               <a:srgbClr val="000000"/>
 467 |             </a:solidFill>
 468 |             <a:effectLst/>
 469 |             <a:uFillTx/>
 470 |           </a:defRPr>
 471 |         </a:lvl9pPr>
 472 |       </a:lstStyle>
 473 |       <a:style>
 474 |         <a:lnRef idx="0"/>
 475 |         <a:fillRef idx="0"/>
 476 |         <a:effectRef idx="0"/>
 477 |         <a:fontRef idx="none"/>
 478 |       </a:style>
 479 |     </a:spDef>
 480 |     <a:lnDef>
 481 |       <a:spPr>
 482 |         <a:noFill/>
 483 |         <a:ln cap="flat" w="25400">
 484 |           <a:solidFill>
 485 |             <a:schemeClr val="accent1"/>
 486 |           </a:solidFill>
 487 |           <a:prstDash val="solid"/>
 488 |           <a:round/>
 489 |         </a:ln>
 490 |         <a:effectLst/>
 491 |         <a:sp3d/>
 492 |       </a:spPr>
 493 |       <a:bodyPr anchor="t" bIns="45719" horzOverflow="overflow" lIns="91439" numCol="1" rIns="91439" rot="0" rtlCol="0" spcCol="38100" spcFirstLastPara="1" tIns="45719" upright="0" vert="horz" vertOverflow="overflow" wrap="square">
 494 |         <a:noAutofit/>
 495 |       </a:bodyPr>
 496 |       <a:lstStyle>
 497 |         <a:defPPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 498 |           <a:lnSpc>
 499 |             <a:spcPct val="100000"/>
 500 |           </a:lnSpc>
 501 |           <a:spcBef>
 502 |             <a:spcPts val="0"/>
 503 |           </a:spcBef>
 504 |           <a:spcAft>
 505 |             <a:spcPts val="0"/>
 506 |           </a:spcAft>
 507 |           <a:buClrTx/>
 508 |           <a:buSzTx/>
 509 |           <a:buFontTx/>
 510 |           <a:buNone/>
 511 |           <a:tabLst/>
 512 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 513 |             <a:ln>
 514 |               <a:noFill/>
 515 |             </a:ln>
 516 |             <a:solidFill>
 517 |               <a:srgbClr val="000000"/>
 518 |             </a:solidFill>
 519 |             <a:effectLst/>
 520 |             <a:uFillTx/>
 521 |           </a:defRPr>
 522 |         </a:defPPr>
 523 |         <a:lvl1pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 524 |           <a:lnSpc>
 525 |             <a:spcPct val="100000"/>
 526 |           </a:lnSpc>
 527 |           <a:spcBef>
 528 |             <a:spcPts val="0"/>
 529 |           </a:spcBef>
 530 |           <a:spcAft>
 531 |             <a:spcPts val="0"/>
 532 |           </a:spcAft>
 533 |           <a:buClrTx/>
 534 |           <a:buSzTx/>
 535 |           <a:buFontTx/>
 536 |           <a:buNone/>
 537 |           <a:tabLst/>
 538 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 539 |             <a:ln>
 540 |               <a:noFill/>
 541 |             </a:ln>
 542 |             <a:solidFill>
 543 |               <a:srgbClr val="000000"/>
 544 |             </a:solidFill>
 545 |             <a:effectLst/>
 546 |             <a:uFillTx/>
 547 |           </a:defRPr>
 548 |         </a:lvl1pPr>
 549 |         <a:lvl2pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 550 |           <a:lnSpc>
 551 |             <a:spcPct val="100000"/>
 552 |           </a:lnSpc>
 553 |           <a:spcBef>
 554 |             <a:spcPts val="0"/>
 555 |           </a:spcBef>
 556 |           <a:spcAft>
 557 |             <a:spcPts val="0"/>
 558 |           </a:spcAft>
 559 |           <a:buClrTx/>
 560 |           <a:buSzTx/>
 561 |           <a:buFontTx/>
 562 |           <a:buNone/>
 563 |           <a:tabLst/>
 564 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 565 |             <a:ln>
 566 |               <a:noFill/>
 567 |             </a:ln>
 568 |             <a:solidFill>
 569 |               <a:srgbClr val="000000"/>
 570 |             </a:solidFill>
 571 |             <a:effectLst/>
 572 |             <a:uFillTx/>
 573 |           </a:defRPr>
 574 |         </a:lvl2pPr>
 575 |         <a:lvl3pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 576 |           <a:lnSpc>
 577 |             <a:spcPct val="100000"/>
 578 |           </a:lnSpc>
 579 |           <a:spcBef>
 580 |             <a:spcPts val="0"/>
 581 |           </a:spcBef>
 582 |           <a:spcAft>
 583 |             <a:spcPts val="0"/>
 584 |           </a:spcAft>
 585 |           <a:buClrTx/>
 586 |           <a:buSzTx/>
 587 |           <a:buFontTx/>
 588 |           <a:buNone/>
 589 |           <a:tabLst/>
 590 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 591 |             <a:ln>
 592 |               <a:noFill/>
 593 |             </a:ln>
 594 |             <a:solidFill>
 595 |               <a:srgbClr val="000000"/>
 596 |             </a:solidFill>
 597 |             <a:effectLst/>
 598 |             <a:uFillTx/>
 599 |           </a:defRPr>
 600 |         </a:lvl3pPr>
 601 |         <a:lvl4pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 602 |           <a:lnSpc>
 603 |             <a:spcPct val="100000"/>
 604 |           </a:lnSpc>
 605 |           <a:spcBef>
 606 |             <a:spcPts val="0"/>
 607 |           </a:spcBef>
 608 |           <a:spcAft>
 609 |             <a:spcPts val="0"/>
 610 |           </a:spcAft>
 611 |           <a:buClrTx/>
 612 |           <a:buSzTx/>
 613 |           <a:buFontTx/>
 614 |           <a:buNone/>
 615 |           <a:tabLst/>
 616 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 617 |             <a:ln>
 618 |               <a:noFill/>
 619 |             </a:ln>
 620 |             <a:solidFill>
 621 |               <a:srgbClr val="000000"/>
 622 |             </a:solidFill>
 623 |             <a:effectLst/>
 624 |             <a:uFillTx/>
 625 |           </a:defRPr>
 626 |         </a:lvl4pPr>
 627 |         <a:lvl5pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 628 |           <a:lnSpc>
 629 |             <a:spcPct val="100000"/>
 630 |           </a:lnSpc>
 631 |           <a:spcBef>
 632 |             <a:spcPts val="0"/>
 633 |           </a:spcBef>
 634 |           <a:spcAft>
 635 |             <a:spcPts val="0"/>
 636 |           </a:spcAft>
 637 |           <a:buClrTx/>
 638 |           <a:buSzTx/>
 639 |           <a:buFontTx/>
 640 |           <a:buNone/>
 641 |           <a:tabLst/>
 642 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 643 |             <a:ln>
 644 |               <a:noFill/>
 645 |             </a:ln>
 646 |             <a:solidFill>
 647 |               <a:srgbClr val="000000"/>
 648 |             </a:solidFill>
 649 |             <a:effectLst/>
 650 |             <a:uFillTx/>
 651 |           </a:defRPr>
 652 |         </a:lvl5pPr>
 653 |         <a:lvl6pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 654 |           <a:lnSpc>
 655 |             <a:spcPct val="100000"/>
 656 |           </a:lnSpc>
 657 |           <a:spcBef>
 658 |             <a:spcPts val="0"/>
 659 |           </a:spcBef>
 660 |           <a:spcAft>
 661 |             <a:spcPts val="0"/>
 662 |           </a:spcAft>
 663 |           <a:buClrTx/>
 664 |           <a:buSzTx/>
 665 |           <a:buFontTx/>
 666 |           <a:buNone/>
 667 |           <a:tabLst/>
 668 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 669 |             <a:ln>
 670 |               <a:noFill/>
 671 |             </a:ln>
 672 |             <a:solidFill>
 673 |               <a:srgbClr val="000000"/>
 674 |             </a:solidFill>
 675 |             <a:effectLst/>
 676 |             <a:uFillTx/>
 677 |           </a:defRPr>
 678 |         </a:lvl6pPr>
 679 |         <a:lvl7pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 680 |           <a:lnSpc>
 681 |             <a:spcPct val="100000"/>
 682 |           </a:lnSpc>
 683 |           <a:spcBef>
 684 |             <a:spcPts val="0"/>
 685 |           </a:spcBef>
 686 |           <a:spcAft>
 687 |             <a:spcPts val="0"/>
 688 |           </a:spcAft>
 689 |           <a:buClrTx/>
 690 |           <a:buSzTx/>
 691 |           <a:buFontTx/>
 692 |           <a:buNone/>
 693 |           <a:tabLst/>
 694 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 695 |             <a:ln>
 696 |               <a:noFill/>
 697 |             </a:ln>
 698 |             <a:solidFill>
 699 |               <a:srgbClr val="000000"/>
 700 |             </a:solidFill>
 701 |             <a:effectLst/>
 702 |             <a:uFillTx/>
 703 |           </a:defRPr>
 704 |         </a:lvl7pPr>
 705 |         <a:lvl8pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 706 |           <a:lnSpc>
 707 |             <a:spcPct val="100000"/>
 708 |           </a:lnSpc>
 709 |           <a:spcBef>
 710 |             <a:spcPts val="0"/>
 711 |           </a:spcBef>
 712 |           <a:spcAft>
 713 |             <a:spcPts val="0"/>
 714 |           </a:spcAft>
 715 |           <a:buClrTx/>
 716 |           <a:buSzTx/>
 717 |           <a:buFontTx/>
 718 |           <a:buNone/>
 719 |           <a:tabLst/>
 720 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 721 |             <a:ln>
 722 |               <a:noFill/>
 723 |             </a:ln>
 724 |             <a:solidFill>
 725 |               <a:srgbClr val="000000"/>
 726 |             </a:solidFill>
 727 |             <a:effectLst/>
 728 |             <a:uFillTx/>
 729 |           </a:defRPr>
 730 |         </a:lvl8pPr>
 731 |         <a:lvl9pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 732 |           <a:lnSpc>
 733 |             <a:spcPct val="100000"/>
 734 |           </a:lnSpc>
 735 |           <a:spcBef>
 736 |             <a:spcPts val="0"/>
 737 |           </a:spcBef>
 738 |           <a:spcAft>
 739 |             <a:spcPts val="0"/>
 740 |           </a:spcAft>
 741 |           <a:buClrTx/>
 742 |           <a:buSzTx/>
 743 |           <a:buFontTx/>
 744 |           <a:buNone/>
 745 |           <a:tabLst/>
 746 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 747 |             <a:ln>
 748 |               <a:noFill/>
 749 |             </a:ln>
 750 |             <a:solidFill>
 751 |               <a:srgbClr val="000000"/>
 752 |             </a:solidFill>
 753 |             <a:effectLst/>
 754 |             <a:uFillTx/>
 755 |           </a:defRPr>
 756 |         </a:lvl9pPr>
 757 |       </a:lstStyle>
 758 |       <a:style>
 759 |         <a:lnRef idx="0"/>
 760 |         <a:fillRef idx="0"/>
 761 |         <a:effectRef idx="0"/>
 762 |         <a:fontRef idx="none"/>
 763 |       </a:style>
 764 |     </a:lnDef>
 765 |     <a:txDef>
 766 |       <a:spPr>
 767 |         <a:noFill/>
 768 |         <a:ln cap="flat" w="12700">
 769 |           <a:noFill/>
 770 |           <a:miter lim="400000"/>
 771 |         </a:ln>
 772 |         <a:effectLst/>
 773 |         <a:sp3d/>
 774 |       </a:spPr>
 775 |       <a:bodyPr anchor="t" bIns="50800" horzOverflow="overflow" lIns="50800" numCol="1" rIns="50800" rot="0" rtlCol="0" spcCol="38100" spcFirstLastPara="1" tIns="50800" upright="0" vert="horz" vertOverflow="overflow" wrap="square">
 776 |         <a:spAutoFit/>
 777 |       </a:bodyPr>
 778 |       <a:lstStyle>
 779 |         <a:defPPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="0" marL="0" marR="0" rtl="0">
 780 |           <a:lnSpc>
 781 |             <a:spcPct val="100000"/>
 782 |           </a:lnSpc>
 783 |           <a:spcBef>
 784 |             <a:spcPts val="0"/>
 785 |           </a:spcBef>
 786 |           <a:spcAft>
 787 |             <a:spcPts val="0"/>
 788 |           </a:spcAft>
 789 |           <a:buClrTx/>
 790 |           <a:buSzTx/>
 791 |           <a:buFontTx/>
 792 |           <a:buNone/>
 793 |           <a:tabLst/>
 794 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1100" u="none">
 795 |             <a:ln>
 796 |               <a:noFill/>
 797 |             </a:ln>
 798 |             <a:solidFill>
 799 |               <a:srgbClr val="000000"/>
 800 |             </a:solidFill>
 801 |             <a:effectLst/>
 802 |             <a:uFillTx/>
 803 |             <a:latin typeface="+mn-lt"/>
 804 |             <a:ea typeface="+mn-ea"/>
 805 |             <a:cs typeface="+mn-cs"/>
 806 |             <a:sym typeface="Helvetica Neue"/>
 807 |           </a:defRPr>
 808 |         </a:defPPr>
 809 |         <a:lvl1pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 810 |           <a:lnSpc>
 811 |             <a:spcPct val="100000"/>
 812 |           </a:lnSpc>
 813 |           <a:spcBef>
 814 |             <a:spcPts val="0"/>
 815 |           </a:spcBef>
 816 |           <a:spcAft>
 817 |             <a:spcPts val="0"/>
 818 |           </a:spcAft>
 819 |           <a:buClrTx/>
 820 |           <a:buSzTx/>
 821 |           <a:buFontTx/>
 822 |           <a:buNone/>
 823 |           <a:tabLst/>
 824 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 825 |             <a:ln>
 826 |               <a:noFill/>
 827 |             </a:ln>
 828 |             <a:solidFill>
 829 |               <a:srgbClr val="000000"/>
 830 |             </a:solidFill>
 831 |             <a:effectLst/>
 832 |             <a:uFillTx/>
 833 |           </a:defRPr>
 834 |         </a:lvl1pPr>
 835 |         <a:lvl2pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 836 |           <a:lnSpc>
 837 |             <a:spcPct val="100000"/>
 838 |           </a:lnSpc>
 839 |           <a:spcBef>
 840 |             <a:spcPts val="0"/>
 841 |           </a:spcBef>
 842 |           <a:spcAft>
 843 |             <a:spcPts val="0"/>
 844 |           </a:spcAft>
 845 |           <a:buClrTx/>
 846 |           <a:buSzTx/>
 847 |           <a:buFontTx/>
 848 |           <a:buNone/>
 849 |           <a:tabLst/>
 850 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 851 |             <a:ln>
 852 |               <a:noFill/>
 853 |             </a:ln>
 854 |             <a:solidFill>
 855 |               <a:srgbClr val="000000"/>
 856 |             </a:solidFill>
 857 |             <a:effectLst/>
 858 |             <a:uFillTx/>
 859 |           </a:defRPr>
 860 |         </a:lvl2pPr>
 861 |         <a:lvl3pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 862 |           <a:lnSpc>
 863 |             <a:spcPct val="100000"/>
 864 |           </a:lnSpc>
 865 |           <a:spcBef>
 866 |             <a:spcPts val="0"/>
 867 |           </a:spcBef>
 868 |           <a:spcAft>
 869 |             <a:spcPts val="0"/>
 870 |           </a:spcAft>
 871 |           <a:buClrTx/>
 872 |           <a:buSzTx/>
 873 |           <a:buFontTx/>
 874 |           <a:buNone/>
 875 |           <a:tabLst/>
 876 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 877 |             <a:ln>
 878 |               <a:noFill/>
 879 |             </a:ln>
 880 |             <a:solidFill>
 881 |               <a:srgbClr val="000000"/>
 882 |             </a:solidFill>
 883 |             <a:effectLst/>
 884 |             <a:uFillTx/>
 885 |           </a:defRPr>
 886 |         </a:lvl3pPr>
 887 |         <a:lvl4pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 888 |           <a:lnSpc>
 889 |             <a:spcPct val="100000"/>
 890 |           </a:lnSpc>
 891 |           <a:spcBef>
 892 |             <a:spcPts val="0"/>
 893 |           </a:spcBef>
 894 |           <a:spcAft>
 895 |             <a:spcPts val="0"/>
 896 |           </a:spcAft>
 897 |           <a:buClrTx/>
 898 |           <a:buSzTx/>
 899 |           <a:buFontTx/>
 900 |           <a:buNone/>
 901 |           <a:tabLst/>
 902 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 903 |             <a:ln>
 904 |               <a:noFill/>
 905 |             </a:ln>
 906 |             <a:solidFill>
 907 |               <a:srgbClr val="000000"/>
 908 |             </a:solidFill>
 909 |             <a:effectLst/>
 910 |             <a:uFillTx/>
 911 |           </a:defRPr>
 912 |         </a:lvl4pPr>
 913 |         <a:lvl5pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 914 |           <a:lnSpc>
 915 |             <a:spcPct val="100000"/>
 916 |           </a:lnSpc>
 917 |           <a:spcBef>
 918 |             <a:spcPts val="0"/>
 919 |           </a:spcBef>
 920 |           <a:spcAft>
 921 |             <a:spcPts val="0"/>
 922 |           </a:spcAft>
 923 |           <a:buClrTx/>
 924 |           <a:buSzTx/>
 925 |           <a:buFontTx/>
 926 |           <a:buNone/>
 927 |           <a:tabLst/>
 928 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 929 |             <a:ln>
 930 |               <a:noFill/>
 931 |             </a:ln>
 932 |             <a:solidFill>
 933 |               <a:srgbClr val="000000"/>
 934 |             </a:solidFill>
 935 |             <a:effectLst/>
 936 |             <a:uFillTx/>
 937 |           </a:defRPr>
 938 |         </a:lvl5pPr>
 939 |         <a:lvl6pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 940 |           <a:lnSpc>
 941 |             <a:spcPct val="100000"/>
 942 |           </a:lnSpc>
 943 |           <a:spcBef>
 944 |             <a:spcPts val="0"/>
 945 |           </a:spcBef>
 946 |           <a:spcAft>
 947 |             <a:spcPts val="0"/>
 948 |           </a:spcAft>
 949 |           <a:buClrTx/>
 950 |           <a:buSzTx/>
 951 |           <a:buFontTx/>
 952 |           <a:buNone/>
 953 |           <a:tabLst/>
 954 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 955 |             <a:ln>
 956 |               <a:noFill/>
 957 |             </a:ln>
 958 |             <a:solidFill>
 959 |               <a:srgbClr val="000000"/>
 960 |             </a:solidFill>
 961 |             <a:effectLst/>
 962 |             <a:uFillTx/>
 963 |           </a:defRPr>
 964 |         </a:lvl6pPr>
 965 |         <a:lvl7pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 966 |           <a:lnSpc>
 967 |             <a:spcPct val="100000"/>
 968 |           </a:lnSpc>
 969 |           <a:spcBef>
 970 |             <a:spcPts val="0"/>
 971 |           </a:spcBef>
 972 |           <a:spcAft>
 973 |             <a:spcPts val="0"/>
 974 |           </a:spcAft>
 975 |           <a:buClrTx/>
 976 |           <a:buSzTx/>
 977 |           <a:buFontTx/>
 978 |           <a:buNone/>
 979 |           <a:tabLst/>
 980 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
 981 |             <a:ln>
 982 |               <a:noFill/>
 983 |             </a:ln>
 984 |             <a:solidFill>
 985 |               <a:srgbClr val="000000"/>
 986 |             </a:solidFill>
 987 |             <a:effectLst/>
 988 |             <a:uFillTx/>
 989 |           </a:defRPr>
 990 |         </a:lvl7pPr>
 991 |         <a:lvl8pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
 992 |           <a:lnSpc>
 993 |             <a:spcPct val="100000"/>
 994 |           </a:lnSpc>
 995 |           <a:spcBef>
 996 |             <a:spcPts val="0"/>
 997 |           </a:spcBef>
 998 |           <a:spcAft>
 999 |             <a:spcPts val="0"/>
1000 |           </a:spcAft>
1001 |           <a:buClrTx/>
1002 |           <a:buSzTx/>
1003 |           <a:buFontTx/>
1004 |           <a:buNone/>
1005 |           <a:tabLst/>
1006 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
1007 |             <a:ln>
1008 |               <a:noFill/>
1009 |             </a:ln>
1010 |             <a:solidFill>
1011 |               <a:srgbClr val="000000"/>
1012 |             </a:solidFill>
1013 |             <a:effectLst/>
1014 |             <a:uFillTx/>
1015 |           </a:defRPr>
1016 |         </a:lvl8pPr>
1017 |         <a:lvl9pPr algn="l" defTabSz="914400" fontAlgn="auto" hangingPunct="0" indent="0" latinLnBrk="1" marL="0" marR="0" rtl="0">
1018 |           <a:lnSpc>
1019 |             <a:spcPct val="100000"/>
1020 |           </a:lnSpc>
1021 |           <a:spcBef>
1022 |             <a:spcPts val="0"/>
1023 |           </a:spcBef>
1024 |           <a:spcAft>
1025 |             <a:spcPts val="0"/>
1026 |           </a:spcAft>
1027 |           <a:buClrTx/>
1028 |           <a:buSzTx/>
1029 |           <a:buFontTx/>
1030 |           <a:buNone/>
1031 |           <a:tabLst/>
1032 |           <a:defRPr b="0" baseline="0" cap="none" i="0" kumimoji="0" normalizeH="0" spc="0" strike="noStrike" sz="1800" u="none">
1033 |             <a:ln>
1034 |               <a:noFill/>
1035 |             </a:ln>
1036 |             <a:solidFill>
1037 |               <a:srgbClr val="000000"/>
1038 |             </a:solidFill>
1039 |             <a:effectLst/>
1040 |             <a:uFillTx/>
1041 |           </a:defRPr>
1042 |         </a:lvl9pPr>
1043 |       </a:lstStyle>
1044 |       <a:style>
1045 |         <a:lnRef idx="0"/>
1046 |         <a:fillRef idx="0"/>
1047 |         <a:effectRef idx="0"/>
1048 |         <a:fontRef idx="none"/>
1049 |       </a:style>
1050 |     </a:txDef>
1051 |   </a:objectDefaults>
1052 | </a:theme>
1053 | 


--------------------------------------------------------------------------------
/test/fixtures/package/xl/workbook.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
 3 |   <bookViews>
 4 |     <workbookView windowHeight="18080" windowWidth="15960" xWindow="0" yWindow="40"/>
 5 |   </bookViews>
 6 |   <sheets>
 7 |     <sheet name="Sheet 1" r:id="rId4" sheetId="1"/>
 8 |     <sheet name="Sheet 2" r:id="rId5" sheetId="2"/>
 9 |     <sheet name="Sheet 3" r:id="rId6" sheetId="3"/>
10 |   </sheets>
11 | </workbook>
12 | 


--------------------------------------------------------------------------------
/test/fixtures/package/xl/worksheets/_rels/sheet3.xml.rels:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
3 |   <Relationship Id="rId1" Target="https://elixir-lang.org/" TargetMode="External" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"/>
4 | </Relationships>
5 | 


--------------------------------------------------------------------------------
/test/fixtures/package/xl/worksheets/sheet1.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
  3 |   <dimension ref="A1:G22"/>
  4 |   <sheetViews>
  5 |     <sheetView defaultGridColor="1" showGridLines="0" workbookViewId="0"/>
  6 |   </sheetViews>
  7 |   <sheetFormatPr customHeight="1" defaultColWidth="16.3333" defaultRowHeight="19.9" outlineLevelCol="0" outlineLevelRow="0"/>
  8 |   <cols>
  9 |     <col customWidth="1" max="7" min="1" style="1" width="16.3516"/>
 10 |     <col customWidth="1" max="256" min="8" style="1" width="16.3516"/>
 11 |   </cols>
 12 |   <sheetData>
 13 |     <row customHeight="1" ht="20.25" r="1">
 14 |       <c r="A1" s="2" t="s">
 15 |         <v>0</v>
 16 |       </c>
 17 |       <c r="B1" s="2" t="s">
 18 |         <v>1</v>
 19 |       </c>
 20 |       <c r="C1" s="2" t="s">
 21 |         <v>2</v>
 22 |       </c>
 23 |       <c r="D1" s="2" t="s">
 24 |         <v>3</v>
 25 |       </c>
 26 |       <c r="E1" s="2" t="s">
 27 |         <v>4</v>
 28 |       </c>
 29 |       <c r="F1" s="2" t="s">
 30 |         <v>5</v>
 31 |       </c>
 32 |       <c r="G1" s="2" t="s">
 33 |         <v>6</v>
 34 |       </c>
 35 |     </row>
 36 |     <row customHeight="1" ht="20.25" r="2">
 37 |       <c r="A2" s="3">
 38 |         <v>1</v>
 39 |       </c>
 40 |       <c r="B2" s="4">
 41 |         <v>2</v>
 42 |       </c>
 43 |       <c r="C2" s="5">
 44 |         <v>3</v>
 45 |       </c>
 46 |       <c r="D2" s="5">
 47 |         <v>4</v>
 48 |       </c>
 49 |       <c r="E2" s="5">
 50 |         <v>5</v>
 51 |       </c>
 52 |       <c r="F2" s="5">
 53 |         <v>6</v>
 54 |       </c>
 55 |       <c r="G2" s="5">
 56 |         <v>7</v>
 57 |       </c>
 58 |     </row>
 59 |     <row customHeight="1" ht="20.05" r="3">
 60 |       <c r="A3" s="6">
 61 |         <v>2</v>
 62 |       </c>
 63 |       <c r="B3" s="7">
 64 |         <f>$A3*B2</f>
 65 |         <v>4</v>
 66 |       </c>
 67 |       <c r="C3" s="8">
 68 |         <f>$A3*C2</f>
 69 |         <v>6</v>
 70 |       </c>
 71 |       <c r="D3" s="8">
 72 |         <f>$A3*D2</f>
 73 |         <v>8</v>
 74 |       </c>
 75 |       <c r="E3" s="8">
 76 |         <f>$A3*E2</f>
 77 |         <v>10</v>
 78 |       </c>
 79 |       <c r="F3" s="8">
 80 |         <f>$A3*F2</f>
 81 |         <v>12</v>
 82 |       </c>
 83 |       <c r="G3" s="8">
 84 |         <f>$A3*G2</f>
 85 |         <v>14</v>
 86 |       </c>
 87 |     </row>
 88 |     <row customHeight="1" ht="20.05" r="4">
 89 |       <c r="A4" s="6">
 90 |         <v>3</v>
 91 |       </c>
 92 |       <c r="B4" s="7">
 93 |         <f>$A4*B3</f>
 94 |         <v>12</v>
 95 |       </c>
 96 |       <c r="C4" s="8">
 97 |         <f>$A4*C3</f>
 98 |         <v>18</v>
 99 |       </c>
100 |       <c r="D4" s="8">
101 |         <f>$A4*D3</f>
102 |         <v>24</v>
103 |       </c>
104 |       <c r="E4" s="8">
105 |         <f>$A4*E3</f>
106 |         <v>30</v>
107 |       </c>
108 |       <c r="F4" s="8">
109 |         <f>$A4*F3</f>
110 |         <v>36</v>
111 |       </c>
112 |       <c r="G4" s="8">
113 |         <f>$A4*G3</f>
114 |         <v>42</v>
115 |       </c>
116 |     </row>
117 |     <row customHeight="1" ht="20.05" r="5">
118 |       <c r="A5" s="6">
119 |         <v>4</v>
120 |       </c>
121 |       <c r="B5" s="7">
122 |         <f>$A5*B4</f>
123 |         <v>48</v>
124 |       </c>
125 |       <c r="C5" s="8">
126 |         <f>$A5*C4</f>
127 |         <v>72</v>
128 |       </c>
129 |       <c r="D5" s="8">
130 |         <f>$A5*D4</f>
131 |         <v>96</v>
132 |       </c>
133 |       <c r="E5" s="8">
134 |         <f>$A5*E4</f>
135 |         <v>120</v>
136 |       </c>
137 |       <c r="F5" s="8">
138 |         <f>$A5*F4</f>
139 |         <v>144</v>
140 |       </c>
141 |       <c r="G5" s="8">
142 |         <f>$A5*G4</f>
143 |         <v>168</v>
144 |       </c>
145 |     </row>
146 |     <row customHeight="1" ht="20.05" r="6">
147 |       <c r="A6" s="6">
148 |         <v>5</v>
149 |       </c>
150 |       <c r="B6" s="7">
151 |         <f>$A6*B5</f>
152 |         <v>240</v>
153 |       </c>
154 |       <c r="C6" s="8">
155 |         <f>$A6*C5</f>
156 |         <v>360</v>
157 |       </c>
158 |       <c r="D6" s="8">
159 |         <f>$A6*D5</f>
160 |         <v>480</v>
161 |       </c>
162 |       <c r="E6" s="8">
163 |         <f>$A6*E5</f>
164 |         <v>600</v>
165 |       </c>
166 |       <c r="F6" s="8">
167 |         <f>$A6*F5</f>
168 |         <v>720</v>
169 |       </c>
170 |       <c r="G6" s="8">
171 |         <f>$A6*G5</f>
172 |         <v>840</v>
173 |       </c>
174 |     </row>
175 |     <row customHeight="1" ht="20.05" r="7">
176 |       <c r="A7" s="6">
177 |         <v>6</v>
178 |       </c>
179 |       <c r="B7" s="7">
180 |         <f>$A7*B6</f>
181 |         <v>1440</v>
182 |       </c>
183 |       <c r="C7" s="8">
184 |         <f>$A7*C6</f>
185 |         <v>2160</v>
186 |       </c>
187 |       <c r="D7" s="8">
188 |         <f>$A7*D6</f>
189 |         <v>2880</v>
190 |       </c>
191 |       <c r="E7" s="8">
192 |         <f>$A7*E6</f>
193 |         <v>3600</v>
194 |       </c>
195 |       <c r="F7" s="8">
196 |         <f>$A7*F6</f>
197 |         <v>4320</v>
198 |       </c>
199 |       <c r="G7" s="8">
200 |         <f>$A7*G6</f>
201 |         <v>5040</v>
202 |       </c>
203 |     </row>
204 |     <row customHeight="1" ht="20.05" r="8">
205 |       <c r="A8" s="6">
206 |         <v>7</v>
207 |       </c>
208 |       <c r="B8" s="7">
209 |         <f>$A8*B7</f>
210 |         <v>10080</v>
211 |       </c>
212 |       <c r="C8" s="8">
213 |         <f>$A8*C7</f>
214 |         <v>15120</v>
215 |       </c>
216 |       <c r="D8" s="8">
217 |         <f>$A8*D7</f>
218 |         <v>20160</v>
219 |       </c>
220 |       <c r="E8" s="8">
221 |         <f>$A8*E7</f>
222 |         <v>25200</v>
223 |       </c>
224 |       <c r="F8" s="8">
225 |         <f>$A8*F7</f>
226 |         <v>30240</v>
227 |       </c>
228 |       <c r="G8" s="8">
229 |         <f>$A8*G7</f>
230 |         <v>35280</v>
231 |       </c>
232 |     </row>
233 |     <row customHeight="1" ht="20.05" r="9">
234 |       <c r="A9" s="6">
235 |         <v>8</v>
236 |       </c>
237 |       <c r="B9" s="7">
238 |         <f>$A9*B8</f>
239 |         <v>80640</v>
240 |       </c>
241 |       <c r="C9" s="8">
242 |         <f>$A9*C8</f>
243 |         <v>120960</v>
244 |       </c>
245 |       <c r="D9" s="8">
246 |         <f>$A9*D8</f>
247 |         <v>161280</v>
248 |       </c>
249 |       <c r="E9" s="8">
250 |         <f>$A9*E8</f>
251 |         <v>201600</v>
252 |       </c>
253 |       <c r="F9" s="8">
254 |         <f>$A9*F8</f>
255 |         <v>241920</v>
256 |       </c>
257 |       <c r="G9" s="8">
258 |         <f>$A9*G8</f>
259 |         <v>282240</v>
260 |       </c>
261 |     </row>
262 |     <row customHeight="1" ht="20.05" r="10">
263 |       <c r="A10" s="6">
264 |         <v>9</v>
265 |       </c>
266 |       <c r="B10" s="7">
267 |         <f>$A10*B9</f>
268 |         <v>725760</v>
269 |       </c>
270 |       <c r="C10" s="8">
271 |         <f>$A10*C9</f>
272 |         <v>1088640</v>
273 |       </c>
274 |       <c r="D10" s="8">
275 |         <f>$A10*D9</f>
276 |         <v>1451520</v>
277 |       </c>
278 |       <c r="E10" s="8">
279 |         <f>$A10*E9</f>
280 |         <v>1814400</v>
281 |       </c>
282 |       <c r="F10" s="8">
283 |         <f>$A10*F9</f>
284 |         <v>2177280</v>
285 |       </c>
286 |       <c r="G10" s="8">
287 |         <f>$A10*G9</f>
288 |         <v>2540160</v>
289 |       </c>
290 |     </row>
291 |     <row customHeight="1" ht="20.05" r="11">
292 |       <c r="A11" s="6">
293 |         <v>10</v>
294 |       </c>
295 |       <c r="B11" s="7">
296 |         <f>$A11*B10</f>
297 |         <v>7257600</v>
298 |       </c>
299 |       <c r="C11" s="8">
300 |         <f>$A11*C10</f>
301 |         <v>10886400</v>
302 |       </c>
303 |       <c r="D11" s="8">
304 |         <f>$A11*D10</f>
305 |         <v>14515200</v>
306 |       </c>
307 |       <c r="E11" s="8">
308 |         <f>$A11*E10</f>
309 |         <v>18144000</v>
310 |       </c>
311 |       <c r="F11" s="8">
312 |         <f>$A11*F10</f>
313 |         <v>21772800</v>
314 |       </c>
315 |       <c r="G11" s="8">
316 |         <f>$A11*G10</f>
317 |         <v>25401600</v>
318 |       </c>
319 |     </row>
320 |     <row customHeight="1" ht="20.05" r="12">
321 |       <c r="A12" s="6">
322 |         <v>11</v>
323 |       </c>
324 |       <c r="B12" s="7">
325 |         <f>$A12*B11</f>
326 |         <v>79833600</v>
327 |       </c>
328 |       <c r="C12" s="8">
329 |         <f>$A12*C11</f>
330 |         <v>119750400</v>
331 |       </c>
332 |       <c r="D12" s="8">
333 |         <f>$A12*D11</f>
334 |         <v>159667200</v>
335 |       </c>
336 |       <c r="E12" s="8">
337 |         <f>$A12*E11</f>
338 |         <v>199584000</v>
339 |       </c>
340 |       <c r="F12" s="8">
341 |         <f>$A12*F11</f>
342 |         <v>239500800</v>
343 |       </c>
344 |       <c r="G12" s="8">
345 |         <f>$A12*G11</f>
346 |         <v>279417600</v>
347 |       </c>
348 |     </row>
349 |     <row customHeight="1" ht="20.05" r="13">
350 |       <c r="A13" s="6">
351 |         <v>12</v>
352 |       </c>
353 |       <c r="B13" s="7">
354 |         <f>$A13*B12</f>
355 |         <v>958003200</v>
356 |       </c>
357 |       <c r="C13" s="8">
358 |         <f>$A13*C12</f>
359 |         <v>1437004800</v>
360 |       </c>
361 |       <c r="D13" s="8">
362 |         <f>$A13*D12</f>
363 |         <v>1916006400</v>
364 |       </c>
365 |       <c r="E13" s="8">
366 |         <f>$A13*E12</f>
367 |         <v>2395008000</v>
368 |       </c>
369 |       <c r="F13" s="8">
370 |         <f>$A13*F12</f>
371 |         <v>2874009600</v>
372 |       </c>
373 |       <c r="G13" s="8">
374 |         <f>$A13*G12</f>
375 |         <v>3353011200</v>
376 |       </c>
377 |     </row>
378 |     <row customHeight="1" ht="20.05" r="14">
379 |       <c r="A14" s="6">
380 |         <v>13</v>
381 |       </c>
382 |       <c r="B14" s="7">
383 |         <f>$A14*B13</f>
384 |         <v>12454041600</v>
385 |       </c>
386 |       <c r="C14" s="8">
387 |         <f>$A14*C13</f>
388 |         <v>18681062400</v>
389 |       </c>
390 |       <c r="D14" s="8">
391 |         <f>$A14*D13</f>
392 |         <v>24908083200</v>
393 |       </c>
394 |       <c r="E14" s="8">
395 |         <f>$A14*E13</f>
396 |         <v>31135104000</v>
397 |       </c>
398 |       <c r="F14" s="8">
399 |         <f>$A14*F13</f>
400 |         <v>37362124800</v>
401 |       </c>
402 |       <c r="G14" s="8">
403 |         <f>$A14*G13</f>
404 |         <v>43589145600</v>
405 |       </c>
406 |     </row>
407 |     <row customHeight="1" ht="20.05" r="15">
408 |       <c r="A15" s="6">
409 |         <v>14</v>
410 |       </c>
411 |       <c r="B15" s="7">
412 |         <f>$A15*B14</f>
413 |         <v>174356582400</v>
414 |       </c>
415 |       <c r="C15" s="8">
416 |         <f>$A15*C14</f>
417 |         <v>261534873600</v>
418 |       </c>
419 |       <c r="D15" s="8">
420 |         <f>$A15*D14</f>
421 |         <v>348713164800</v>
422 |       </c>
423 |       <c r="E15" s="8">
424 |         <f>$A15*E14</f>
425 |         <v>435891456000</v>
426 |       </c>
427 |       <c r="F15" s="8">
428 |         <f>$A15*F14</f>
429 |         <v>523069747200</v>
430 |       </c>
431 |       <c r="G15" s="8">
432 |         <f>$A15*G14</f>
433 |         <v>610248038400</v>
434 |       </c>
435 |     </row>
436 |     <row customHeight="1" ht="20.05" r="16">
437 |       <c r="A16" s="6">
438 |         <v>15</v>
439 |       </c>
440 |       <c r="B16" s="7">
441 |         <f>$A16*B15</f>
442 |         <v>2615348736000</v>
443 |       </c>
444 |       <c r="C16" s="8">
445 |         <f>$A16*C15</f>
446 |         <v>3923023104000</v>
447 |       </c>
448 |       <c r="D16" s="8">
449 |         <f>$A16*D15</f>
450 |         <v>5230697472000</v>
451 |       </c>
452 |       <c r="E16" s="8">
453 |         <f>$A16*E15</f>
454 |         <v>6538371840000</v>
455 |       </c>
456 |       <c r="F16" s="8">
457 |         <f>$A16*F15</f>
458 |         <v>7846046208000</v>
459 |       </c>
460 |       <c r="G16" s="8">
461 |         <f>$A16*G15</f>
462 |         <v>9153720576000</v>
463 |       </c>
464 |     </row>
465 |     <row customHeight="1" ht="20.05" r="17">
466 |       <c r="A17" s="6">
467 |         <v>16</v>
468 |       </c>
469 |       <c r="B17" s="7">
470 |         <f>$A17*B16</f>
471 |         <v>41845579776000</v>
472 |       </c>
473 |       <c r="C17" s="8">
474 |         <f>$A17*C16</f>
475 |         <v>62768369664000</v>
476 |       </c>
477 |       <c r="D17" s="8">
478 |         <f>$A17*D16</f>
479 |         <v>83691159552000</v>
480 |       </c>
481 |       <c r="E17" s="8">
482 |         <f>$A17*E16</f>
483 |         <v>104613949440000</v>
484 |       </c>
485 |       <c r="F17" s="8">
486 |         <f>$A17*F16</f>
487 |         <v>125536739328000</v>
488 |       </c>
489 |       <c r="G17" s="8">
490 |         <f>$A17*G16</f>
491 |         <v>146459529216000</v>
492 |       </c>
493 |     </row>
494 |     <row customHeight="1" ht="20.05" r="18">
495 |       <c r="A18" s="6">
496 |         <v>17</v>
497 |       </c>
498 |       <c r="B18" s="7">
499 |         <f>$A18*B17</f>
500 |         <v>711374856192000</v>
501 |       </c>
502 |       <c r="C18" s="8">
503 |         <f>$A18*C17</f>
504 |         <v>1067062284288000</v>
505 |       </c>
506 |       <c r="D18" s="8">
507 |         <f>$A18*D17</f>
508 |         <v>1422749712384000</v>
509 |       </c>
510 |       <c r="E18" s="8">
511 |         <f>$A18*E17</f>
512 |         <v>1778437140480000</v>
513 |       </c>
514 |       <c r="F18" s="8">
515 |         <f>$A18*F17</f>
516 |         <v>2134124568576000</v>
517 |       </c>
518 |       <c r="G18" s="8">
519 |         <f>$A18*G17</f>
520 |         <v>2489811996672000</v>
521 |       </c>
522 |     </row>
523 |     <row customHeight="1" ht="20.05" r="19">
524 |       <c r="A19" s="6">
525 |         <v>18</v>
526 |       </c>
527 |       <c r="B19" s="7">
528 |         <f>$A19*B18</f>
529 |         <v>1.2804747411456e+16</v>
530 |       </c>
531 |       <c r="C19" s="8">
532 |         <f>$A19*C18</f>
533 |         <v>1.9207121117184e+16</v>
534 |       </c>
535 |       <c r="D19" s="8">
536 |         <f>$A19*D18</f>
537 |         <v>2.5609494822912e+16</v>
538 |       </c>
539 |       <c r="E19" s="8">
540 |         <f>$A19*E18</f>
541 |         <v>3.201186852864e+16</v>
542 |       </c>
543 |       <c r="F19" s="8">
544 |         <f>$A19*F18</f>
545 |         <v>3.8414242234368e+16</v>
546 |       </c>
547 |       <c r="G19" s="8">
548 |         <f>$A19*G18</f>
549 |         <v>4.4816615940096e+16</v>
550 |       </c>
551 |     </row>
552 |     <row customHeight="1" ht="20.05" r="20">
553 |       <c r="A20" s="6">
554 |         <v>19</v>
555 |       </c>
556 |       <c r="B20" s="7">
557 |         <f>$A20*B19</f>
558 |         <v>2.43290200817664e+17</v>
559 |       </c>
560 |       <c r="C20" s="8">
561 |         <f>$A20*C19</f>
562 |         <v>3.64935301226496e+17</v>
563 |       </c>
564 |       <c r="D20" s="8">
565 |         <f>$A20*D19</f>
566 |         <v>4.86580401635328e+17</v>
567 |       </c>
568 |       <c r="E20" s="8">
569 |         <f>$A20*E19</f>
570 |         <v>6.0822550204416e+17</v>
571 |       </c>
572 |       <c r="F20" s="8">
573 |         <f>$A20*F19</f>
574 |         <v>7.29870602452992e+17</v>
575 |       </c>
576 |       <c r="G20" s="8">
577 |         <f>$A20*G19</f>
578 |         <v>8.51515702861824e+17</v>
579 |       </c>
580 |     </row>
581 |     <row customHeight="1" ht="20.05" r="21">
582 |       <c r="A21" s="6">
583 |         <v>20</v>
584 |       </c>
585 |       <c r="B21" s="7">
586 |         <f>$A21*B20</f>
587 |         <v>4.86580401635328e+18</v>
588 |       </c>
589 |       <c r="C21" s="8">
590 |         <f>$A21*C20</f>
591 |         <v>7.29870602452992e+18</v>
592 |       </c>
593 |       <c r="D21" s="8">
594 |         <f>$A21*D20</f>
595 |         <v>9.73160803270656e+18</v>
596 |       </c>
597 |       <c r="E21" s="8">
598 |         <f>$A21*E20</f>
599 |         <v>1.21645100408832e+19</v>
600 |       </c>
601 |       <c r="F21" s="8">
602 |         <f>$A21*F20</f>
603 |         <v>1.45974120490598e+19</v>
604 |       </c>
605 |       <c r="G21" s="8">
606 |         <f>$A21*G20</f>
607 |         <v>1.70303140572365e+19</v>
608 |       </c>
609 |     </row>
610 |     <row customHeight="1" ht="20.05" r="22">
611 |       <c r="A22" s="6">
612 |         <v>21</v>
613 |       </c>
614 |       <c r="B22" s="7">
615 |         <f>$A22*B21</f>
616 |         <v>1.02181884343419e+20</v>
617 |       </c>
618 |       <c r="C22" s="8">
619 |         <f>$A22*C21</f>
620 |         <v>1.53272826515128e+20</v>
621 |       </c>
622 |       <c r="D22" s="8">
623 |         <f>$A22*D21</f>
624 |         <v>2.04363768686838e+20</v>
625 |       </c>
626 |       <c r="E22" s="8">
627 |         <f>$A22*E21</f>
628 |         <v>2.55454710858547e+20</v>
629 |       </c>
630 |       <c r="F22" s="8">
631 |         <f>$A22*F21</f>
632 |         <v>3.06545653030256e+20</v>
633 |       </c>
634 |       <c r="G22" s="8">
635 |         <f>$A22*G21</f>
636 |         <v>3.57636595201967e+20</v>
637 |       </c>
638 |     </row>
639 |   </sheetData>
640 |   <pageMargins bottom="0.75" footer="0.277778" header="0.277778" left="0.5" right="0.5" top="0.75"/>
641 |   <pageSetup firstPageNumber="1" fitToHeight="1" fitToWidth="1" orientation="portrait" pageOrder="downThenOver" scale="72" useFirstPageNumber="0"/>
642 |   <headerFooter>
643 |     <oddFooter>&amp;C&amp;&quot;Helvetica Neue,Regular&quot;&amp;12&amp;K000000&amp;P</oddFooter>
644 |   </headerFooter>
645 | </worksheet>
646 | 


--------------------------------------------------------------------------------
/test/fixtures/package/xl/worksheets/sheet2.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
 3 |   <sheetPr>
 4 |     <pageSetUpPr fitToPage="1"/>
 5 |   </sheetPr>
 6 |   <dimension ref="A1:E10"/>
 7 |   <sheetViews>
 8 |     <sheetView defaultGridColor="1" showGridLines="0" workbookViewId="0"/>
 9 |   </sheetViews>
10 |   <sheetFormatPr customHeight="1" defaultColWidth="16.3333" defaultRowHeight="19.9" outlineLevelCol="0" outlineLevelRow="0"/>
11 |   <cols>
12 |     <col customWidth="1" max="5" min="1" style="9" width="16.3516"/>
13 |     <col customWidth="1" max="256" min="6" style="9" width="16.3516"/>
14 |   </cols>
15 |   <sheetData>
16 |     <row customHeight="1" ht="20.25" r="1">
17 |       <c r="A1" s="10"/>
18 |       <c r="B1" s="10"/>
19 |       <c r="C1" s="10"/>
20 |       <c r="D1" s="10"/>
21 |       <c r="E1" s="10"/>
22 |     </row>
23 |     <row customHeight="1" ht="20.25" r="2">
24 |       <c r="A2" s="11" t="s">
25 |         <v>7</v>
26 |       </c>
27 |       <c r="B2" s="12" t="s">
28 |         <v>8</v>
29 |       </c>
30 |       <c r="C2" s="13"/>
31 |       <c r="D2" s="13"/>
32 |       <c r="E2" s="13"/>
33 |     </row>
34 |     <row customHeight="1" ht="20.05" r="3">
35 |       <c r="A3" s="14"/>
36 |       <c r="B3" s="15"/>
37 |       <c r="C3" s="16"/>
38 |       <c r="D3" s="16"/>
39 |       <c r="E3" s="16"/>
40 |     </row>
41 |     <row customHeight="1" ht="20.05" r="4">
42 |       <c r="A4" s="14"/>
43 |       <c r="B4" s="15"/>
44 |       <c r="C4" s="16"/>
45 |       <c r="D4" s="16"/>
46 |       <c r="E4" s="16"/>
47 |     </row>
48 |     <row customHeight="1" ht="20.05" r="5">
49 |       <c r="A5" s="14"/>
50 |       <c r="B5" s="15"/>
51 |       <c r="C5" s="16"/>
52 |       <c r="D5" s="16"/>
53 |       <c r="E5" s="16"/>
54 |     </row>
55 |     <row customHeight="1" ht="20.05" r="6">
56 |       <c r="A6" s="14"/>
57 |       <c r="B6" s="15"/>
58 |       <c r="C6" s="16"/>
59 |       <c r="D6" s="16"/>
60 |       <c r="E6" s="16"/>
61 |     </row>
62 |     <row customHeight="1" ht="20.05" r="7">
63 |       <c r="A7" s="14"/>
64 |       <c r="B7" s="15"/>
65 |       <c r="C7" s="16"/>
66 |       <c r="D7" s="16"/>
67 |       <c r="E7" s="16"/>
68 |     </row>
69 |     <row customHeight="1" ht="20.05" r="8">
70 |       <c r="A8" s="14"/>
71 |       <c r="B8" s="15"/>
72 |       <c r="C8" s="16"/>
73 |       <c r="D8" s="16"/>
74 |       <c r="E8" s="16"/>
75 |     </row>
76 |     <row customHeight="1" ht="20.05" r="9">
77 |       <c r="A9" s="14"/>
78 |       <c r="B9" s="15"/>
79 |       <c r="C9" s="16"/>
80 |       <c r="D9" s="16"/>
81 |       <c r="E9" s="16"/>
82 |     </row>
83 |     <row customHeight="1" ht="20.05" r="10">
84 |       <c r="A10" s="14"/>
85 |       <c r="B10" s="15"/>
86 |       <c r="C10" s="16"/>
87 |       <c r="D10" s="16"/>
88 |       <c r="E10" s="16"/>
89 |     </row>
90 |   </sheetData>
91 |   <pageMargins bottom="1" footer="0.25" header="0.25" left="1" right="1" top="1"/>
92 |   <pageSetup firstPageNumber="1" fitToHeight="1" fitToWidth="1" orientation="portrait" pageOrder="downThenOver" scale="100" useFirstPageNumber="0"/>
93 |   <headerFooter>
94 |     <oddFooter>&amp;C&amp;&quot;Helvetica Neue,Regular&quot;&amp;12&amp;K000000&amp;P</oddFooter>
95 |   </headerFooter>
96 | </worksheet>
97 | 


--------------------------------------------------------------------------------
/test/fixtures/package/xl/worksheets/sheet3.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
  3 |   <sheetPr>
  4 |     <pageSetUpPr fitToPage="1"/>
  5 |   </sheetPr>
  6 |   <dimension ref="A1:B10"/>
  7 |   <sheetViews>
  8 |     <sheetView defaultGridColor="1" showGridLines="0" workbookViewId="0"/>
  9 |   </sheetViews>
 10 |   <sheetFormatPr customHeight="1" defaultColWidth="16.3333" defaultRowHeight="19.9" outlineLevelCol="0" outlineLevelRow="0"/>
 11 |   <cols>
 12 |     <col customWidth="1" max="1" min="1" style="17" width="16.3516"/>
 13 |     <col customWidth="1" max="2" min="2" style="17" width="22.7734"/>
 14 |     <col customWidth="1" max="256" min="3" style="17" width="16.3516"/>
 15 |   </cols>
 16 |   <sheetData>
 17 |     <row customHeight="1" ht="20.25" r="1">
 18 |       <c r="A1" s="10"/>
 19 |       <c r="B1" s="10"/>
 20 |     </row>
 21 |     <row customHeight="1" ht="20.25" r="2">
 22 |       <c r="A2" s="11" t="s">
 23 |         <v>9</v>
 24 |       </c>
 25 |       <c r="B2" s="18">
 26 |         <f>DATE(2019,11,15)</f>
 27 |         <v>43784</v>
 28 |       </c>
 29 |     </row>
 30 |     <row customHeight="1" ht="20.05" r="3">
 31 |       <c r="A3" s="19" t="s">
 32 |         <v>10</v>
 33 |       </c>
 34 |       <c r="B3" s="20">
 35 |         <f>NOW()</f>
 36 |         <v>43793.462650462963</v>
 37 |       </c>
 38 |     </row>
 39 |     <row customHeight="1" ht="20.05" r="4">
 40 |       <c r="A4" s="19" t="s">
 41 |         <v>11</v>
 42 |       </c>
 43 |       <c r="B4" s="21">
 44 |         <f>TIME(18,45,12)</f>
 45 |         <v>1462.781388888889</v>
 46 |       </c>
 47 |     </row>
 48 |     <row customHeight="1" ht="20.05" r="5">
 49 |       <c r="A5" s="19" t="s">
 50 |         <v>12</v>
 51 |       </c>
 52 |       <c r="B5" s="22">
 53 |         <v>0.125</v>
 54 |       </c>
 55 |     </row>
 56 |     <row customHeight="1" ht="20.05" r="6">
 57 |       <c r="A6" s="19" t="s">
 58 |         <v>13</v>
 59 |       </c>
 60 |       <c r="B6" s="23">
 61 |         <v>100</v>
 62 |       </c>
 63 |     </row>
 64 |     <row customHeight="1" ht="20.05" r="7">
 65 |       <c r="A7" s="19" t="s">
 66 |         <v>14</v>
 67 |       </c>
 68 |       <c r="B7" s="24" t="s">
 69 |         <v>15</v>
 70 |       </c>
 71 |     </row>
 72 |     <row customHeight="1" ht="20.05" r="8">
 73 |       <c r="A8" s="19" t="s">
 74 |         <v>16</v>
 75 |       </c>
 76 |       <c r="B8" s="7" t="b">
 77 |         <v>1</v>
 78 |       </c>
 79 |     </row>
 80 |     <row customHeight="1" ht="20.05" r="9">
 81 |       <c r="A9" s="19" t="s">
 82 |         <v>17</v>
 83 |       </c>
 84 |       <c r="B9" s="7" t="b">
 85 |         <v>0</v>
 86 |       </c>
 87 |     </row>
 88 |     <row customHeight="1" ht="20.05" r="10">
 89 |       <c r="A10" s="19" t="s">
 90 |         <v>18</v>
 91 |       </c>
 92 |       <c r="B10" s="24" t="s">
 93 |         <v>19</v>
 94 |       </c>
 95 |     </row>
 96 |   </sheetData>
 97 |   <hyperlinks>
 98 |     <hyperlink display="https://elixir-lang.org/" location="" r:id="rId1" ref="B10" tooltip=""/>
 99 |   </hyperlinks>
100 |   <pageMargins bottom="1" footer="0.25" header="0.25" left="1" right="1" top="1"/>
101 |   <pageSetup firstPageNumber="1" fitToHeight="1" fitToWidth="1" orientation="portrait" pageOrder="downThenOver" scale="100" useFirstPageNumber="0"/>
102 |   <headerFooter>
103 |     <oddFooter>&amp;C&amp;&quot;Helvetica Neue,Regular&quot;&amp;12&amp;K000000&amp;P</oddFooter>
104 |   </headerFooter>
105 | </worksheet>
106 | 


--------------------------------------------------------------------------------
/test/fixtures/package/xl/worksheets/sheet4.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 2 | <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing" xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006">
 3 |     <sheetPr filterMode="false">
 4 |         <pageSetUpPr fitToPage="false" />
 5 |     </sheetPr>
 6 |     <dimension ref="A1:D2" />
 7 |     <sheetViews>
 8 |         <sheetView showFormulas="false" showGridLines="true" showRowColHeaders="true" showZeros="true" rightToLeft="false" tabSelected="true" showOutlineSymbols="true" defaultGridColor="true" view="normal" topLeftCell="A1" colorId="64" zoomScale="100" zoomScaleNormal="100" zoomScalePageLayoutView="100" workbookViewId="0">
 9 |             <selection pane="topLeft" activeCell="E1" activeCellId="0" sqref="E1" />
10 |         </sheetView>
11 |     </sheetViews>
12 |     <sheetFormatPr defaultColWidth="11.53515625" defaultRowHeight="12.8" zeroHeight="false" outlineLevelRow="0" outlineLevelCol="0"></sheetFormatPr>
13 |     <sheetData>
14 |         <row r="1" customFormat="false" ht="12.8" hidden="false" customHeight="false" outlineLevel="0" collapsed="false">
15 |             <c r="A1" s="0" t="s">
16 |                 <v>20</v>
17 |             </c>
18 |             <c r="B1" s="0" t="s">
19 |                 <v>20</v>
20 |             </c>
21 |             <c r="C1" s="0" t="s">
22 |                 <v>20</v>
23 |             </c>
24 |             <c r="D1" s="0" t="s">
25 |                 <v>20</v>
26 |             </c>
27 |         </row>
28 |         <row r="2" customFormat="false" ht="12.8" hidden="false" customHeight="false" outlineLevel="0" collapsed="false">
29 |             <c r="A2" s="0" t="s">
30 |                 <v>21</v>
31 |             </c>
32 |             <c r="B2" s="0" t="s">
33 |                 <v>21</v>
34 |             </c>
35 |             <c r="C2" s="0" t="s">
36 |                 <v>21</v>
37 |             </c>
38 |             <c r="D2" s="0" t="s">
39 |                 <v>21</v>
40 |             </c>
41 |         </row>
42 |     </sheetData>
43 |     <printOptions headings="false" gridLines="false" gridLinesSet="true" horizontalCentered="false" verticalCentered="false" />
44 |     <pageMargins left="0.7875" right="0.7875" top="1.05277777777778" bottom="1.05277777777778" header="0.7875" footer="0.7875" />
45 |     <pageSetup paperSize="9" scale="100" firstPageNumber="1" fitToWidth="1" fitToHeight="1" pageOrder="downThenOver" orientation="portrait" blackAndWhite="false" draft="false" cellComments="none" useFirstPageNumber="true" horizontalDpi="300" verticalDpi="300" copies="1" />
46 |     <headerFooter differentFirst="false" differentOddEven="false">
47 |         <oddHeader>&amp;C&amp;&quot;Times New Roman,Regular&quot;&amp;12&amp;A</oddHeader>
48 |         <oddFooter>&amp;C&amp;&quot;Times New Roman,Regular&quot;&amp;12Página &amp;P</oddFooter>
49 |     </headerFooter>
50 | </worksheet>


--------------------------------------------------------------------------------
/test/fixtures/package/xl/worksheets/sheet5.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
 3 |   <sheetPr>
 4 |     <pageSetUpPr fitToPage="1"/>
 5 |   </sheetPr>
 6 |   <dimension ref="A1:E1"/>
 7 |   <sheetViews>
 8 |     <sheetView defaultGridColor="1" showGridLines="0" workbookViewId="0"/>
 9 |   </sheetViews>
10 |   <sheetFormatPr customHeight="1" defaultColWidth="16.3333" defaultRowHeight="19.9" outlineLevelCol="0" outlineLevelRow="0"/>
11 |   <cols>
12 |     <col customWidth="1" max="1" min="1" style="17" width="16.3516"/>
13 |     <col customWidth="1" max="2" min="2" style="17" width="22.7734"/>
14 |     <col customWidth="1" max="256" min="3" style="17" width="16.3516"/>
15 |   </cols>
16 |   <sheetData>
17 |     <row customHeight="1" ht="20.25" r="1">
18 |       <c r="A1" s="10"/>
19 |       <c r="B1" t="inlineStr"><is><t></t></is></c>
20 |       <c r="C1" t="inlineStr"><is><t>Hello</t></is></c>
21 |       <c r="D1"></c>
22 |       <c r="E1" t="n"><v>0.0</v></c>
23 |     </row>
24 |   </sheetData>
25 |   <pageMargins bottom="1" footer="0.25" header="0.25" left="1" right="1" top="1"/>
26 |   <pageSetup firstPageNumber="1" fitToHeight="1" fitToWidth="1" orientation="portrait" pageOrder="downThenOver" scale="100" useFirstPageNumber="0"/>
27 |   <headerFooter>
28 |     <oddFooter>&amp;C&amp;&quot;Helvetica Neue,Regular&quot;&amp;12&amp;K000000&amp;P</oddFooter>
29 |   </headerFooter>
30 | </worksheet>
31 | 


--------------------------------------------------------------------------------
/test/fixtures/test.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xavier/xlsx_reader/411a48e8234286d89e5a64fef18918e0b10e437c/test/fixtures/test.xlsx


--------------------------------------------------------------------------------
/test/fixtures/test.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xavier/xlsx_reader/411a48e8234286d89e5a64fef18918e0b10e437c/test/fixtures/test.zip


--------------------------------------------------------------------------------
/test/fixtures/xml/sharedStringsWithRichText.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 2 | <sst count="6" uniqueCount="5" xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
 3 |   <!-- Source: https://docs.microsoft.com/en-us/office/open-xml/working-with-the-shared-string-table -->
 4 |   <si>
 5 |     <t>Cell A1</t>
 6 |   </si>
 7 |   <si>
 8 |     <t>Cell B1</t>
 9 |   </si>
10 |   <si>
11 |     <t>My Cell</t>
12 |   </si>
13 |   <si>
14 |     <r>
15 |       <rPr>
16 |         <sz val="11"/>
17 |         <color rgb="FFFF0000"/>
18 |         <rFont val="Calibri"/>
19 |         <family val="2"/>
20 |         <scheme val="minor"/>
21 |       </rPr>
22 |       <t>Cell</t>
23 |     </r>
24 |     <r>
25 |       <rPr>
26 |         <sz val="11"/>
27 |         <color theme="1"/>
28 |         <rFont val="Calibri"/>
29 |         <family val="2"/>
30 |         <scheme val="minor"/>
31 |       </rPr>
32 |       <t xml:space="preserve"> </t>
33 |     </r>
34 |     <r>
35 |       <rPr>
36 |         <b/>
37 |         <sz val="11"/>
38 |         <color theme="1"/>
39 |         <rFont val="Calibri"/>
40 |         <family val="2"/>
41 |         <scheme val="minor"/>
42 |       </rPr>
43 |       <t>A2</t>
44 |     </r>
45 |   </si>
46 |   <si>
47 |     <r>
48 |       <rPr>
49 |         <sz val="11"/>
50 |         <color rgb="FF00B0F0"/>
51 |         <rFont val="Calibri"/>
52 |         <family val="2"/>
53 |         <scheme val="minor"/>
54 |       </rPr>
55 |       <t>Cell</t>
56 |     </r>
57 |     <r>
58 |       <rPr>
59 |         <sz val="11"/>
60 |         <color theme="1"/>
61 |         <rFont val="Calibri"/>
62 |         <family val="2"/>
63 |         <scheme val="minor"/>
64 |       </rPr>
65 |       <t xml:space="preserve"> </t>
66 |     </r>
67 |     <r>
68 |       <rPr>
69 |         <i/>
70 |         <sz val="11"/>
71 |         <color theme="1"/>
72 |         <rFont val="Calibri"/>
73 |         <family val="2"/>
74 |         <scheme val="minor"/>
75 |       </rPr>
76 |       <t>B2</t>
77 |     </r>
78 |   </si>
79 | </sst>
80 | 


--------------------------------------------------------------------------------
/test/fixtures/xml/sharedStringsWithXmlSpacePreserve.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 2 | <sst count="6" uniqueCount="5" xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
 3 |   <si>
 4 |     <t xml:space="preserve">  with spaces  </t>
 5 |   </si>
 6 |    <si>
 7 |     <t xml:space="default">  without spaces  </t>
 8 |   </si>
 9 |   <si>
10 |     <t>  without spaces  </t>
11 |   </si>
12 | </sst>
13 | 


--------------------------------------------------------------------------------
/test/fixtures/xml/worksheetWithInlineStr.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
 3 |   <sheetData>
 4 |     <row>
 5 |       <c t="inlineStr">
 6 |         <is>
 7 |           <t>inline string</t>
 8 |         </is>
 9 |       </c>
10 |     </row>
11 |   </sheetData>
12 | </worksheet>
13 | 


--------------------------------------------------------------------------------
/test/fixtures/xml/worksheetWithSharedFormulas.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 2 | <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
 3 | 	<sheetData>
 4 | 		<row r="1" spans="1:2" x14ac:dyDescent="0.2">
 5 | 			<c r="A1">
 6 | 				<v>
 7 | 					1
 8 | 				</v>
 9 | 			</c>
10 | 			<c r="B1">
11 | 				<f t="shared" ref="" si="0">
12 | 					SUM(A1:A3)
13 | 				</f>
14 | 				<v>
15 | 					6
16 | 				</v>
17 | 			</c>
18 | 		</row>
19 | 		<row r="2" spans="1:2" x14ac:dyDescent="0.2">
20 | 			<c r="A2">
21 | 				<v>
22 | 					2
23 | 				</v>
24 | 			</c>
25 | 			<c r="B2">
26 | 				<f t="shared" si="0" />
27 | 				<v>
28 | 					6
29 | 				</v>
30 | 			</c>
31 | 		</row>
32 | 		<row r="3" spans="1:2" x14ac:dyDescent="0.2">
33 | 			<c r="A3">
34 | 				<v>
35 | 					3
36 | 				</v>
37 | 			</c>
38 | 			<c r="B3">
39 | 				<f t="shared" si="0" />
40 | 				<v>
41 | 					6
42 | 				</v>
43 | 			</c>
44 | 		</row>
45 | 	</sheetData>
46 | </worksheet>
47 | 


--------------------------------------------------------------------------------
/test/test_helper.exs:
--------------------------------------------------------------------------------
 1 | ExUnit.start()
 2 | 
 3 | defmodule TestFixtures do
 4 |   def read!(relative_path) do
 5 |     relative_path
 6 |     |> path
 7 |     |> File.read!()
 8 |   end
 9 | 
10 |   def path(relative_path) do
11 |     Path.join([__DIR__, "fixtures", relative_path])
12 |   end
13 | end
14 | 


--------------------------------------------------------------------------------
/test/xlsx_reader/cell_reference_test.exs:
--------------------------------------------------------------------------------
 1 | # credo:disable-for-this-file Credo.Check.Warning.OperationWithConstantResult
 2 | defmodule XlsxReader.CellReferenceTest do
 3 |   use ExUnit.Case
 4 | 
 5 |   alias XlsxReader.CellReference
 6 | 
 7 |   describe ".parse/1" do
 8 |     test "returns a {col, row} tuple" do
 9 |       assert {1, 1} == CellReference.parse("A1")
10 |       assert {1, 42} == CellReference.parse("A42")
11 |       assert {2, 1} == CellReference.parse("B1")
12 |       assert {26, 3} == CellReference.parse("Z3")
13 |       assert {26 * 1 + 1, 123} == CellReference.parse("AA123")
14 |       assert {26 * 1 + 26, 123} == CellReference.parse("AZ123")
15 |       assert {26 * 2 + 1, 123} == CellReference.parse("BA123")
16 |       assert {26 * 26 + 1, 123} == CellReference.parse("ZA123")
17 |       assert {26 * 26 + 26, 123} == CellReference.parse("ZZ123")
18 |       assert {26 * 26 * 1 + 26 * 1 + 1, 123_456} == CellReference.parse("AAA123456")
19 |       assert {26 * 26 * 1 + 26 * 1 + 26, 123_456} == CellReference.parse("AAZ123456")
20 |       assert {26 * 26 * 1 + 26 * 2 + 1, 123_456} == CellReference.parse("ABA123456")
21 |       assert {26 * 26 * 2 + 26 * 26 + 1, 123_456} == CellReference.parse("BZA123456")
22 |     end
23 | 
24 |     test "returns error if the reference is invalid" do
25 |       assert :error == CellReference.parse("1A")
26 |       assert :error == CellReference.parse("$A1")
27 |       assert :error == CellReference.parse("A$1")
28 |       assert :error == CellReference.parse("$A$1")
29 |       assert :error == CellReference.parse("bogus")
30 |     end
31 |   end
32 | end
33 | 


--------------------------------------------------------------------------------
/test/xlsx_reader/conversion_test.exs:
--------------------------------------------------------------------------------
1 | defmodule XlsxReader.ConversionTest do
2 |   use ExUnit.Case
3 |   doctest XlsxReader.Conversion
4 | end
5 | 


--------------------------------------------------------------------------------
/test/xlsx_reader/custom_dates_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule CustomDatesTest do
 2 |   @moduledoc """
 3 |   Ensure that various custom date and
 4 |   datetime formats are parsed into
 5 |   Date or NaiveDateTime as appropriate.
 6 |   """
 7 | 
 8 |   use ExUnit.Case
 9 | 
10 |   test "custom_dates.xlsx" do
11 |     assert {:ok, package} = XlsxReader.open(TestFixtures.path("custom_dates.xlsx"))
12 | 
13 |     assert ["Sheet1"] = XlsxReader.sheet_names(package)
14 | 
15 |     assert {:ok,
16 |             [
17 |               ["ISO8601 Date", ~D[2020-05-01]],
18 |               ["ISO8601 Datetime", ~N[2020-05-01 12:45:59]],
19 |               ["US Date", ~D[2020-05-01]],
20 |               ["US Date", ~D[2020-12-31]],
21 |               ["US Datetime", ~N[2020-05-01 01:23:00]],
22 |               ["US Datetime", ~N[2020-05-01 12:23:00]]
23 |             ]} = XlsxReader.sheet(package, "Sheet1")
24 |   end
25 | end
26 | 


--------------------------------------------------------------------------------
/test/xlsx_reader/package_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.PackageLoaderTest do
 2 |   use ExUnit.Case
 3 | 
 4 |   alias XlsxReader.{PackageLoader, ZipArchive}
 5 | 
 6 |   describe "open/1" do
 7 |     test "opens a xlsx file" do
 8 |       zip_handle = ZipArchive.handle(TestFixtures.path("test.xlsx"), :path)
 9 | 
10 |       assert {:ok, package} = PackageLoader.open(zip_handle)
11 | 
12 |       assert package.zip_handle == zip_handle
13 |     end
14 | 
15 |     test "rejects non-xlsx file" do
16 |       zip_handle = ZipArchive.handle(TestFixtures.path("test.zip"), :path)
17 | 
18 |       assert {:error, "invalid xlsx file"} = PackageLoader.open(zip_handle)
19 |     end
20 | 
21 |     test "rejects non-zip file" do
22 |       zip_handle = ZipArchive.handle(TestFixtures.path("not_a_zip.zip"), :path)
23 | 
24 |       assert {:error, "invalid zip file"} = PackageLoader.open(zip_handle)
25 |     end
26 |   end
27 | 
28 |   describe "load_sheet_by_name/2" do
29 |     setup do
30 |       zip_handle = ZipArchive.handle(TestFixtures.path("test.xlsx"), :path)
31 |       {:ok, package} = PackageLoader.open(zip_handle)
32 | 
33 |       {:ok, %{package: package}}
34 |     end
35 | 
36 |     test "loads a sheet by name", %{package: package} do
37 |       assert {:ok,
38 |               [
39 |                 ["A", "B", "C" | _],
40 |                 [1.0, 2.0, 3.0 | _],
41 |                 [2.0, 4.0, 6.0 | _]
42 |                 | _
43 |               ]} = PackageLoader.load_sheet_by_name(package, "Sheet 1")
44 | 
45 |       assert {:ok,
46 |               [
47 |                 ["", "" | _],
48 |                 ["some ", "test" | _]
49 |                 | _
50 |               ]} = PackageLoader.load_sheet_by_name(package, "Sheet 2")
51 |     end
52 |   end
53 | end
54 | 


--------------------------------------------------------------------------------
/test/xlsx_reader/parsers/relationships_parser_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.Parsers.RelationshipsParserTest do
 2 |   use ExUnit.Case
 3 | 
 4 |   alias XlsxReader.Parsers.RelationshipsParser
 5 | 
 6 |   test "parses workbook.xml.rels" do
 7 |     workbook_xml_rels = TestFixtures.read!("package/xl/_rels/workbook.xml.rels")
 8 | 
 9 |     expected = %{
10 |       shared_strings: %{
11 |         "rId1" => "sharedStrings.xml"
12 |       },
13 |       styles: %{
14 |         "rId2" => "styles.xml"
15 |       },
16 |       themes: %{
17 |         "rId3" => "theme/theme1.xml"
18 |       },
19 |       sheets: %{
20 |         "rId4" => "worksheets/sheet1.xml",
21 |         "rId5" => "worksheets/sheet2.xml",
22 |         "rId6" => "worksheets/sheet3.xml"
23 |       }
24 |     }
25 | 
26 |     assert {:ok, expected} == RelationshipsParser.parse(workbook_xml_rels)
27 |   end
28 | end
29 | 


--------------------------------------------------------------------------------
/test/xlsx_reader/parsers/shared_strings_parser_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.Parsers.SharedStringsParserTest do
 2 |   use ExUnit.Case
 3 | 
 4 |   alias XlsxReader.Array
 5 |   alias XlsxReader.Parsers.SharedStringsParser
 6 | 
 7 |   test "parses sharedStrings.xml" do
 8 |     shared_strings_xml = TestFixtures.read!("package/xl/sharedStrings.xml")
 9 | 
10 |     expected =
11 |       Array.from_list([
12 |         "A",
13 |         "B",
14 |         "C",
15 |         "D",
16 |         "E",
17 |         "F",
18 |         "G",
19 |         "some ",
20 |         "test",
21 |         "date",
22 |         "datetime",
23 |         "time",
24 |         "percentage",
25 |         "money chf",
26 |         "money usd",
27 |         "9999,99 USD",
28 |         "ticked",
29 |         "not ticked",
30 |         "hyperlink",
31 |         "https://elixir-lang.org/",
32 |         " ",
33 |         "-"
34 |       ])
35 | 
36 |     assert {:ok, expected} == SharedStringsParser.parse(shared_strings_xml)
37 |   end
38 | 
39 |   test "parses strings with rich text" do
40 |     shared_strings_xml = TestFixtures.read!("xml/sharedStringsWithRichText.xml")
41 | 
42 |     expected =
43 |       Array.from_list([
44 |         "Cell A1",
45 |         "Cell B1",
46 |         "My Cell",
47 |         "Cell A2",
48 |         "Cell B2"
49 |       ])
50 | 
51 |     assert {:ok, expected} == SharedStringsParser.parse(shared_strings_xml)
52 |   end
53 | 
54 |   test "takes xml:space instruction into account" do
55 |     shared_strings_xml = TestFixtures.read!("xml/sharedStringsWithXmlSpacePreserve.xml")
56 | 
57 |     expected =
58 |       Array.from_list([
59 |         "  with spaces  ",
60 |         "without spaces",
61 |         "without spaces"
62 |       ])
63 | 
64 |     assert {:ok, expected} == SharedStringsParser.parse(shared_strings_xml)
65 |   end
66 | end
67 | 


--------------------------------------------------------------------------------
/test/xlsx_reader/parsers/styles_parser_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.Parsers.StylesParserTest do
 2 |   use ExUnit.Case
 3 | 
 4 |   alias XlsxReader.Array
 5 |   alias XlsxReader.Parsers.StylesParser
 6 | 
 7 |   setup do
 8 |     {:ok, %{styles_xml: TestFixtures.read!("package/xl/styles.xml")}}
 9 |   end
10 | 
11 |   test "parses styles.xml into an array of style types", %{styles_xml: styles_xml} do
12 |     expected_style_types =
13 |       Array.from_list([
14 |         :number,
15 |         :number,
16 |         :unsupported,
17 |         :number,
18 |         :number,
19 |         :number,
20 |         :number,
21 |         :number,
22 |         :number,
23 |         :number,
24 |         :number,
25 |         :unsupported,
26 |         :unsupported,
27 |         :number,
28 |         :number,
29 |         :number,
30 |         :number,
31 |         :number,
32 |         :date,
33 |         :unsupported,
34 |         :date_time,
35 |         :time,
36 |         :percentage,
37 |         nil,
38 |         :unsupported
39 |       ])
40 | 
41 |     assert {:ok, ^expected_style_types, _custom_formats} = StylesParser.parse(styles_xml)
42 |   end
43 | 
44 |   test "supports user-provided custom formats", %{styles_xml: styles_xml} do
45 |     supported_custom_formats = [
46 |       {"[$CHF]0.00", :number}
47 |     ]
48 | 
49 |     expected_style_types =
50 |       Array.from_list([
51 |         :number,
52 |         :number,
53 |         :unsupported,
54 |         :number,
55 |         :number,
56 |         :number,
57 |         :number,
58 |         :number,
59 |         :number,
60 |         :number,
61 |         :number,
62 |         :unsupported,
63 |         :unsupported,
64 |         :number,
65 |         :number,
66 |         :number,
67 |         :number,
68 |         :number,
69 |         :date,
70 |         :unsupported,
71 |         :date_time,
72 |         :time,
73 |         :percentage,
74 |         :number,
75 |         :unsupported
76 |       ])
77 | 
78 |     assert {:ok, ^expected_style_types, _custom_formats} =
79 |              StylesParser.parse(styles_xml, supported_custom_formats)
80 |   end
81 | end
82 | 


--------------------------------------------------------------------------------
/test/xlsx_reader/parsers/utils_test.exs:
--------------------------------------------------------------------------------
1 | defmodule XlsxReader.Parsers.UtilsTest do
2 |   use ExUnit.Case
3 |   doctest XlsxReader.Parsers.Utils
4 | end
5 | 


--------------------------------------------------------------------------------
/test/xlsx_reader/parsers/workbook_parser_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.Parsers.WorkbookParserTest do
 2 |   use ExUnit.Case
 3 | 
 4 |   alias XlsxReader.Parsers.WorkbookParser
 5 | 
 6 |   test "parses workbook.xml" do
 7 |     workbook_xml = TestFixtures.read!("package/xl/workbook.xml")
 8 | 
 9 |     expected = %XlsxReader.Workbook{
10 |       sheets: [
11 |         %XlsxReader.Sheet{name: "Sheet 1", rid: "rId4", sheet_id: "1"},
12 |         %XlsxReader.Sheet{name: "Sheet 2", rid: "rId5", sheet_id: "2"},
13 |         %XlsxReader.Sheet{name: "Sheet 3", rid: "rId6", sheet_id: "3"}
14 |       ],
15 |       rels: nil,
16 |       shared_strings: nil,
17 |       style_types: nil,
18 |       base_date: ~D[1899-12-30]
19 |     }
20 | 
21 |     assert {:ok, expected} == WorkbookParser.parse(workbook_xml)
22 |   end
23 | end
24 | 


--------------------------------------------------------------------------------
/test/xlsx_reader/parsers/worksheet_parser_test.exs:
--------------------------------------------------------------------------------
  1 | defmodule XlsxReader.Parsers.WorksheetParserTest do
  2 |   use ExUnit.Case
  3 | 
  4 |   alias XlsxReader.{Cell, Conversion, Workbook}
  5 |   alias XlsxReader.Parsers.{SharedStringsParser, StylesParser, WorksheetParser}
  6 | 
  7 |   setup do
  8 |     {:ok, shared_strings} =
  9 |       "package/xl/sharedStrings.xml"
 10 |       |> TestFixtures.read!()
 11 |       |> SharedStringsParser.parse()
 12 | 
 13 |     {:ok, style_types, custom_formats} =
 14 |       "package/xl/styles.xml"
 15 |       |> TestFixtures.read!()
 16 |       |> StylesParser.parse()
 17 | 
 18 |     workbook = %Workbook{
 19 |       shared_strings: shared_strings,
 20 |       style_types: style_types,
 21 |       custom_formats: custom_formats,
 22 |       base_date: Conversion.base_date(1900)
 23 |     }
 24 | 
 25 |     {:ok, workbook: workbook}
 26 |   end
 27 | 
 28 |   test "parses sheet.xml", %{workbook: workbook} do
 29 |     sheet_xml = TestFixtures.read!("package/xl/worksheets/sheet1.xml")
 30 | 
 31 |     assert {:ok, _result} = WorksheetParser.parse(sheet_xml, workbook)
 32 |   end
 33 | 
 34 |   test "looks up shared strings", %{workbook: workbook} do
 35 |     sheet_xml = TestFixtures.read!("package/xl/worksheets/sheet1.xml")
 36 | 
 37 |     assert {:ok, rows} = WorksheetParser.parse(sheet_xml, workbook)
 38 | 
 39 |     assert [["A", "B", "C", "D", "E", "F", "G"] | _] = rows
 40 |   end
 41 | 
 42 |   test "performs cell type conversions by default", %{workbook: workbook} do
 43 |     sheet_xml = TestFixtures.read!("package/xl/worksheets/sheet3.xml")
 44 | 
 45 |     expected = [
 46 |       ["", ""],
 47 |       ["date", ~D[2019-11-15]],
 48 |       ["datetime", ~N[2019-11-24 11:06:13]],
 49 |       ["time", ~N[1904-01-01 18:45:12]],
 50 |       ["percentage", 12.5],
 51 |       ["money chf", "100"],
 52 |       ["money usd", "9999,99 USD"],
 53 |       ["ticked", true],
 54 |       ["not ticked", false],
 55 |       ["hyperlink", "https://elixir-lang.org/"]
 56 |     ]
 57 | 
 58 |     assert {:ok, rows} = WorksheetParser.parse(sheet_xml, workbook)
 59 | 
 60 |     assert expected == rows
 61 |   end
 62 | 
 63 |   test "returns raw values (except shared strings) when type conversion is disabled", %{
 64 |     workbook: workbook
 65 |   } do
 66 |     sheet_xml = TestFixtures.read!("package/xl/worksheets/sheet3.xml")
 67 | 
 68 |     expected = [
 69 |       ["", ""],
 70 |       ["date", "43784"],
 71 |       ["datetime", "43793.462650462963"],
 72 |       ["time", "1462.781388888889"],
 73 |       ["percentage", "0.125"],
 74 |       ["money chf", "100"],
 75 |       ["money usd", "9999,99 USD"],
 76 |       ["ticked", "1"],
 77 |       ["not ticked", "0"],
 78 |       ["hyperlink", "https://elixir-lang.org/"]
 79 |     ]
 80 | 
 81 |     assert {:ok, rows} = WorksheetParser.parse(sheet_xml, workbook, type_conversion: false)
 82 | 
 83 |     assert expected == rows
 84 |   end
 85 | 
 86 |   test "handles correctly empty values", %{workbook: workbook} do
 87 |     sheet_xml = TestFixtures.read!("package/xl/worksheets/sheet5.xml")
 88 | 
 89 |     assert {:ok, [["", "", "Hello", "", "0.0"]]} =
 90 |              WorksheetParser.parse(sheet_xml, workbook, type_conversion: false)
 91 |   end
 92 | 
 93 |   test "handles inline strings", %{workbook: workbook} do
 94 |     sheet_xml = TestFixtures.read!("xml/worksheetWithInlineStr.xml")
 95 | 
 96 |     expected = [["inline string"]]
 97 | 
 98 |     assert {:ok, rows} = WorksheetParser.parse(sheet_xml, workbook)
 99 | 
100 |     assert expected == rows
101 |   end
102 | 
103 |   test "should ignore rows based on skip_row?", %{
104 |     workbook: workbook
105 |   } do
106 |     sheet_xml = TestFixtures.read!("package/xl/worksheets/sheet4.xml")
107 | 
108 |     ignore_trimmed = fn row -> Enum.all?(row, &(String.trim(&1) == "")) end
109 | 
110 |     assert {:ok, rows} = WorksheetParser.parse(sheet_xml, workbook, skip_row?: ignore_trimmed)
111 |     assert [["-", "-", "-", "-"]] == rows
112 | 
113 |     ignore_trimmed_or_dashes = fn row -> ignore_trimmed.(row) or Enum.all?(row, &(&1 == "-")) end
114 | 
115 |     assert {:ok, rows} =
116 |              WorksheetParser.parse(sheet_xml, workbook, skip_row?: ignore_trimmed_or_dashes)
117 | 
118 |     assert [] == rows
119 |   end
120 | 
121 |   test "should return cell structs instead of values when cell_data_format is :cell" do
122 |     {:ok, package} = XlsxReader.open(TestFixtures.path("has_formulas.xlsx"))
123 |     {:ok, sheets} = XlsxReader.sheets(package, cell_data_format: :cell)
124 | 
125 |     expected = [
126 |       {"sheet_1",
127 |        [
128 |          [
129 |            %Cell{value: "abc", formula: nil, ref: "A1"},
130 |            %Cell{value: 123.0, formula: nil, ref: "B1"}
131 |          ]
132 |        ]},
133 |       {"sheet_2",
134 |        [
135 |          [
136 |            %Cell{value: "def", formula: nil, ref: "A1"},
137 |            %Cell{value: 456.0, formula: nil, ref: "B1"},
138 |            "",
139 |            %Cell{value: 466.0, formula: "SUM(B1, 10)", ref: "D1"}
140 |          ]
141 |        ]}
142 |     ]
143 | 
144 |     assert expected == sheets
145 |   end
146 | 
147 |   test "should return shared formulas as part of Cell struct", %{workbook: workbook} do
148 |     sheet_xml =
149 |       TestFixtures.read!("xml/worksheetWithSharedFormulas.xml")
150 |       |> String.replace("\n", "")
151 |       |> String.replace("\t", "")
152 | 
153 |     expected = [
154 |       [
155 |         %XlsxReader.Cell{value: "1", formula: nil, ref: "A1"},
156 |         %XlsxReader.Cell{value: "6", formula: "SUM(A1:A3)", ref: "B1"}
157 |       ],
158 |       [
159 |         %XlsxReader.Cell{value: "2", formula: nil, ref: "A2"},
160 |         %XlsxReader.Cell{value: "6", formula: "SUM(A1:A3)", ref: "B2"}
161 |       ],
162 |       [
163 |         %XlsxReader.Cell{value: "3", formula: nil, ref: "A3"},
164 |         %XlsxReader.Cell{value: "6", formula: "SUM(A1:A3)", ref: "B3"}
165 |       ]
166 |     ]
167 | 
168 |     assert {:ok, expected} == WorksheetParser.parse(sheet_xml, workbook, cell_data_format: :cell)
169 |   end
170 | 
171 |   test "should include or exclude hidden sheets based on an option" do
172 |     filepath = TestFixtures.path("hidden_sheets.xlsx")
173 | 
174 |     {:ok, package} = XlsxReader.open(filepath, exclude_hidden_sheets?: false)
175 |     all_sheet_names = package |> XlsxReader.sheet_names()
176 |     assert all_sheet_names == ["Sheet 1", "Sheet 2", "Sheet 3"]
177 | 
178 |     {:ok, package} = XlsxReader.open(filepath, exclude_hidden_sheets?: true)
179 |     visible_sheet_names = package |> XlsxReader.sheet_names()
180 |     assert visible_sheet_names == ["Sheet 1"]
181 |   end
182 | end
183 | 


--------------------------------------------------------------------------------
/test/xlsx_reader/styles_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.StylesTest do
 2 |   use ExUnit.Case
 3 | 
 4 |   alias XlsxReader.Styles
 5 | 
 6 |   describe "get_style_type/2" do
 7 |     test "some known styles" do
 8 |       assert :number == Styles.get_style_type("0", %{})
 9 |       assert :number == Styles.get_style_type("1", %{})
10 |       assert :number == Styles.get_style_type("2", %{})
11 |       assert :percentage == Styles.get_style_type("9", %{})
12 |       assert :date == Styles.get_style_type("14", %{})
13 |       assert :time == Styles.get_style_type("18", %{})
14 |       assert :unsupported == Styles.get_style_type("49", %{})
15 |     end
16 | 
17 |     test "supported custom formats" do
18 |       assert :percentage = Styles.get_style_type("123", %{"123" => "0.0%"})
19 | 
20 |       # ISO8601 date/time
21 |       assert :date = Styles.get_style_type("123", %{"123" => "yyyy-mm-dd"})
22 |       assert :date_time = Styles.get_style_type("123", %{"123" => "yyyy-mm-dd hh:mm:ss"})
23 |       assert :date_time = Styles.get_style_type("123", %{"123" => "yyyy-mm-ddThh:mm:ssZ"})
24 | 
25 |       # US date/time
26 |       assert :date = Styles.get_style_type("123", %{"123" => "m/d/yyyy"})
27 |       assert :date_time = Styles.get_style_type("123", %{"123" => "m/d/yyyy h:mm"})
28 | 
29 |       # Plain time
30 |       assert :time = Styles.get_style_type("123", %{"123" => "hh:mm"})
31 |     end
32 | 
33 |     test "user-provided supported custom formats" do
34 |       assert :date == Styles.get_style_type("123", %{"123" => "mmm yy"}, [{"mmm yy", :date}])
35 |       assert :date == Styles.get_style_type("123", %{"123" => "mmm yy"}, [{~r/mmm? yy/, :date}])
36 |     end
37 | 
38 |     test "unknown format" do
39 |       assert nil == Styles.get_style_type("123", %{"456" => "0.0%"})
40 |       assert nil == Styles.get_style_type("123", %{"123" => "bogus"})
41 |       assert nil == Styles.get_style_type("123", %{"123" => "bogus"}, [{"mmm yy", :date}])
42 |     end
43 |   end
44 | end
45 | 


--------------------------------------------------------------------------------
/test/xlsx_reader/zip_archive_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule XlsxReader.ZipArchiveTest do
 2 |   use ExUnit.Case
 3 | 
 4 |   alias XlsxReader.ZipArchive
 5 | 
 6 |   describe "list/1" do
 7 |     test "lists the contents of a zip file" do
 8 |       zip_handle = ZipArchive.handle(TestFixtures.path("test.zip"), :path)
 9 | 
10 |       assert {:ok, ["dir/subdir/file3.bin", "file1.txt", "file2.dat"]} =
11 |                ZipArchive.list(zip_handle)
12 |     end
13 | 
14 |     test "lists the contents of a zip buffer" do
15 |       zip_handle = ZipArchive.handle(TestFixtures.read!("test.zip"), :binary)
16 | 
17 |       assert {:ok, ["dir/subdir/file3.bin", "file1.txt", "file2.dat"]} =
18 |                ZipArchive.list(zip_handle)
19 |     end
20 | 
21 |     test "invalid zip file" do
22 |       zip_handle = ZipArchive.handle(TestFixtures.path("not_a_zip.zip"), :path)
23 | 
24 |       assert {:error, "invalid zip file"} = ZipArchive.list(zip_handle)
25 |     end
26 | 
27 |     test "zip file not found" do
28 |       zip_handle = ZipArchive.handle("__does_not_exist__", :path)
29 | 
30 |       assert {:error, "file not found"} = ZipArchive.list(zip_handle)
31 |     end
32 |   end
33 | 
34 |   describe "extract/2" do
35 |     test "extracts a file from a zip file" do
36 |       zip_handle = ZipArchive.handle(TestFixtures.path("test.zip"), :path)
37 | 
38 |       assert {:ok, "Contents of file1\n"} = ZipArchive.extract(zip_handle, "file1.txt")
39 |       assert {:ok, "Contents of file2\n"} = ZipArchive.extract(zip_handle, "file2.dat")
40 |       assert {:ok, "Contents of file3\n"} = ZipArchive.extract(zip_handle, "dir/subdir/file3.bin")
41 | 
42 |       assert {:error, "file \"bogus.bin\" not found in archive"} =
43 |                ZipArchive.extract(zip_handle, "bogus.bin")
44 |     end
45 | 
46 |     test "extracts a file from zip buffer" do
47 |       zip_handle = ZipArchive.handle(TestFixtures.path("test.zip"), :path)
48 | 
49 |       assert {:ok, "Contents of file1\n"} = ZipArchive.extract(zip_handle, "file1.txt")
50 |       assert {:ok, "Contents of file2\n"} = ZipArchive.extract(zip_handle, "file2.dat")
51 |       assert {:ok, "Contents of file3\n"} = ZipArchive.extract(zip_handle, "dir/subdir/file3.bin")
52 | 
53 |       assert {:error, "file \"bogus.bin\" not found in archive"} =
54 |                ZipArchive.extract(zip_handle, "bogus.bin")
55 |     end
56 | 
57 |     test "invalid zip file" do
58 |       zip_handle = ZipArchive.handle(TestFixtures.path("not_a_zip.zip"), :path)
59 | 
60 |       assert {:error, "invalid zip file"} = ZipArchive.extract(zip_handle, "file1.txt")
61 |     end
62 | 
63 |     test "zip file not found" do
64 |       zip_handle = ZipArchive.handle("__does_not_exist__", :path)
65 | 
66 |       assert {:error, "file not found"} = ZipArchive.extract(zip_handle, "file1.txt")
67 |     end
68 |   end
69 | end
70 | 


--------------------------------------------------------------------------------
/test/xlsx_reader_test.exs:
--------------------------------------------------------------------------------
  1 | defmodule XlsxReaderTest do
  2 |   use ExUnit.Case
  3 | 
  4 |   test "README install version check" do
  5 |     app = :xlsx_reader
  6 | 
  7 |     app_version = "#{Application.spec(app, :vsn)}"
  8 |     readme = File.read!("README.md")
  9 |     [_, readme_versions] = Regex.run(~r/{:#{app}, "(.+)"}/, readme)
 10 | 
 11 |     assert Version.match?(
 12 |              app_version,
 13 |              readme_versions
 14 |            ),
 15 |            """
 16 |            Install version constraint in README.md does not match to current app version.
 17 |            Current App Version: #{app_version}
 18 |            Readme Install Versions: #{readme_versions}
 19 |            """
 20 |   end
 21 | 
 22 |   describe "open/2" do
 23 |     test "opens a xlsx file from the file system" do
 24 |       xlsx = TestFixtures.path("test.xlsx")
 25 | 
 26 |       assert {:ok, %XlsxReader.Package{}} = XlsxReader.open(xlsx)
 27 |       assert {:ok, %XlsxReader.Package{}} = XlsxReader.open(xlsx, source: :path)
 28 |     end
 29 | 
 30 |     test "open a xlsx file from memory" do
 31 |       xlsx = TestFixtures.read!("test.xlsx")
 32 | 
 33 |       assert {:ok, %XlsxReader.Package{}} = XlsxReader.open(xlsx, source: :binary)
 34 |     end
 35 | 
 36 |     test "rejects non-xlsx file" do
 37 |       xlsx = TestFixtures.path("test.zip")
 38 | 
 39 |       assert {:error, "invalid xlsx file"} = XlsxReader.open(xlsx)
 40 |     end
 41 | 
 42 |     test "rejects non-zip file" do
 43 |       xlsx = TestFixtures.path("not_a_zip.zip")
 44 | 
 45 |       assert {:error, "invalid zip file"} = XlsxReader.open(xlsx)
 46 |     end
 47 | 
 48 |     test "rejects relative and absolute path to directory" do
 49 |       relative_path = "test"
 50 |       absolute_path = Path.absname(relative_path)
 51 | 
 52 |       assert {:error, "invalid zip file"} = XlsxReader.open(relative_path)
 53 |       assert {:error, "invalid zip file"} = XlsxReader.open(absolute_path)
 54 |     end
 55 | 
 56 |     test "supported custom formats" do
 57 |       xlsx = TestFixtures.path("test.xlsx")
 58 | 
 59 |       assert {:ok, package} =
 60 |                XlsxReader.open(xlsx,
 61 |                  supported_custom_formats: [
 62 |                    {"[$CHF]0.00", :string}
 63 |                  ]
 64 |                )
 65 | 
 66 |       {:ok, sheet} = XlsxReader.sheet(package, "Sheet 3")
 67 | 
 68 |       assert [
 69 |                ["", _],
 70 |                ["date", _],
 71 |                ["datetime", _],
 72 |                ["time", _],
 73 |                ["percentage", _],
 74 |                ["money chf", "100"],
 75 |                ["money usd", _],
 76 |                ["ticked", _],
 77 |                ["not ticked", _],
 78 |                ["hyperlink", _]
 79 |              ] = sheet
 80 |     end
 81 |   end
 82 | 
 83 |   describe "sheet_names/1" do
 84 |     setup do
 85 |       {:ok, package} = XlsxReader.open(TestFixtures.path("test.xlsx"))
 86 | 
 87 |       {:ok, %{package: package}}
 88 |     end
 89 | 
 90 |     test "lists the sheets in workbook", %{package: package} do
 91 |       assert ["Sheet 1", "Sheet 2", "Sheet 3"] == XlsxReader.sheet_names(package)
 92 |     end
 93 |   end
 94 | 
 95 |   describe "sheet/3" do
 96 |     setup do
 97 |       {:ok, package} = XlsxReader.open(TestFixtures.path("test.xlsx"))
 98 | 
 99 |       {:ok, %{package: package}}
100 |     end
101 | 
102 |     test "returns the contents of the sheet by name", %{package: package} do
103 |       assert {:ok,
104 |               [
105 |                 ["A", "B", "C" | _],
106 |                 [1.0, 2.0, 3.0 | _]
107 |                 | _
108 |               ]} = XlsxReader.sheet(package, "Sheet 1")
109 |     end
110 | 
111 |     test "type conversion off", %{package: package} do
112 |       assert {:ok,
113 |               [
114 |                 _,
115 |                 ["date", "43784"]
116 |                 | _
117 |               ]} = XlsxReader.sheet(package, "Sheet 3", type_conversion: false)
118 |     end
119 | 
120 |     test "number type", %{package: package} do
121 |       assert {:ok,
122 |               [
123 |                 ["A", "B", "C" | _],
124 |                 [
125 |                   %Decimal{coef: 1, exp: 0, sign: 1},
126 |                   %Decimal{coef: 2, exp: 0, sign: 1},
127 |                   %Decimal{coef: 3, exp: 0, sign: 1} | _
128 |                 ]
129 |                 | _
130 |               ]} = XlsxReader.sheet(package, "Sheet 1", number_type: Decimal)
131 |     end
132 | 
133 |     test "custom blank value", %{package: package} do
134 |       assert {:ok,
135 |               [
136 |                 ["n/a", "n/a"]
137 |                 | _
138 |               ]} = XlsxReader.sheet(package, "Sheet 3", blank_value: "n/a")
139 |     end
140 | 
141 |     test "skip empty rows", %{package: package} do
142 |       assert {:ok,
143 |               [
144 |                 ["date" | _]
145 |                 | _
146 |               ]} = XlsxReader.sheet(package, "Sheet 3", empty_rows: false)
147 |     end
148 |   end
149 | 
150 |   describe "sheets/2" do
151 |     setup do
152 |       {:ok, package} = XlsxReader.open(TestFixtures.path("test.xlsx"))
153 | 
154 |       {:ok, %{package: package}}
155 |     end
156 | 
157 |     test "load all sheets", %{package: package} do
158 |       assert {:ok,
159 |               [
160 |                 {"Sheet 1", [["A", "B", "C" | _] | _]},
161 |                 {"Sheet 2", [["", "", "", "", ""] | _]},
162 |                 {"Sheet 3", [["", ""] | _]}
163 |               ]} = XlsxReader.sheets(package)
164 |     end
165 | 
166 |     test "filters sheets", %{package: package} do
167 |       assert {:ok,
168 |               [
169 |                 {"Sheet 1", _},
170 |                 {"Sheet 3", _}
171 |               ]} = XlsxReader.sheets(package, only: ["Sheet 1", "Sheet 3"])
172 | 
173 |       assert {:ok,
174 |               [
175 |                 {"Sheet 1", _},
176 |                 {"Sheet 3", _}
177 |               ]} = XlsxReader.sheets(package, only: [~r/Sheet [13]/])
178 | 
179 |       assert {:ok,
180 |               [
181 |                 {"Sheet 1", _},
182 |                 {"Sheet 3", _}
183 |               ]} = XlsxReader.sheets(package, except: "Sheet 2")
184 | 
185 |       assert {:ok,
186 |               [
187 |                 {"Sheet 1", _},
188 |                 {"Sheet 3", _}
189 |               ]} = XlsxReader.sheets(package, only: ~r/Sheet \d+/, except: ["Sheet 2"])
190 |     end
191 |   end
192 | 
193 |   describe "async_sheets/3" do
194 |     setup do
195 |       {:ok, package} = XlsxReader.open(TestFixtures.path("test.xlsx"))
196 | 
197 |       {:ok, %{package: package}}
198 |     end
199 | 
200 |     test "load all sheets", %{package: package} do
201 |       assert {:ok,
202 |               [
203 |                 {"Sheet 1", [["A", "B", "C" | _] | _]},
204 |                 {"Sheet 2", [["", "", "", "", ""] | _]},
205 |                 {"Sheet 3", [["", ""] | _]}
206 |               ]} = XlsxReader.async_sheets(package)
207 |     end
208 | 
209 |     test "filters sheets", %{package: package} do
210 |       assert {:ok,
211 |               [
212 |                 {"Sheet 1", _},
213 |                 {"Sheet 3", _}
214 |               ]} = XlsxReader.async_sheets(package, only: ["Sheet 1", "Sheet 3"])
215 | 
216 |       assert {:ok,
217 |               [
218 |                 {"Sheet 1", _},
219 |                 {"Sheet 3", _}
220 |               ]} = XlsxReader.async_sheets(package, only: [~r/Sheet [13]/])
221 | 
222 |       assert {:ok,
223 |               [
224 |                 {"Sheet 1", _},
225 |                 {"Sheet 3", _}
226 |               ]} = XlsxReader.async_sheets(package, except: "Sheet 2")
227 | 
228 |       assert {:ok,
229 |               [
230 |                 {"Sheet 1", _},
231 |                 {"Sheet 3", _}
232 |               ]} = XlsxReader.async_sheets(package, only: ~r/Sheet \d+/, except: ["Sheet 2"])
233 |     end
234 |   end
235 | end
236 | 


--------------------------------------------------------------------------------