├── .gitignore
├── .travis.yml
├── LICENSE
├── README.md
├── composer.json
├── docs
    ├── blade.md
    ├── blade
    │   ├── load-view.md
    │   ├── styling.md
    │   └── vars.md
    ├── borders.md
    ├── changelog.md
    ├── changelog
    │   ├── version-1.md
    │   └── version-2.md
    ├── export.md
    ├── export
    │   ├── array.md
    │   ├── autofilter.md
    │   ├── autosize.md
    │   ├── call.md
    │   ├── cells.md
    │   ├── export.md
    │   ├── format.md
    │   ├── freeze.md
    │   ├── injection.md
    │   ├── merge.md
    │   ├── rows.md
    │   ├── sheet-styling.md
    │   ├── sheets.md
    │   ├── simple.md
    │   ├── sizing.md
    │   └── store.md
    ├── formats.md
    ├── getting-started.md
    ├── getting-started
    │   ├── config.md
    │   ├── contributing.md
    │   ├── installation.md
    │   ├── license.md
    │   └── requirements.md
    ├── import.md
    ├── import
    │   ├── basics.md
    │   ├── batch.md
    │   ├── cache.md
    │   ├── calculation.md
    │   ├── chunk.md
    │   ├── config.md
    │   ├── convert.md
    │   ├── dates.md
    │   ├── edit.md
    │   ├── extra.md
    │   ├── formatting.md
    │   ├── injection.md
    │   ├── results.md
    │   └── select.md
    ├── merge.md
    ├── reference-guide.md
    └── reference-guide
    │   ├── borders.md
    │   ├── closures.md
    │   ├── css-styles.md
    │   ├── file-properties.md
    │   ├── formatting.md
    │   └── sheet-properties.md
├── phpunit.xml
├── provides.json
├── src
    ├── Maatwebsite
    │   └── Excel
    │   │   ├── Classes
    │   │       ├── Cache.php
    │   │       ├── FormatIdentifier.php
    │   │       ├── LaravelExcelWorksheet.php
    │   │       └── PHPExcel.php
    │   │   ├── Collections
    │   │       ├── CellCollection.php
    │   │       ├── ExcelCollection.php
    │   │       ├── RowCollection.php
    │   │       └── SheetCollection.php
    │   │   ├── Excel.php
    │   │   ├── ExcelServiceProvider.php
    │   │   ├── Exceptions
    │   │       └── LaravelExcelException.php
    │   │   ├── Facades
    │   │       └── Excel.php
    │   │   ├── Files
    │   │       ├── ExcelFile.php
    │   │       ├── ExportHandler.php
    │   │       ├── File.php
    │   │       ├── ImportHandler.php
    │   │       └── NewExcelFile.php
    │   │   ├── Filters
    │   │       └── ChunkReadFilter.php
    │   │   ├── Parsers
    │   │       ├── CssParser.php
    │   │       ├── ExcelParser.php
    │   │       └── ViewParser.php
    │   │   ├── Readers
    │   │       ├── Batch.php
    │   │       ├── ConfigReader.php
    │   │       ├── HtmlReader.php
    │   │       └── LaravelExcelReader.php
    │   │   └── Writers
    │   │       ├── CellWriter.php
    │   │       └── LaravelExcelWriter.php
    └── config
    │   └── excel.php
└── tests
    ├── .gitkeep
    ├── Collections
        └── CellCollectionTest.php
    ├── Excel
        ├── ExcelTestCase.php
        └── ExcelTester.php
    ├── Files
        ├── CsvExcelFileTest.php
        ├── ExcelFileTest.php
        ├── NewExcelFileTest.php
        ├── classes
        │   ├── CsvTestImport.php
        │   ├── TestExport.php
        │   ├── TestExportHandler.php
        │   ├── TestImport.php
        │   └── TestImportHandler.php
        └── files
        │   ├── test-custom.csv
        │   └── test.csv
    ├── Filters
        ├── ChunkReadFilterTest.php
        ├── RegisterFilterTestCase.php
        └── files
        │   ├── multi.xls
        │   ├── sample.csv
        │   ├── sample.xls
        │   └── sample.xlsx
    ├── Readers
        ├── ChineseXlsReaderTest.php
        ├── CsvReaderTest.php
        ├── CustomValueBinderTest.php
        ├── MultipleSheetsXlsReaderTest.php
        ├── ReaderTest.php
        ├── XlsReaderTest.php
        ├── XlsxReaderTest.php
        ├── ZerosHandlingReaderTest.php
        ├── files
        │   ├── chinese.xls
        │   ├── customBinder.csv
        │   ├── multiple.xls
        │   ├── test.csv
        │   ├── test.xls
        │   ├── test.xlsx
        │   └── zeros.xls
        └── traits
        │   ├── ImportTrait.php
        │   └── SingleImportTestingTrait.php
    ├── TestCase.php
    ├── TestConfig.php
    ├── TestServiceProvider.php
    └── Writers
        ├── ExcelWriterTest.php
        └── exports
            └── .gitignore


/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor
2 | composer.phar
3 | composer.lock
4 | .DS_Store


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php:
 4 |   - 5.4
 5 |   - 5.5
 6 |   - 5.6
 7 | 
 8 | before_script:
 9 |   - travis_retry composer self-update
10 |   - travis_retry composer install --prefer-source --no-interaction
11 | 
12 | script: phpunit
13 | 
14 | matrix:
15 |   allow_failures:
16 |     - php: hhvm
17 |   fast_finish: true


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## Laravel Excel v2.0.0 for Laravel 5
 2 | 
 3 | Looking for Laravel Excel for Laravel 4? Visit the [`1.3` branch](https://github.com/Maatwebsite/Laravel-Excel/tree/1.3)
 4 | 
 5 | [<img src="http://www.maatwebsite.nl/img/excel_banner.jpg"/>](http://www.maatwebsite.nl/laravel-excel/docs)
 6 | [<img src="https://cloud.githubusercontent.com/assets/7728097/6332170/1b495af2-bb84-11e4-9a93-34a9abc01840.jpg"/>](http://www.maatwebsite.nl/vacature-php-programmeur-maastricht)
 7 | 
 8 | Laravel Excel brings the power of PHPOffice's PHPExcel to Laravel 5 with a touch of the Laravel Magic. It includes features like: importing Excel and CSV to collections, exporting models, array's and views to Excel, importing batches of files and importing a file by a config file.
 9 | 
10 | - Import into Laravel **Collections**
11 | - Export **Blade views** to Excel and CSV with optional CSS styling
12 | - **Batch** imports
13 | - A lot of optional **config settings**
14 | - Easy **cell caching**
15 | - Chunked importer
16 | - ExcelFile method injections
17 | - Editing existing Excel files
18 | - **Advanced import** by config files
19 | - and many more...
20 | 
21 | ---
22 | 
23 | ```php
24 | Excel::create('Laravel Excel', function($excel) {
25 | 
26 |     $excel->sheet('Excel sheet', function($sheet) {
27 | 
28 |         $sheet->setOrientation('landscape');
29 | 
30 |     });
31 | 
32 | })->export('xls');
33 | ```
34 | 
35 | ---
36 | 
37 | [![Build Status](https://travis-ci.org/Maatwebsite/Laravel-Excel.svg?branch=master)](https://travis-ci.org/Maatwebsite/Laravel-Excel)
38 | [![Latest Stable Version](https://poser.pugx.org/maatwebsite/excel/v/stable.png)](https://packagist.org/packages/maatwebsite/excel) [![Total Downloads](https://poser.pugx.org/maatwebsite/excel/downloads.png)](https://packagist.org/packages/maatwebsite/excel)  [![License](https://poser.pugx.org/maatwebsite/excel/license.png)](https://packagist.org/packages/maatwebsite/excel)
39 | [![Monthly Downloads](https://poser.pugx.org/maatwebsite/excel/d/monthly.png)](https://packagist.org/packages/maatwebsite/excel)
40 | [![Daily Downloads](https://poser.pugx.org/maatwebsite/excel/d/daily.png)](https://packagist.org/packages/maatwebsite/excel)
41 | 
42 | #Installation
43 | 
44 | Require this package in your `composer.json` and update composer. This will download the package and PHPExcel of PHPOffice.
45 | 
46 | ```php
47 | "maatwebsite/excel": "~2.0.0"
48 | ```
49 | 
50 | After updating composer, add the ServiceProvider to the providers array in `config/app.php`
51 | 
52 | ```php
53 | 'Maatwebsite\Excel\ExcelServiceProvider',
54 | ```
55 | 
56 | You can use the facade for shorter code. Add this to your aliases:
57 | 
58 | ```php
59 | 'Excel' => 'Maatwebsite\Excel\Facades\Excel',
60 | ```
61 | 
62 | The class is bound to the ioC as `excel`
63 | 
64 | ```php
65 | $excel = App::make('excel');
66 | ```
67 | 
68 | To publish the config settings in Laravel 5 use:
69 | 
70 | ```php
71 | php artisan vendor:publish
72 | ```
73 | 
74 | This will add an `excel.php` config file to your config folder.
75 | 
76 | # Documentation
77 | 
78 | The complete documentation can be found at: [http://www.maatwebsite.nl/laravel-excel/docs](http://www.maatwebsite.nl/laravel-excel/docs)
79 | 
80 | # Contributing
81 | 
82 | **ALL** bug fixes should be made to appropriate branch (e.g. `2.0` for 2.0.* bug fixes). Bug fixes should never be sent to the `master` branch.
83 | 
84 | More about contributing can be found at: [http://www.maatwebsite.nl/laravel-excel/docs/getting-started#contributing](http://www.maatwebsite.nl/laravel-excel/docs/getting-started#contributing)
85 | 
86 | # License
87 | 
88 | This package is licensed under LGPL. You are free to use it in personal and commercial projects. The code can be forked and modified, but the original copyright author should always be included!
89 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "maatwebsite/excel",
 3 |   "description": "An eloquent way of importing and exporting Excel and CSV in Laravel 4 with the power of PHPExcel",
 4 |   "license": "LGPL",
 5 |   "keywords": [
 6 |     "laravel",
 7 |     "phpexcel",
 8 |     "excel",
 9 |     "csv",
10 |     "export",
11 |     "import",
12 |     "batch"
13 |   ],
14 |   "authors": [
15 |     {
16 |       "name": "Maatwebsite.nl",
17 |       "email": "patrick@maatwebsite.nl"
18 |     }
19 |   ],
20 |   "require": {
21 |     "php": ">=5.3.0",
22 |     "phpoffice/phpexcel": "~1.8.0",
23 |     "illuminate/cache": "~5.0",
24 |     "illuminate/config": "~5.0",
25 |     "illuminate/filesystem": "~5.0",
26 |     "illuminate/support": "~5.0",
27 |     "nesbot/carbon": "~1.0",
28 |     "tijsverkoyen/css-to-inline-styles": "~1.5"
29 |   },
30 |   "require-dev": {
31 |     "phpseclib/phpseclib": ">=0.3.7",
32 |     "phpunit/phpunit": "~4.0",
33 |     "mockery/mockery": "~0.9",
34 |     "orchestra/testbench": "~3.0.0"
35 |   },
36 |   "suggest": {
37 |     "illuminate/http": "~5.0",
38 |     "illuminate/routing": "~5.0",
39 |     "illuminate/view": "~5.0"
40 |   },
41 |   "autoload": {
42 |     "classmap": [
43 |       "src/Maatwebsite/Excel",
44 |       "tests/TestCase.php"
45 |     ],
46 |     "psr-0": {
47 |       "Maatwebsite\\Excel\\": "src/"
48 |     }
49 |   }
50 | }
51 | 


--------------------------------------------------------------------------------
/docs/blade.md:
--------------------------------------------------------------------------------
1 | @include:Loading a view|load-view
2 | @include:Passing variables|vars
3 | @include:Styling sheets|styling


--------------------------------------------------------------------------------
/docs/blade/load-view.md:
--------------------------------------------------------------------------------
 1 | # @Blade to Excel
 2 | 
 3 | We can utilise the magic of Laravel's Blade engine to power our Excel export. Sharing a view, loading a view per sheet, creating a html table inside a view, basic CSS styling, ...
 4 | 
 5 | # Loading a view for a single sheet
 6 | 
 7 | We can load a view for every sheet we create with `->loadView()`.
 8 | 
 9 |     Excel::create('New file', function($excel) {
10 | 
11 |         $excel->sheet('New sheet', function($sheet) {
12 | 
13 |             $sheet->loadView('folder.view');
14 | 
15 |         });
16 | 
17 |     });
18 | 
19 | # Using different views for different sheets
20 | 
21 |     Excel::create('New file', function($excel) {
22 | 
23 |         $excel->sheet('First sheet', function($sheet) {
24 | 
25 |             $sheet->loadView('view_first');
26 |         });
27 | 
28 |         $excel->sheet('Second sheet', function($sheet) {
29 | 
30 |             $sheet->loadView('view_second');
31 |         });
32 | 
33 |     });
34 | 
35 | # Sharing a view for all sheets
36 | 
37 | We can share a view for all sheets with `shareView()`.
38 | 
39 |     Excel::shareView('folder.view')->create();
40 | 
41 | # Unsetting a view for a sheet
42 | 
43 | When we are using a shared view, but we don't want to use a view for the current sheet, we can use `->unsetView()`.
44 | 
45 |     $sheet->unsetView();


--------------------------------------------------------------------------------
/docs/blade/styling.md:
--------------------------------------------------------------------------------
  1 | # Styling sheets
  2 | 
  3 | ### General styling
  4 | 
  5 | If you want to change the general styling of your sheet (not cell or range specific), you can use the `->setStyle()` method or any of the other setters which can be found inside the export documentation.
  6 | 
  7 |     // Font family
  8 |     $sheet->setFontFamily('Comic Sans MS');
  9 | 
 10 |     // Set font with ->setStyle()`
 11 |     $sheet->setStyle(array(
 12 |         'font' => array(
 13 |             'name'      =>  'Calibri',
 14 |             'size'      =>  12,
 15 |             'bold'      =>  true
 16 |         )
 17 |     ));
 18 | 
 19 | ### Styling with PHPExcel methods
 20 | 
 21 | It's possible to style the sheets and specific cells with help of PHPExcel methods. This package includes a lot of shortcuts (see export documentation), but also always the use of the native methods.
 22 | 
 23 |     // Set background color for a specific cell
 24 |     $sheet->getStyle('A1')->applyFromArray(array(
 25 |         'fill' => array(
 26 |             'type'  => PHPExcel_Style_Fill::FILL_SOLID,
 27 |             'color' => array('rgb' => 'FF0000')
 28 |         )
 29 |     ));
 30 | 
 31 | ### Using HTML tags
 32 | 
 33 | Most of the HTML tags are supported.
 34 | 
 35 |     <html>
 36 | 
 37 |         <!-- Headings -->
 38 |         <td><h1>Big title</h1></td>
 39 | 
 40 |         <!--  Bold -->
 41 |         <td><b>Bold cell</b></td>
 42 |         <td><strong>Bold cell</strong></td>
 43 | 
 44 |         <!-- Italic -->
 45 |         <td><i>Italic cell</i></td>
 46 | 
 47 |         <!-- Images -->
 48 |         <td><img src="img.jpg" /></td>
 49 | 
 50 |     </html>
 51 | 
 52 | > Inside the `view.php` config you can change how these tags will be interpreted by Excel by default.
 53 | 
 54 | ### Using HTML attributes
 55 | 
 56 | Some of the basic styling can be done with HTML attributes.
 57 | 
 58 |     <html>
 59 | 
 60 |         <!-- Horizontal alignment -->
 61 |         <td align="right">Big title</td>
 62 | 
 63 |         <!--  Vertical alignment -->
 64 |         <td valign="middle">Bold cell</td>
 65 | 
 66 |         <!-- Rowspan -->
 67 |         <td rowspan="3">Bold cell</td>
 68 | 
 69 |         <!-- Colspan -->
 70 |         <td colspan="6">Italic cell</td>
 71 | 
 72 |         <!-- Width -->
 73 |         <td width="100">Cell with width of 100</td>
 74 | 
 75 |         <!-- Height -->
 76 |         <td height="100">Cell with height of 100</td>
 77 | 
 78 |     </html>
 79 | 
 80 | ### Styling through inline-styles
 81 | 
 82 | It's possible to use inline styles inside your view files. Most of the general styles are supported.
 83 | 
 84 |     <html>
 85 | 
 86 |         <!-- Cell with black background -->
 87 |         <td style="background-color: #000000;">Cell</td>
 88 | 
 89 |     </html>
 90 | 
 91 | > Inside the reference guide you can find a list of supported styles.
 92 | 
 93 | ### Styling through external CSS file
 94 | 
 95 | Styling can be done through an external CSS file.
 96 | 
 97 | External css file:
 98 | 
 99 |     #cell {
100 |         background-color: #000000;
101 |         color: #ffffff;
102 |     }
103 | 
104 |     .cell {
105 |         background-color: #000000;
106 |         color: #ffffff;
107 |     }
108 | 
109 |     tr td {
110 |         background-color: #ffffff;
111 |     }
112 | 
113 |     tr > td {
114 |         border-bottom: 1px solid #000000;
115 |     }
116 | 
117 | Table:
118 | 
119 |     <html>
120 | 
121 |         {{ HTML::style('css/table.css') }}
122 | 
123 |         <!-- Cell styled with class -->
124 |         <td class="cell">Cell</td>
125 | 
126 |         <!-- Cell styled with ID -->
127 |         <td id="cell">Cell</td>
128 | 
129 |     </html>
130 | 
131 | > Inside the reference guide you can find a list of supported styles.
132 | 
133 | > It's advised to include `<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />` into the view to fix problems with UTF-8 encoding.


--------------------------------------------------------------------------------
/docs/blade/vars.md:
--------------------------------------------------------------------------------
 1 | # Passing variables to the view
 2 | 
 3 | ### As parameter
 4 | 
 5 | We can pass variables to the view by using the second parameter inside the `loadView()` method.
 6 | 
 7 | 	$sheet->loadView('view', array('key' => 'value'));
 8 | 
 9 | ### With with()
10 | 
11 | Alternatively you can use the `with()` method which works the same as with Laravel views.
12 | 
13 | 	// Using normal with()
14 | 	$sheet->loadView('view')
15 | 		  ->with('key', 'value');
16 | 
17 | 	// using dynamic with()
18 | 	$sheet->loadView('view')
19 | 		  ->withKey('value');


--------------------------------------------------------------------------------
/docs/borders.md:
--------------------------------------------------------------------------------
 1 | PHPExcel_Style_Border::BORDER_NONE = 'none'
 2 | PHPExcel_Style_Border::BORDER_DASHDOT = 'dashDot'
 3 | PHPExcel_Style_Border::BORDER_DASHDOTDOT = 'dashDotDot'
 4 | PHPExcel_Style_Border::BORDER_DASHED = 'dashed'
 5 | PHPExcel_Style_Border::BORDER_DOTTED = 'dotted'
 6 | PHPExcel_Style_Border::BORDER_DOUBLE = 'double'
 7 | PHPExcel_Style_Border::BORDER_HAIR = 'hair'
 8 | PHPExcel_Style_Border::BORDER_MEDIUM = 'medium'
 9 | PHPExcel_Style_Border::BORDER_MEDIUMDASHDOT = 'mediumDashDot'
10 | PHPExcel_Style_Border::BORDER_MEDIUMDASHDOTDOT = 'mediumDashDotDot'
11 | PHPExcel_Style_Border::BORDER_MEDIUMDASHED = 'mediumDashed'
12 | PHPExcel_Style_Border::BORDER_SLANTDASHDOT = 'slantDashDot'
13 | PHPExcel_Style_Border::BORDER_THICK = 'thick'
14 | PHPExcel_Style_Border::BORDER_THIN = 'thin'


--------------------------------------------------------------------------------
/docs/changelog.md:
--------------------------------------------------------------------------------
1 | @include:Version 1|version-1
2 | @include:Version 2|version-2
3 | 


--------------------------------------------------------------------------------
/docs/changelog/version-1.md:
--------------------------------------------------------------------------------
  1 | # Version 1
  2 | 
  3 | ### 1.3.5
  4 | - PHPExcel 1.8.1 compatibility
  5 | - Clean-up ServiceProvider
  6 | - Fix short array syntax for PHP5.3
  7 | 
  8 | ### 1.3.4
  9 | - Fix usage of sheet callback when modifying an existing file
 10 | - Modifying existing files improvements (support style overriding)
 11 | - Add text-indent support to HtmlReader
 12 | - Add simple sheet password protection
 13 | - Add support for exporting multiple pdf pages
 14 | - Add inline cell formatting to blade
 15 | 
 16 | ### 1.3.3
 17 | - Fix issue with different start row in chunk filter
 18 | 
 19 | ### 1.3.2
 20 | - Custom value binders
 21 | - Html reader update
 22 | 
 23 | ### 1.3.1
 24 | - Fix short array syntax
 25 | 
 26 | ### 1.3.0
 27 | - Additional headers with export() 
 28 | - Float, integer, string, timestamps problems
 29 | - Cell content ending by zeros
 30 | - Images in html
 31 | - Font family bug
 32 | - Setting row number of row with headings
 33 | 
 34 | ### 1.2.3
 35 | - PDF writer
 36 | - Include charts config
 37 | - Chunk filter with selected sheet
 38 | - Compatibility fix with new PHPExcel release
 39 | - setDateColumns fix
 40 | - Optional dependencies to require-dev
 41 | - Several bugfixes
 42 | 
 43 | ### 1.2.2
 44 | - Chunk filter fixes
 45 | - Isset() CellCollection fixes
 46 | - PHP 5.3 support
 47 | - Missing border styles
 48 | - Add CSV settings (delimiter, enclosure, lineEnding) to ExcelFile objects
 49 | 
 50 | ### 1.2.1
 51 | - Fix with() method parameters
 52 | 
 53 | ### 1.2.0
 54 | - Filters
 55 | - Chunk filter (with chunked importer)
 56 | - ExcelFile (method) injections
 57 | - NewExcelFile (method) injections
 58 | - Edit existing worksheets
 59 | - Converting existing worksheet
 60 | - Laravel 4.* + 5.0 support
 61 | 
 62 | ### 1.1.9
 63 | - PHP 5.3 fixes
 64 | 
 65 | ### 1.1.8
 66 | - PHP 5.3 support
 67 | - fromArray bugfix
 68 | 
 69 | ### 1.1.7
 70 | - Fix heading generation for export with `->fromArray()`
 71 | - Bugfix for non-Unix kernels
 72 | - Enhanced CSS parser (thanks to `tijsverkoyen/CssToInlineStyles`)
 73 | - Support for nested CSS styles
 74 | - Support for multiple css attributes per class
 75 | - Support for internal and external CSS files
 76 | - Support for inline style blocks (`<style>`)
 77 | 
 78 | ### 1.1.6
 79 | 
 80 | - Provides.json fix
 81 | - DocBlock fixes
 82 | - Define Illuminate dependencies inside composer.json
 83 | - Better HTML rowspan handling views
 84 | - use new CellCollection() instead of ::make, to support upcoming Laravel version
 85 | - Workaround for long integers
 86 | - Add support to `wrap-text` in views
 87 | - Fix empty dates parsing
 88 | - Support local stylesheets in view parsing
 89 | - Push tr classes to td-children in views
 90 | - Support for dynamically appending rows to an empty (new) sheet
 91 | - Fix separator typo in config
 92 | 
 93 | ### 1.1.5
 94 | 
 95 | - Select sheets by index with `Excel::selectSheetsByIndex(0,1)->load(...)`
 96 | - Separator typo fix
 97 | - Added `->setFileName()` method
 98 | - Use `->setTitle()` only for workbook title not for setting the filename anymore
 99 | - Made `setAutoSize()` chainable for other sheet methods
100 | - Export config setting to disable pre calculation of formulas during export
101 | - Export config setting to set the autosizing method (approx|exact)
102 | - Auto sizing export from view fix
103 | 
104 | ### 1.1.4
105 | 
106 | - Fix for importing 0 as null
107 | - New unit tests
108 | 
109 | ### 1.1.3
110 | 
111 | - Cell writer `->setBorder()` fix
112 | 
113 | ### 1.1.2
114 | 
115 | - Fix for multiple imports on one pageload
116 | - Multiple new import heading conversions (`Config: excel::import.heading: true|false|slugged|ascii|numeric|hashed|trans|original`)
117 | 
118 | ### 1.1.1
119 | 
120 | - Retrieve workbook and sheet title during import (`->getTitle()`)
121 | 
122 | ### 1.1.0
123 | 
124 | - `Limit()`, `skip()` and `take()` support for fetching results
125 | - Set default page margins
126 | - Export Eloquent models directly (`fromModel()`)
127 | - Auto generate the first row (table heading) from the array keys
128 | - Manipulate cells and cell ranges inside a closure
129 | - Set cell backgrounds/fonts/values, ...
130 | - Create/append/prepend new row/rows
131 | - Manipulate row cells (background, fonts, ...)
132 | - Config value default alignment on merge cells
133 | - DocBlock updates to support better use of IDE autocomplete features
134 | - Parse width and height inside views
135 | - Parse images in views
136 | - Optional to ASCII conversion of imported header columns (array indices)
137 | - Config values for default null comparision and start cells for exports
138 | - Changed default CSV enclosure to `"`
139 | - Support for Laravel package installer
140 | 
141 | ### 1.0.9
142 | 
143 | - Blade to Excel export fix for PHP5.3
144 | 
145 | ### 1.0.8
146 | 
147 | - File format identifier enhancements
148 | 
149 | ### 1.0.7
150 | 
151 | - Set workbook properties fix
152 | - Extra units tests
153 | 
154 | ### 1.0.6
155 | 
156 | - BatchReader fix
157 | 
158 | ### 1.0.5
159 | 
160 | - Date parsing fix
161 | 
162 | ### 1.0.4
163 | 
164 | - Fix calling $this in  anonymous function to set locale and cache
165 | 
166 | ### 1.0.3
167 | 
168 | - Table headings to attribute names undefined offset fix
169 | - Composer.json enhancements
170 | - Documentation fixes
171 | 
172 | ### 1.0.2
173 | 
174 | - Cell Collection fixes
175 | - Default autosizing bugfixes
176 | - ->load() accepts input encoding parameter
177 | - Documentation fixes
178 | 
179 | ### 1.0.1
180 | 
181 | - Column width and row height bugfix
182 | - Typo fixes
183 | 
184 | ### 1.0.0
185 | 
186 | - New documentation
187 | - More logical file structure (dividing into files, separating the different functionality (import / export)
188 | - More optional config settings
189 | - CSV Delimiter fixes
190 | - CSV Encoding
191 | - Import into collections (to support utilisation of ->first(), etc.)
192 | - Better column selecting and result limiting
193 | - Batch upload
194 | - Import dates as Carbon objects by default
195 | - Advanced file import through config coordinates
196 | - Select sheets to import
197 | - Create closure (Excel::create('file', function($excel) { } ))
198 | - More logical syntax for creating new files, syntaxes of creating by array and creating with view should be as identical as possible
199 | - Rewrite of sheet building for views
200 | - Using closures to build sheets for normal sheet creation
201 | - Better support for calling native PHPExcel methods
202 | - Better use of setters
203 | - Config setting to set default store behavior
204 | - Column/row width
205 | - Share views over all sheets + easy views switching per sheet
206 | - External stylesheet with classes/ids parsing for views
207 | - Colspan fix
208 | - Th default styling
209 | - Caching / Cell caching
210 | 


--------------------------------------------------------------------------------
/docs/changelog/version-2.md:
--------------------------------------------------------------------------------
 1 | # Version 2
 2 | 
 3 | ### 2.0.4
 4 | - PHPExcel 1.8.1 compatibility
 5 | - Clean-up ServiceProvider
 6 | 
 7 | ### 2.0.3
 8 | - Fix usage of sheet callback when modifying an existing file
 9 | - Modifying existing files improvements (support style overriding)
10 | - Add text-indent support to HtmlReader
11 | - Add simple sheet password protection
12 | - Add support for exporting multiple pdf pages
13 | - Add inline cell formatting to blade
14 | 
15 | ### 2.0.2
16 | - Fix issue with different start row in chunk filter
17 | 
18 | ### 2.0.1
19 | - Custom value binders
20 | - Html reader update
21 | 
22 | ### 2.0.0
23 | - Laravel 5 release
24 | 


--------------------------------------------------------------------------------
/docs/export.md:
--------------------------------------------------------------------------------
 1 | @include:Creating a new file|simple
 2 | @include:Exporting|export
 3 | @include:NewExcelFile injections|injection
 4 | @include:Store to server|store
 5 | @include:Creating Sheets|sheets
 6 | @include:Creatings Sheets From array|array
 7 | @include:Row manipulation|rows
 8 | @include:Cell manipulation|cells
 9 | @include:Sheet styling|sheet-styling
10 | @include:Freeze rows|freeze
11 | @include:Auto filter|autofilter
12 | @include:Cell sizing|sizing
13 | @include:Auto size|autosize
14 | @include:Column merging|merge
15 | @include:Column formatting|format
16 | @include:PHPExcel methods|call


--------------------------------------------------------------------------------
/docs/export/array.md:
--------------------------------------------------------------------------------
 1 | # Creating a sheet from an array
 2 | 
 3 | ## Array
 4 | 
 5 | To create a new file from an array use `->fromArray($source, $nullValue, $startCell, $strictNullComparison, $headingGeneration)` inside the sheet closure.
 6 | 
 7 |     Excel::create('Filename', function($excel) {
 8 | 
 9 |         $excel->sheet('Sheetname', function($sheet) {
10 | 
11 |             $sheet->fromArray(array(
12 |                 array('data1', 'data2'),
13 |                 array('data3', 'data4')
14 |             ));
15 | 
16 |         });
17 | 
18 |     })->export('xls');
19 | 
20 | Alternatively you can use `->with()`.
21 | 
22 |     $sheet->with(array(
23 |         array('data1', 'data2'),
24 |         array('data3', 'data4')
25 |     ));
26 | 
27 | If you want to pass variables inside the closure, use `use($data)`
28 | 
29 |     $data = array(
30 |         array('data1', 'data2'),
31 |         array('data3', 'data4')
32 |     );
33 | 
34 |     Excel::create('Filename', function($excel) use($data) {
35 | 
36 |         $excel->sheet('Sheetname', function($sheet) use($data) {
37 | 
38 |             $sheet->fromArray($data);
39 | 
40 |         });
41 | 
42 |     })->export('xls');
43 | 
44 | ### Null comparision
45 | 
46 | By default 0 is shown as an empty cell. If you want to change this behaviour, you can pass true as 4th parameter:
47 | 
48 |     // Will show 0 as 0
49 |     $sheet->fromArray($data, null, 'A1', true);
50 | 
51 | >> To change the default behaviour, you can use `excel::export.sheets.strictNullComparison` config setting.
52 | 
53 | ## Eloquent model
54 | 
55 | It's also possible to pass an Eloquent model and export it by using `->fromModel($model)`. The method accepts the same parameters as fromArray
56 | 
57 | ## Auto heading generation
58 | 
59 | By default the export will use the keys of your array (or model attribute names) as first row (header column). To change this behaviour you can edit the default config setting (`excel::export.generate_heading_by_indices`) or pass `false` as 5th parameter:
60 | 
61 |     // Won't auto generate heading columns
62 |     $sheet->fromArray($data, null, 'A1', false, false);


--------------------------------------------------------------------------------
/docs/export/autofilter.md:
--------------------------------------------------------------------------------
1 | # Auto filter
2 | 
3 | To enable the auto filter use `->setAutoFilter($range = false)`.
4 | 
5 |     // Auto filter for entire sheet
6 |     $sheet->setAutoFilter();
7 | 
8 |     // Set auto filter for a range
9 |     $sheet->setAutoFilter('A1:E10');


--------------------------------------------------------------------------------
/docs/export/autosize.md:
--------------------------------------------------------------------------------
 1 | # Auto size
 2 | 
 3 | By default the exported file be automatically auto sized. To change this behaviour you can either change the config or use the setters:
 4 | 
 5 |     // Set auto size for sheet
 6 |     $sheet->setAutoSize(true);
 7 | 
 8 |     // Disable auto size for sheet
 9 |     $sheet->setAutoSize(false);
10 | 
11 |     // Disable auto size for columns
12 |     $sheet->setAutoSize(array(
13 |         'A', 'C'
14 |     ));
15 | 
16 | > The default config setting can be found in: `export.php`.


--------------------------------------------------------------------------------
/docs/export/call.md:
--------------------------------------------------------------------------------
 1 | # Calling PHPExcel's native methods
 2 | 
 3 | It's possible to call all native PHPExcel methods on the `$excel` and `$sheet` objects.
 4 | 
 5 | ### Calling Workbook methods
 6 | 
 7 | Example:
 8 | 
 9 |     // Get default style for this workbook
10 |     $excel->getDefaultStyle();
11 | 
12 | ### Calling worksheet methods
13 | 
14 | Example:
15 | 
16 |     // Protect cells
17 |     $sheet->protectCells('A1', $password);
18 | 
19 | > Head over to PHPOffice to learn more about the native methods.


--------------------------------------------------------------------------------
/docs/export/cells.md:
--------------------------------------------------------------------------------
 1 | # Cell manipulation
 2 | 
 3 |     $sheet->cell('A1', function($cell) {
 4 | 
 5 |         // manipulate the cell
 6 | 
 7 |     });
 8 | 
 9 |     $sheet->cells('A1:A5', function($cells) {
10 | 
11 |         // manipulate the range of cells
12 | 
13 |     });
14 | 
15 | ### Set background
16 | 
17 | To change the background of a range of cells we can use `->setBackground($color, $type, $colorType)`
18 | 
19 |     // Set black background
20 |     $cells->setBackground('#000000');
21 | 
22 | ### Change fonts
23 | 
24 |     // Set with font color
25 |     $cells->setFontColor('#ffffff');
26 | 
27 |     // Set font family
28 |     $cells->setFontFamily('Calibri');
29 | 
30 |     // Set font size
31 |     $cells->setFontSize(16);
32 | 
33 |     // Set font weight to bold
34 |     $cells->setFontWeight('bold');
35 | 
36 |     // Set font
37 |     $cells->setFont(array(
38 |         'family'     => 'Calibri',
39 |         'size'       => '16',
40 |         'bold'       =>  true
41 |     ));
42 | 
43 | ### Set borders
44 | 
45 |     // Set all borders (top, right, bottom, left)
46 |     $cells->setBorder('solid', 'none', 'none', 'solid');
47 | 
48 |     // Set borders with array
49 |     $cells->setBorder(array(
50 |         'borders' => array(
51 |             'top'   => array(
52 |                 'style' => 'solid'
53 |             ),
54 |         )
55 |     ));
56 | 
57 | ### Set horizontal alignment
58 | 
59 |     // Set alignment to center
60 |     $cells->setAlignment('center');
61 | 
62 | ### Set vertical alignment
63 | 
64 |     // Set vertical alignment to middle
65 |      $cells->setValignment('middle');


--------------------------------------------------------------------------------
/docs/export/export.md:
--------------------------------------------------------------------------------
 1 | # Exporting
 2 | 
 3 | To download the created file, use `->export($ext)` or `->download($ext)`.
 4 | 
 5 | #### Export to Excel5 (xls)
 6 | 
 7 |     Excel::create('Filename', function($excel) {
 8 | 
 9 |     })->export('xls');
10 | 
11 |     // or
12 |     ->download('xls');
13 | 
14 | #### Export to Excel2007 (xlsx)
15 | 
16 |     ->export('xlsx');
17 | 
18 |     // or
19 |     ->download('xlsx');
20 | 
21 | #### Export to CSV
22 | 
23 |     ->export('csv');
24 | 
25 |     // or
26 |     ->download('csv');
27 | 
28 | > You can set the default enclosure and delimiter inside the config
29 | 
30 | #### Export to PDF
31 | 
32 | To export files to pdf, you will have to include `"dompdf/dompdf": "~0.6.1"`, `"mpdf/mpdf": "~5.7.3"` or `"tecnick.com/tcpdf": "~6.0.0"` in your `composer.json` and change the `export.pdf.driver` config setting accordingly.
33 | 
34 |     ->export('pdf');


--------------------------------------------------------------------------------
/docs/export/format.md:
--------------------------------------------------------------------------------
 1 | # Column formatting
 2 | 
 3 | To tell Excel how it should interpret certain columns, you can use `->setColumnFormat($array)`.
 4 | 
 5 |     // Format column as percentage
 6 |     $sheet->setColumnFormat(array(
 7 |         'C' => '0%'
 8 |     ));
 9 |     
10 |     // Format a range with e.g. leading zeros
11 |     $sheet->setColumnFormat(array(
12 |         'A2:K2' => '0000'
13 |     ));
14 | 
15 |     // Set multiple column formats
16 |     $sheet->setColumnFormat(array(
17 |         'B' => '0',
18 |         'D' => '0.00',
19 |         'F' => '@',
20 |         'F' => 'yyyy-mm-dd',
21 |     ));
22 | 
23 | > Go to the reference guide to see a list of available formats.
24 | 


--------------------------------------------------------------------------------
/docs/export/freeze.md:
--------------------------------------------------------------------------------
 1 | # Freeze rows
 2 | 
 3 | If you want to freeze a cell, row or column, use:
 4 | 
 5 |     // Freeze first row
 6 |     $sheet->freezeFirstRow();
 7 | 
 8 |     // Freeze the first column
 9 |     $sheet->freezeFirstColumn();
10 | 
11 |     // Freeze the first row and column
12 |     $sheet->freezeFirstRowAndColumn();
13 | 
14 |     // Set freeze
15 |     $sheet->setFreeze('A2');


--------------------------------------------------------------------------------
/docs/export/injection.md:
--------------------------------------------------------------------------------
 1 | # NewExcelFile injections
 2 | 
 3 | Following the Laravel 5.0 philosophy with its new awesome FormRequest injections, we introduce you NewExcelFile injections.
 4 | 
 5 | ## NewExcelFile class
 6 | 
 7 | This NewExcelFile is a wrapper for a new Excel file. Inside the `getFilename()` you can declare the wanted filename.
 8 | 
 9 |     class UserListExport extends \Maatwebsite\Excel\Files\NewExcelFile {
10 | 
11 |         public function getFilename()
12 |         {
13 |             return 'filename';
14 |         }
15 |     }
16 | 
17 | ## Usage
18 | 
19 | You can inject these NewExcelFiles inside the __constructor or inside the method (when using Laravel 5.0), in e.g. the controller.
20 | 
21 |     class ExampleController extends Controller {
22 | 
23 |         public function exportUserList(UserListExport $export)
24 |         {
25 |             // work on the export
26 |             return $export->sheet('sheetName', function($sheet)
27 |             {
28 | 
29 |             })->export('xls');
30 |         }
31 | 
32 |     }
33 | 
34 | ## Export Handlers
35 | 
36 | To decouple your Excel-export code completely from the controller, you can use the export handlers.
37 | 
38 |     class ExampleController extends Controller {
39 | 
40 |         public function exportUserList(UserListExport $export)
41 |         {
42 |             // Handle the export
43 |             $export->handleExport();
44 |         }
45 | 
46 |     }
47 | 
48 | The `handleExport()` method will dynamically call a handler class which is your class name appended with `Handler`
49 | 
50 |     class UserListExportHandler implements \Maatwebsite\Excel\Files\ExportHandler {
51 | 
52 |         public function handle(UserListExport $export)
53 |         {
54 |             // work on the export
55 |             return $export->sheet('sheetName', function($sheet)
56 |             {
57 | 
58 |             })->export('xls');
59 |         }
60 | 
61 |     }
62 | 


--------------------------------------------------------------------------------
/docs/export/merge.md:
--------------------------------------------------------------------------------
 1 | # Column merging
 2 | 
 3 | ### Merging cells
 4 | 
 5 | To merge a range of cells, use `->mergeCells($range)`.
 6 | 
 7 |     $sheet->mergeCells('A1:E1');
 8 | 
 9 | ### Merging columns and rows
10 | 
11 | To merge columns and rows, use `->setMergeColumn($array)`.
12 | 
13 |     $sheet->setMergeColumn(array(
14 |         'columns' => array('A','B','C','D'),
15 |         'rows' => array(
16 |             array(2,3),
17 |             array(5,11),
18 |         )
19 |     ));


--------------------------------------------------------------------------------
/docs/export/rows.md:
--------------------------------------------------------------------------------
 1 | # Row manipulation
 2 | 
 3 | ### Manipulate certain row
 4 | 
 5 | #### Change cell values
 6 | 
 7 |     // Manipulate first row
 8 |     $sheet->row(1, array(
 9 |          'test1', 'test2'
10 |     ));
11 | 
12 |     // Manipulate 2nd row
13 |     $sheet->row(2, array(
14 |         'test3', 'test4'
15 |     ));
16 | 
17 | #### Manipulate row cells
18 | 
19 |     // Set black background
20 |     $sheet->row(1, function($row) {
21 | 
22 |         // call cell manipulation methods
23 |         $row->setBackground('#000000');
24 | 
25 |     });
26 | 
27 | ### Append row
28 | 
29 |     // Append row after row 2
30 |     $sheet->appendRow(2, array(
31 |         'appended', 'appended'
32 |     ));
33 | 
34 |     // Append row as very last
35 |     $sheet->appendRow(array(
36 |         'appended', 'appended'
37 |     ));
38 | 
39 | ### Prepend row
40 | 
41 |     // Add before first row
42 |     $sheet->prependRow(1, array(
43 |         'prepended', 'prepended'
44 |     ));
45 | 
46 |     // Add as very first
47 |     $sheet->prependRow(array(
48 |         'prepended', 'prepended'
49 |     ));
50 | 
51 | ### Append multiple rows
52 | 
53 |     // Append multiple rows
54 |     $sheet->rows(array(
55 |         array('test1', 'test2'),
56 |         array('test3', 'test4')
57 |     ));
58 | 
59 |     // Append multiple rows
60 |     $sheet->rows(array(
61 |         array('test5', 'test6'),
62 |         array('test7', 'test8')
63 |     ));


--------------------------------------------------------------------------------
/docs/export/sheet-styling.md:
--------------------------------------------------------------------------------
 1 | # Sheet styling
 2 | 
 3 | ### General styling
 4 | 
 5 | If you want to change the general styling of your sheet (not cell or range specific), you can use the `->setStyle()` method.
 6 | 
 7 |     // Set font with ->setStyle()`
 8 |     $sheet->setStyle(array(
 9 |         'font' => array(
10 |             'name'      =>  'Calibri',
11 |             'size'      =>  15,
12 |             'bold'      =>  true
13 |         )
14 |     ));
15 | 
16 | ### Fonts
17 | 
18 | To change the font for the current sheet use `->setFont($array)`:
19 | 
20 |     $sheet->setFont(array(
21 |         'family'     => 'Calibri',
22 |         'size'       => '15',
23 |         'bold'       => true
24 |     ));
25 | 
26 | #### Separate setters
27 | 
28 |     // Font family
29 |     $sheet->setFontFamily('Comic Sans MS');
30 | 
31 |     // Font size
32 |     $sheet->setFontSize(15);
33 | 
34 |     // Font bold
35 |     $sheet->setFontBold(true);
36 | 
37 | ### Borders
38 | 
39 | You can set borders for the sheet, by using:
40 | 
41 |     // Sets all borders
42 |     $sheet->setAllBorders('thin');
43 | 
44 |     // Set border for cells
45 |     $sheet->setBorder('A1', 'thin');
46 | 
47 |     // Set border for range
48 |     $sheet->setBorder('A1:F10', 'thin');
49 | 
50 | > Go to the reference guide to see a list of available border styles


--------------------------------------------------------------------------------
/docs/export/sheets.md:
--------------------------------------------------------------------------------
 1 | # Sheets
 2 | 
 3 | ### Creating a sheet
 4 | 
 5 | To create a new sheet inside our newly created file, use `->sheet('Sheetname')`.
 6 | 
 7 |     Excel::create('Filename', function($excel) {
 8 | 
 9 |         $excel->sheet('Sheetname', function($sheet) {
10 | 
11 |             // Sheet manipulation
12 | 
13 |         });
14 | 
15 |     })->export('xls');
16 | 
17 | 
18 | ### Creating multiple sheets
19 | 
20 | You can set as many sheets as you like inside the file:
21 | 
22 |     Excel::create('Filename', function($excel) {
23 | 
24 |         // Our first sheet
25 |         $excel->sheet('First sheet', function($sheet) {
26 | 
27 |         });
28 | 
29 |         // Our second sheet
30 |         $excel->sheet('Second sheet', function($sheet) {
31 | 
32 |         });
33 | 
34 |     })->export('xls');
35 | 
36 | ### Changing properties
37 | 
38 | There are a couple of properties we can change inside the closure. Most of them are set to the config values by default. See `app/config/packages/maatwebsite/excel/config.php`.
39 | 
40 |     Excel::create('Filename', function($excel) {
41 | 
42 |         $excel->sheet('Sheetname', function($sheet) {
43 | 
44 |             $sheet->setOrientation('landscape');
45 | 
46 |         });
47 | 
48 |     })->export('xls');
49 | 
50 | > Go to the reference guide to see a list of available properties.
51 | 
52 | ### Default page margin
53 | 
54 | It's possible to set the default page margin inside the config file `excel::export.sheets`.
55 | It accepts boolean, single value or array.
56 | 
57 | To manually set the page margin you can use: `->setPageMargin()`
58 | 
59 |     // Set top, right, bottom, left
60 |     $sheet->setPageMargin(array(
61 |         0.25, 0.30, 0.25, 0.30
62 |     ));
63 | 
64 |     // Set all margins
65 |     $sheet->setPageMargin(0.25);
66 |     
67 | ### Password protecting a sheet
68 |     
69 | A sheet can be password protected with `$sheet->protect()`:
70 | 
71 |     // Default protect
72 |     $sheet->protect('password');
73 |     
74 |     // Advanced protect
75 |     $sheet->protect('password', function(\PHPExcel_Worksheet_Protection $protection) {
76 |         $protection->setSort(true);
77 |     });
78 | 


--------------------------------------------------------------------------------
/docs/export/simple.md:
--------------------------------------------------------------------------------
 1 | # Simple Excel Export
 2 | 
 3 | ### Basics
 4 | 
 5 | A new file can be created using the `create` method with the filename as first parameter.
 6 | 
 7 |     Excel::create('Filename');
 8 | 
 9 | To manipulate the creation of the file you can use the callback
10 | 
11 |     Excel::create('Filename', function($excel) {
12 | 
13 |         // Call writer methods here
14 | 
15 |     });
16 | 
17 | ### Changing properties
18 | 
19 | There are a couple of properties we can change inside the closure. Most of them are set to the config values by default. See `app/config/packages/maatwebsite/excel/config.php`.
20 | 
21 |     Excel::create('Filename', function($excel) {
22 | 
23 |         // Set the title
24 |         $excel->setTitle('Our new awesome title');
25 | 
26 |         // Chain the setters
27 |         $excel->setCreator('Maatwebsite')
28 |               ->setCompany('Maatwebsite');
29 | 
30 |         // Call them separately
31 |         $excel->setDescription('A demonstration to change the file properties');
32 | 
33 |     });
34 | 
35 | > Go to the reference guide to see a list of available properties.


--------------------------------------------------------------------------------
/docs/export/sizing.md:
--------------------------------------------------------------------------------
 1 | # Cell size
 2 | 
 3 | ### Set column width
 4 | 
 5 | To set the column width use `->setWidth($cell, $width)`.
 6 | 
 7 |     // Set width for a single column
 8 |     $sheet->setWidth('A', 5);
 9 | 
10 |     // Set width for multiple cells
11 |     $sheet->setWidth(array(
12 |         'A'     =>  5,
13 |         'B'     =>  10
14 |     ));
15 | 
16 | ### Set row height
17 | 
18 | To set the row height use `->setHeight($row, $height)`.
19 | 
20 |     // Set height for a single row
21 |     $sheet->setHeight(1, 50);
22 | 
23 |     // Set height for multiple rows
24 |     $sheet->setHeight(array(
25 |         1     =>  50,
26 |         2     =>  25
27 |     ));
28 | 
29 | ### Set cell size
30 | 
31 | To set the cell size use `->setSize($cell, $width, $height)`.
32 | 
33 |     // Set size for a single cell
34 |     $sheet->setSize('A1', 500, 50);
35 | 
36 |     $sheet->setSize(array(
37 |         'A1' => array(
38 |             'width'     => 50
39 |             'height'    => 500,
40 |         )
41 |     ));


--------------------------------------------------------------------------------
/docs/export/store.md:
--------------------------------------------------------------------------------
 1 | # Store on server
 2 | 
 3 | To store the created file on the server, use `->store($ext, $path = false, $returnInfo = false)` or `->save()`.
 4 | 
 5 | ### Normal export to default storage path
 6 | 
 7 | By default the file will be stored inside the `app/storage/exports` folder, which has been defined in the `export.php` config file.
 8 | 
 9 |     Excel::create('Filename', function($excel) {
10 | 
11 |         // Set sheets
12 | 
13 |     })->store('xls');
14 | 
15 | ### Normal export to custom storage path
16 | 
17 | If you want to use a custom storage path (e.g. to separate the files per client), you can set the folder as the second parameter.
18 | 
19 |     ->store('xls', storage_path('excel/exports'));
20 | 
21 | ### Store and export
22 | 
23 |     ->store('xls')->export('xls');
24 | 
25 | ### Store and return storage info
26 | 
27 | If you want to return storage information, set the third paramter to true or change the config setting inside `export.php`.
28 | 
29 |     ->store('xls', false, true);
30 | 
31 | |Key|Explanation|
32 | |---|-----------|
33 | |**full**| Full path with filename
34 | |**path**| Path without filename
35 | |**file**| Filename
36 | |**title**| File title
37 | |**ext**| File extension
38 | 
39 | > Make sure your storage folder is **writable**!


--------------------------------------------------------------------------------
/docs/formats.md:
--------------------------------------------------------------------------------
 1 | PHPExcel_Style_NumberFormat::FORMAT_GENERAL = 'General'
 2 | PHPExcel_Style_NumberFormat::FORMAT_TEXT = '@'
 3 | PHPExcel_Style_NumberFormat::FORMAT_NUMBER = '0'
 4 | PHPExcel_Style_NumberFormat::FORMAT_NUMBER_00 = '0.00'
 5 | PHPExcel_Style_NumberFormat::FORMAT_NUMBER_COMMA_SEPARATED1 = '#,##0.00'
 6 | PHPExcel_Style_NumberFormat::FORMAT_NUMBER_COMMA_SEPARATED2 = '#,##0.00_-'
 7 | PHPExcel_Style_NumberFormat::FORMAT_PERCENTAGE = '0%'
 8 | PHPExcel_Style_NumberFormat::FORMAT_PERCENTAGE_00 = '0.00%'
 9 | PHPExcel_Style_NumberFormat::FORMAT_DATE_YYYYMMDD2 = 'yyyy-mm-dd'
10 | PHPExcel_Style_NumberFormat::FORMAT_DATE_YYYYMMDD = 'yy-mm-dd'
11 | PHPExcel_Style_NumberFormat::FORMAT_DATE_DDMMYYYY = 'dd/mm/yy'
12 | PHPExcel_Style_NumberFormat::FORMAT_DATE_DMYSLASH = 'd/m/y'
13 | PHPExcel_Style_NumberFormat::FORMAT_DATE_DMYMINUS = 'd-m-y'
14 | PHPExcel_Style_NumberFormat::FORMAT_DATE_DMMINUS = 'd-m'
15 | PHPExcel_Style_NumberFormat::FORMAT_DATE_MYMINUS = 'm-y'
16 | PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX14 = 'mm-dd-yy'
17 | PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX15 = 'd-mmm-yy'
18 | PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX16 = 'd-mmm'
19 | PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX17 = 'mmm-yy'
20 | PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX22 = 'm/d/yy h:mm'
21 | PHPExcel_Style_NumberFormat::FORMAT_DATE_DATETIME = 'd/m/y h:mm'
22 | PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME1 = 'h:mm AM/PM'
23 | PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME2 = 'h:mm:ss AM/PM'
24 | PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME3 = 'h:mm'
25 | PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME4 = 'h:mm:ss'
26 | PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME5 = 'mm:ss'
27 | PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME6 = 'h:mm:ss'
28 | PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME7 = 'i:s.S'
29 | PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME8 = 'h:mm:ss;@'
30 | PHPExcel_Style_NumberFormat::FORMAT_DATE_YYYYMMDDSLASH = 'yy/mm/dd;@'
31 | PHPExcel_Style_NumberFormat::FORMAT_CURRENCY_USD_SIMPLE = '"$"#,##0.00_-'
32 | PHPExcel_Style_NumberFormat::FORMAT_CURRENCY_USD = '$#,##0_-'
33 | PHPExcel_Style_NumberFormat::FORMAT_CURRENCY_EUR_SIMPLE = '[$EUR ]#,##0.00_-'
34 | 
35 | ->setColumnFormat(array(
36 |           'B' => '0',
37 |           'D' => '0.00',
38 |           'F' => '@',
39 |           'F' => 'yyyy-mm-dd',
40 |           ......
41 |       )
42 |   )


--------------------------------------------------------------------------------
/docs/getting-started.md:
--------------------------------------------------------------------------------
1 | @include:Installation|installation
2 | @include:Config|config
3 | @include:Requirements|requirements
4 | @include:Contributing|contributing
5 | @include:License|license


--------------------------------------------------------------------------------
/docs/getting-started/config.md:
--------------------------------------------------------------------------------
 1 | #Config
 2 | 
 3 | ### Laravel 4
 4 | 
 5 | Laravel Excel includes several config settings for import-, export-, view- and CSV-specific settings.
 6 | Use the artisan publish command to publish the config file to your project.
 7 | 
 8 |     php artisan config:publish maatwebsite/excel
 9 | 
10 | The config files can now be found at `app/config/packages/maatwebsite/excel`
11 | 
12 | ### Laravel 5
13 | 
14 | To publish the config settings in Laravel 5 use:
15 | 
16 |     php artisan vendor:publish
17 | 
18 | This will add an `excel.php` config file to your config folder.
19 | 


--------------------------------------------------------------------------------
/docs/getting-started/contributing.md:
--------------------------------------------------------------------------------
 1 | # Contribution Guide
 2 | 
 3 | ### Bug fixes
 4 | 
 5 | **ALL** bug fixes should be made to appropriate branch (e.g. `1.1` for 1.1.* bug fixes). Bug fixes should never be sent to the `master` branch.
 6 | 
 7 | ### Pull Requests
 8 | 
 9 | Every pull request should pass the unit tests. If you include new functionality, make sure you include a test. Pull requests will be evaluated and possibly added to the next stable release.
10 | 
11 | ### Feature Requests
12 | 
13 | If you have an idea for a new feature you would like to see added to Laravel Excel, you may create an issue on GitHub with `[Request]` in the title. The feature request will then be reviewed by @Maatwebsite.
14 | 
15 | ### Coding Guidelines
16 | 
17 | Laravel, and therefore Maatwebsite's Laravel Excel follows the [PSR-0](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md) and [PSR-1](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md) coding standards. In addition to these standards, below is a list of other coding standards that should be followed:
18 | 
19 | - Namespace declarations should be on the same line as `<?php`.
20 | - Class opening `{` should be on the same line as the class name.
21 | - Function and control structure opening `{` should be on a separate line.
22 | - Interface and Trait names are suffixed with `Interface` (`FooInterface`) and `Trait` (`FooTrait`) respectively.
23 | 


--------------------------------------------------------------------------------
/docs/getting-started/installation.md:
--------------------------------------------------------------------------------
 1 | #Installation
 2 | 
 3 | Require this package in your `composer.json` and update composer. This will download the package and PHPExcel of PHPOffice.
 4 | 
 5 |     "maatwebsite/excel": "1.*"
 6 | 
 7 | After updating composer, add the ServiceProvider to the providers array in `app/config/app.php`
 8 | 
 9 |     'Maatwebsite\Excel\ExcelServiceProvider',
10 | 
11 | You can use the facade for shorter code. Add this to your aliasses:
12 | 
13 |     'Excel' => 'Maatwebsite\Excel\Facades\Excel',
14 | 
15 | The class is binded to the ioC as `excel`
16 | 
17 |     $excel = App::make('excel');


--------------------------------------------------------------------------------
/docs/getting-started/license.md:
--------------------------------------------------------------------------------
1 | #License
2 | 
3 | This package is licensed under LGPL. You are free to use it in personal and commercial projects. The code can be forked and modified, but the original copyright author should always be included!
4 | 


--------------------------------------------------------------------------------
/docs/getting-started/requirements.md:
--------------------------------------------------------------------------------
1 | # Requirements
2 | 
3 | - PHP version >= 5.3.7
4 | - Laravel >= 4.1
5 | - PHPOffice PHPExcel >= 1.8.0 (included by composer.json)
6 | - PHP extension php_zip enabled (required if you need PHPExcel to handle .xlsx .ods or .gnumeric files)
7 | - PHP extension php_xml enabled
8 | - PHP extension php_gd2 enabled (optional, but required for exact column width autocalculation)


--------------------------------------------------------------------------------
/docs/import.md:
--------------------------------------------------------------------------------
 1 | @include:Importing a file|basics
 2 | @include:ExcelFile injections|injection
 3 | @include:Handling results|results
 4 | @include:Selecting sheets and columns|select
 5 | @include:Dates|dates
 6 | @include:Calculation|calculation
 7 | @include:Custom formatting values|formatting
 8 | @include:Caching and cell caching|cache
 9 | @include:Chunk importing|chunk
10 | @include:Batch import|batch
11 | @include:Import by config|config
12 | @include:Edit existing files|edit
13 | @include:Converting|convert
14 | @include:Extra|extra


--------------------------------------------------------------------------------
/docs/import/basics.md:
--------------------------------------------------------------------------------
 1 | # Importing a file
 2 | 
 3 | To start importing a file, you can use `->load($filename)`. The callback is optional.
 4 | 
 5 |     Excel::load('file.xls', function($reader) {
 6 | 
 7 |         // reader methods
 8 | 
 9 |     });
10 | 


--------------------------------------------------------------------------------
/docs/import/batch.md:
--------------------------------------------------------------------------------
 1 | #Batch import
 2 | 
 3 | ### Import a folder
 4 | 
 5 | To import an entire folder (only xls, xlsx and csv files will be imported), set the folder as the first parameter.
 6 | 
 7 |     Excel::batch('app/storage/uploads', function($rows, $file) {
 8 | 
 9 |         // Explain the reader how it should interpret each row,
10 |         // for every file inside the batch
11 |         $rows->each(function($row) {
12 | 
13 |             // Example: dump the firstname
14 |             dd($row->firstname);
15 | 
16 |         });
17 | 
18 |     });
19 | 
20 | ### Import multiple files
21 | 
22 | It's also possible to provide an array of files to import.
23 | 
24 |     $files = array(
25 |         'file1.xls',
26 |         'file2.xls'
27 |     );
28 | 
29 |     Excel::batch($files, function($rows, $file) {
30 | 
31 |     });
32 | 
33 | ### Import a folder and multiple sheets
34 | 
35 | When your files contain multiple sheets, you should also loop the sheets
36 | 
37 |     Excel::batch('app/storage/uploads', function($sheets, $file) {
38 | 
39 |         $sheets->each(function($sheet) {
40 | 
41 |         });
42 | 
43 |     });


--------------------------------------------------------------------------------
/docs/import/cache.md:
--------------------------------------------------------------------------------
 1 | # Caching and Cell caching
 2 | 
 3 | ### Cell caching
 4 | 
 5 | You can enable cell caching inside the config `cache.php`. You can choose between a couple of drivers and change a couple of settings. By default the caching is **enabled** and will use **in memory** caching.
 6 | 
 7 | ### Remembering results
 8 | 
 9 | If you want to remember the results you can use `->remember($minutes)`. Next time you will load the same file (if it's still inside the cache), it will return the cached results.
10 | 
11 |     // Remember for 10 minutes
12 |     $results = $reader->remember(10)->get();


--------------------------------------------------------------------------------
/docs/import/calculation.md:
--------------------------------------------------------------------------------
 1 | # Calculate formulas
 2 | 
 3 | By default formulas inside the file are being calculated and it's result will be returned. Inside `import.php` config you can change the default behaviour by setting `calculate` to the desired preference.
 4 | 
 5 | If you want to enable/disable it for a single import, you can use `->calculate($boolean)`
 6 | 
 7 |     // Enable calculation
 8 |     $reader->calculate();
 9 | 
10 |     // Disable calculation
11 |     $reader->calculate(false);
12 | 


--------------------------------------------------------------------------------
/docs/import/chunk.md:
--------------------------------------------------------------------------------
 1 | # Chunk importer
 2 | 
 3 | When dealing with big files, it's better to import the data in big chunks. You can enable this with `filter('chunk')`;
 4 | To import it into chunks you can use `chunk($size, $callback)` instead of the normal `get()`. The first parameter is the size of the chunk. The second parameter is a closure which will return the results.
 5 | 
 6 |     Excel::filter('chunk')->load('file.csv')->chunk(250, function($results)
 7 |     {
 8 |             foreach($results as $row)
 9 |             {
10 |                 // do stuff
11 |             }
12 |     });
13 | 
14 | ## ExcelFile class example:
15 | 
16 | When working with ExcelFile injections (in the constructor or as method injection), you can enable the chunk filter inside the ExcelFile class
17 | 
18 |     class UserListImport extends \Maatwebsite\Excel\Files\ExcelFile {
19 | 
20 |         public function getFile()
21 |         {
22 |             return 'file.csv';
23 |         }
24 | 
25 |         public function getFilters()
26 |         {
27 |             return [
28 |                 'chunk'
29 |             ];
30 |         }
31 | 
32 |     }
33 | 
34 | Injected ExcelFile example:
35 | 
36 |     public function importUserList(UserListImport $import)
37 |     {
38 |         $import->chunk(250, function($results)
39 |         {
40 |             // do stuff
41 |         })
42 |     }
43 | 


--------------------------------------------------------------------------------
/docs/import/config.md:
--------------------------------------------------------------------------------
 1 | # Import by Config
 2 | 
 3 | When using advanced Excel files (e.g. without any heading columns), it can be complicated to import these.
 4 | `->byConfig()` will help you handle this problem.
 5 | 
 6 | Inside `excel::import.sheets` config you can find an example.
 7 | 
 8 |     Excel::load('file.xls')->byConfig('excel::import.sheets', function($sheet) {
 9 | 
10 |         // The firstname getter will correspond with a cell coordinate set inside the config
11 |         $firstname = $sheet->firstname;
12 | 
13 |     });
14 | 
15 | > **Note:** if you are using multiple sheets. `->byConfig` will loop through all sheets. If these getters are only exist on one sheet, you can always use `->selectSheets()`.


--------------------------------------------------------------------------------
/docs/import/convert.md:
--------------------------------------------------------------------------------
1 | # Converting
2 | 
3 | You can convert from one filetype to another by using `->convert()`
4 | 
5 |     Excel::load('file.csv', function($file) {
6 | 
7 |         // modify stuff
8 | 
9 |     })->convert('xls');


--------------------------------------------------------------------------------
/docs/import/dates.md:
--------------------------------------------------------------------------------
 1 | # Dates
 2 | 
 3 | By default the dates will be parsed as a **[Carbon object](https://github.com/briannesbitt/Carbon)**. You can disable date formatting completly inside `import.php` by setting `dates.enabled` to `false`.
 4 | 
 5 | To enable/disable date formatting for a single import, use `->formatDates($boolean, $format)`
 6 | 
 7 |     // Format the dates
 8 |     $reader->formatDates(true);
 9 | 
10 |     // Disable date formatting
11 |     $reader->formatDates(false);
12 | 
13 |     // Format dates + set date format
14 |     $reader->formatDates(true, 'Y-m-d');
15 | 
16 | ### Format dates
17 | 
18 | By default the dates are **not formatted**, but returned as a Carbon object. There are a couple of options to format them.
19 | 
20 | #### Formatting results after ->get()
21 | 
22 | Inside your loop you can utilise the Carbon method `->format($dateFormat)`
23 | 
24 |     $rows->each(function($row) {
25 | 
26 |         $created_at = $row->created_at->format('Y-m-d');
27 | 
28 |     });
29 | 
30 | #### Setting a default date format
31 | 
32 | Inside the config you can set a default date format. A Carbon object will no longer be returned.
33 | 
34 | Or you can use `->setDateFormat()`
35 | 
36 |     $reader->setDateFormat('Y-m-d');
37 | 
38 | ### Setting custom date columns
39 | 
40 | Cells which are not Excel formatted dates will not be parsed as a date. To force this behaviour (or to use this with CSV imports), you can set these date columns manually: `->setDateColumns()`
41 | 
42 |     $reader->setDateColumns(array(
43 |         'created_at',
44 |         'deleted_at'
45 |     ))->get();
46 | 


--------------------------------------------------------------------------------
/docs/import/edit.md:
--------------------------------------------------------------------------------
1 | # Editing existing files
2 | 
3 | You can edit existing Excel files, by loading them and after modication exporting them.
4 | 
5 |     Excel::load('file.csv', function($file) {
6 | 
7 |         // modify stuff
8 | 
9 |     })->export('csv');


--------------------------------------------------------------------------------
/docs/import/extra.md:
--------------------------------------------------------------------------------
 1 | # Extra
 2 | 
 3 | ### Disable using first row as collection attributes
 4 | 
 5 | By default we will use the first row of a file as table heading (so as attribute names for the collection).
 6 | You can change the default behaviour inside `import.php` with `import.heading`.
 7 | 
 8 | To disable this for a single import, use `->noHeading()`.
 9 | 
10 |     $reader->noHeading();
11 | 
12 | ### Setting the cell name separator
13 | By default collection attribute names will be set by looking at the first row columns. Spaces will be translated to `_`.
14 | 
15 | **E.g. Created at -> created_at**
16 | 
17 | The default behaviour can be changed inside the `import.php` config by changing `'separator'`. Or you can use `->setSeparator($separator)`.
18 | 
19 |     $reader->setSeparator('-');
20 | 
21 | ### Ignoring empty cells
22 | By default empty cells will not be ignored and presented as null inside the cell collection.
23 | 
24 | To change the default behaviour, you can change `'ignoreEmpty`' inside `import.php` or use `->ignoreEmpty()`.
25 | 
26 |     $reader->ignoreEmpty();
27 | 
28 | ### Input encoding
29 | 
30 | Inside the `import.php` config you can change the input encoding. In most cases **UTF-8** will be the best solution. Hower if you dump your results make sure your HTML page has this exact same meta charset!
31 | 
32 | Optionally you can pass the input encoding inside the `->load()` method.
33 | 
34 |     // When utilising a closure, you can pass the input encoding as third parameter.
35 |     Excel::load('filename.csv', function($reader) {
36 | 
37 |     }, 'UTF-8');
38 | 
39 |     // or without a closure, you can use it as second parameter.
40 |     Excel::load('filename.csv', 'UTF-8');
41 | 
42 | ### CSV Settings
43 | 
44 | Inside the `csv.php` config you can change the default settings, like the `delimiter`, the `enclosure` and the `line_ending`.
45 | 


--------------------------------------------------------------------------------
/docs/import/formatting.md:
--------------------------------------------------------------------------------
 1 | # Custom formatting values
 2 | 
 3 | By default Laravel Excel uses PHPExcel's default value binder to intelligently format a cells value when reading it. You may override this behavior by passing in your own value binder to suit your specific needs. Value binders must implement PHPExcel_Cell_IValueBinder and have a bindValue method. They may also extend PHPExcel_Cell_DefaultValueBinder to return the default behavior.
 4 |     
 5 |     use PHPExcel_Cell;
 6 |     use PHPExcel_Cell_DataType;
 7 |     use PHPExcel_Cell_IValueBinder;
 8 |     use PHPExcel_Cell_DefaultValueBinder;
 9 | 
10 |     class MyValueBinder extends PHPExcel_Cell_DefaultValueBinder implements PHPExcel_Cell_IValueBinder
11 |     {
12 |         public function bindValue(PHPExcel_Cell $cell, $value = null)
13 |         {
14 |             if (is_numeric($value))
15 |             {
16 |                 $cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_NUMERIC);
17 | 
18 |                 return true;
19 |             }
20 |             
21 |             // else return default behavior
22 |             return parent::bindValue($cell, $value);
23 |         }
24 |     }
25 | 
26 |     $myValueBinder = new MyValueBinder;
27 | 
28 |     Excel::setValueBinder($myValueBinder)->load('file.xls', function($reader) {
29 | 
30 |         // reader methods
31 | 
32 |     });
33 | 
34 | Available PHPExcel_Cell_DataType's are TYPE_STRING, TYPE_FORMULA, TYPE_NUMERIC, TYPE_BOOL, TYPE_NULL, TYPE_INLINE and TYPE_ERROR
35 | 
36 | To reset the value binder back to default and/or before calling Laravel Excel after setting a custom value binder you need to call the resetValueBinder method.
37 | 
38 |     Excel::resetValueBinder();


--------------------------------------------------------------------------------
/docs/import/injection.md:
--------------------------------------------------------------------------------
 1 | # ExcelFile injections
 2 | 
 3 | Following the Laravel 5.0 philosophy with its new awesome FormRequest injections, we introduce you ExcelFile injections.
 4 | 
 5 | ## ExcelFile class
 6 | 
 7 | This class is a wrapper for a file on your server. Inside the `getFile()` method you return the filename and it's location. Inside the `getFilters()` method you can enable filters, like the chunk filter.
 8 | 
 9 |     class UserListImport extends \Maatwebsite\Excel\Files\ExcelFile {
10 | 
11 |         public function getFile()
12 |         {
13 |             return storage_path('exports') . '/file.csv';
14 |         }
15 | 
16 |         public function getFilters()
17 |         {
18 |             return [
19 |                 'chunk'
20 |             ];
21 |         }
22 | 
23 |     }
24 | 
25 | If you want to have the `getFile()` dynamic based on user's input, you can easily do:
26 | 
27 |     public function getFile()
28 |     {
29 |         // Import a user provided file
30 |         $file = Input::file('report');
31 |         $filename = $this->doSomethingLikeUpload($file);
32 | 
33 |         // Return it's location
34 |         return $filename;
35 |     }
36 | 
37 | ## Usage
38 | 
39 | You can inject these ExcelFiles inside the __constructor or inside the method (when using Laravel 5.0), in e.g. the controller.
40 | 
41 |     class ExampleController extends Controller {
42 | 
43 |         public function importUserList(UserListImport $import)
44 |         {
45 |             // get the results
46 |             $results = $import->get();
47 |         }
48 | 
49 |     }
50 | 
51 | ## CSV Settings
52 | 
53 | You can pass through optional CSV settings, like `$delimiter`, `$enclosure` and `$lineEnding` as protected properties of the class.
54 | 
55 |     class UserListImport extends \Maatwebsite\Excel\Files\ExcelFile {
56 | 
57 |         protected $delimiter  = ',';
58 |         protected $enclosure  = '"';
59 |         protected $lineEnding = '\r\n';
60 | 
61 |     }
62 | 
63 | ## Import Handlers
64 | 
65 | To decouple your Excel-import code completely from the controller, you can use the import handlers.
66 | 
67 |     class ExampleController extends Controller {
68 | 
69 |         public function importUserList(UserListImport $import)
70 |         {
71 |             // Handle the import
72 |             $import->handleImport();
73 |         }
74 | 
75 |     }
76 | 
77 | The `handleImport()` method will dynamically call a handler class which is your class name appended with `Handler`
78 | 
79 |     class UserListImportHandler implements \Maatwebsite\Excel\Files\ImportHandler {
80 | 
81 |         public function handle(UserListImport $import)
82 |         {
83 |             // get the results
84 |             $results = $import->get();
85 |         }
86 | 
87 |     }
88 | 


--------------------------------------------------------------------------------
/docs/import/results.md:
--------------------------------------------------------------------------------
  1 | # Handling imported results
  2 | 
  3 | ### Getting all sheets and rows
  4 | 
  5 | After you have loaded a file, you can `->get()` the results like so:
  6 | 
  7 |     Excel::load('file.xls', function($reader) {
  8 | 
  9 |     })->get();
 10 | 
 11 | or
 12 | 
 13 |     Excel::load('file.xls', function($reader) {
 14 | 
 15 |         // Getting all results
 16 |         $results = $reader->get();
 17 | 
 18 |         // ->all() is a wrapper for ->get() and will work the same
 19 |         $results = $reader->all();
 20 | 
 21 |     });
 22 | 
 23 | > The `->get()` and `->all()` methods will return a sheet or row collection, depending on the amount of sheets the file has. You can disable this feature inside the `import.php` config by setting `'force_sheets_collection'` to `true`. When set to true it will always return a sheet collection.
 24 | 
 25 | ### Table heading as attributes
 26 | 
 27 | By default the first row of the excel file will be used as attributes.
 28 | 
 29 |     // Get the firstname
 30 |     $row->firstname;
 31 | 
 32 | > **Note**: by default these attributes will be converted to a slug. You can change the default inside the config `excel::import.heading`. Available options are: `true|false|slugged|ascii|numeric|hashed|trans|original`
 33 | 
 34 | > True and slugged will be converted to ASCII as well when `excel::import.to_ascii` is set to true. You can change the default separator as well inside the config.
 35 | 
 36 | ### Collections
 37 | 
 38 | Sheets, rows and cells are collections, this means after doing a `->get()` you can use all default collection methods.
 39 | 
 40 |     // E.g. group the results
 41 |     $reader->get()->groupBy('firstname');
 42 | 
 43 | ### Getting the first sheet or row
 44 | 
 45 | To get the first sheet or row, you can utilise `->first()`.
 46 | 
 47 |     $reader->first();
 48 | 
 49 | > **Note:** depending on the config `'force_sheets_collection'` it will return the first row or sheet.
 50 | 
 51 | ### Workbook and sheet title
 52 | 
 53 | It's possible to retrieve the workbook and sheet title with `->getTitle()`.
 54 | 
 55 |     // Get workbook title
 56 |     $workbookTitle = $reader->getTitle();
 57 | 
 58 |     foreach($reader as $sheet)
 59 |     {
 60 |         // get sheet title
 61 |         $sheetTitle = $sheet->getTitle();
 62 |     }
 63 | 
 64 | ### Limiting the results
 65 | 
 66 | ##### Taking rows
 67 | 
 68 | When you only want to return the first x rows of a sheet, you can use `->take()` or `->limit()`.
 69 | 
 70 |     // You can either use ->take()
 71 |     $reader->take(10);
 72 | 
 73 |     // Or ->limit()
 74 |     $reader->limit(10);
 75 | 
 76 | ##### Skipping rows
 77 | 
 78 | When you want to skip a certain amount of rows you can use `->skip()` or `->limit(false, 10)`
 79 | 
 80 |     // Skip 10 results
 81 |     $reader->skip(10);
 82 | 
 83 |     // Skip 10 results with limit, but return all other rows
 84 |     $reader->limit(false, 10);
 85 | 
 86 |     // Skip and take
 87 |     $reader->skip(10)->take(10);
 88 | 
 89 |     // Limit with skip and take
 90 |     $reader->($skip, $take);
 91 | 
 92 | ### Result mutators
 93 | 
 94 | When you want to get an array instead of an object, you can use `->toArray()`.
 95 | 
 96 |     $reader->toArray();
 97 | 
 98 | When you want an object, you can alternativly (instead of get() or all()) use `->toObject()`.
 99 | 
100 |     $reader->toObject();
101 | 
102 | ### Displaying results
103 | 
104 | You can dump the results to a readable output by using `->dump()` or `->dd()`.
105 | 
106 |     // Dump the results
107 |     $reader->dump();
108 | 
109 |     // Dump results and die
110 |     $reader->dd();
111 | 
112 | ### Iterating the results
113 | 
114 | You can iterate the results by using `->each()`.
115 | 
116 |     // Loop through all sheets
117 |     $reader->each(function($sheet) {
118 | 
119 |         // Loop through all rows
120 |         $sheet->each(function($row) {
121 | 
122 |         });
123 | 
124 |     });
125 | 
126 | > Alternatively you can also `foreach` the results.
127 | 


--------------------------------------------------------------------------------
/docs/import/select.md:
--------------------------------------------------------------------------------
 1 | # Selecting sheets and columns
 2 | 
 3 | ### Selecting one specific sheet
 4 | If you want to select a single sheet, you can use `->selectSheets($name)`. Only that sheet will be loaded.
 5 | 
 6 |     Excel::selectSheets('sheet1')->load();
 7 | 
 8 | ### Selecting multiple sheets
 9 | If you want to select multiple sheets inside your file, you can pass an array as the parameter;
10 | 
11 |     Excel::selectSheets('sheet1', 'sheet2')->load();
12 | 
13 | ### Selecting sheets by index
14 | 
15 |     // First sheet
16 |     Excel::selectSheetsByIndex(0)->load();
17 | 
18 |     // First and second sheet
19 |     Excel::selectSheetsByIndex(0, 1)->load();
20 | 
21 | ### Selecting columns
22 | 
23 | If you want to select only a couple of columns, you can use `->select($columns)` or pass an array as the first parameter of `->get($columns)`.
24 | 
25 |     // Select
26 |     $reader->select(array('firstname', 'lastname'))->get();
27 | 
28 |     // Or
29 |     $reader->get(array('firstname', 'lastname'));
30 | 
31 | > All get methods (like all(), first(), dump(), toArray(), ...) accept an array of columns.
32 | 


--------------------------------------------------------------------------------
/docs/merge.md:
--------------------------------------------------------------------------------
1 | $mergeColumn = array(
2 |      *                  'columns' => array('A','B','C','D'),
3 |      *                  'rows' => array(
4 |      *                      array(2,3),
5 |      *                      array(5,11),
6 |      *                      .....
7 |      *                   )
8 |      *            );


--------------------------------------------------------------------------------
/docs/reference-guide.md:
--------------------------------------------------------------------------------
1 | @include:Available file properties|file-properties
2 | @include:Available sheet properties|sheet-properties
3 | @include:Available CSS styles|css-styles
4 | @include:Available border styles|borders
5 | @include:Available column formatting|formatting
6 | @include:Closures|closures


--------------------------------------------------------------------------------
/docs/reference-guide/borders.md:
--------------------------------------------------------------------------------
 1 | # Available border styles
 2 | 
 3 | | Style name  | PHPExcel class reference|
 4 | | ------------- |-----------------|
 5 | |none|PHPExcel_Style_Border::BORDER_NONE
 6 | |dashDot|PHPExcel_Style_Border::BORDER_DASHDOT
 7 | | dashDotDot|PHPExcel_Style_Border::BORDER_DASHDOTDOT
 8 | | dashed |PHPExcel_Style_Border::BORDER_DASHED
 9 | | dotted |PHPExcel_Style_Border::BORDER_DOTTED
10 | | double |PHPExcel_Style_Border::BORDER_DOUBLE
11 | | hair |PHPExcel_Style_Border::BORDER_HAIR
12 | | medium |PHPExcel_Style_Border::BORDER_MEDIUM
13 | | mediumDashDot |PHPExcel_Style_Border::BORDER_MEDIUMDASHDOT
14 | | mediumDashDotDot |PHPExcel_Style_Border::BORDER_MEDIUMDASHDOTDOT
15 | | mediumDashed |PHPExcel_Style_Border::BORDER_MEDIUMDASHED
16 | | slantDashDot |PHPExcel_Style_Border::BORDER_SLANTDASHDOT
17 | |  thick|PHPExcel_Style_Border::BORDER_THICK
18 | |  thin|PHPExcel_Style_Border::BORDER_THIN


--------------------------------------------------------------------------------
/docs/reference-guide/closures.md:
--------------------------------------------------------------------------------
 1 | # Closures
 2 | 
 3 | | Method  | Closure class |
 4 | | ------------- |-------------|
 5 | | create()      | Maatwebsite\Excel\Writers\LaravelExcelWriter |
 6 | | load()     | Maatwebsite\Excel\Readers\LaravelExcelReader    |
 7 | | batch | Maatwebsite\Excel\Readers\Batch     |
 8 | | sheet() | Maatwebsite\Excel\Classes\LaravelExcelWorksheet     |
 9 | | cells() | Maatwebsite\Excel\Writers\CellWriter     |
10 | | row() | Maatwebsite\Excel\Writers\CellWriter    |


--------------------------------------------------------------------------------
/docs/reference-guide/css-styles.md:
--------------------------------------------------------------------------------
 1 | # Available CSS styles
 2 | 
 3 | Styles that can be used inside an external CSS file or as inline CSS.
 4 | 
 5 | | Style name  | Example Value |
 6 | | ------------- |-------------|
 7 | | background(-color)      | #000000 |
 8 | | color     | #FFFFFF     |
 9 | | font-weight | bold     |
10 | | font-style | italic     |
11 | | font-weight | bold     |
12 | | font-size | 20px     |
13 | | font-family | Open Sans     |
14 | | text-decoration | underline     |
15 | | text-align | center    |
16 | | vertical-align | middle     |
17 | | border(-*) | 1px dashed #CCC     |
18 | | width | 100(px)    |
19 | | height | 1100(px) |


--------------------------------------------------------------------------------
/docs/reference-guide/file-properties.md:
--------------------------------------------------------------------------------
 1 | # Available file properties
 2 | 
 3 | Properties that can be set with `$excel->set{$property}()`
 4 | 
 5 | | Property name  |
 6 | | ------------- |
 7 | |creator
 8 | |lastModifiedBy
 9 | |title
10 | |description
11 | |subject
12 | |keywords
13 | |category
14 | |manager
15 | |company


--------------------------------------------------------------------------------
/docs/reference-guide/formatting.md:
--------------------------------------------------------------------------------
 1 | # Available column formatting
 2 | 
 3 | | Format name  | PHPExcel class reference|
 4 | | ------------- |-----------------|
 5 | |General|PHPExcel_Style_NumberFormat::FORMAT_GENERAL
 6 | |@|PHPExcel_Style_NumberFormat::FORMAT_TEXT
 7 | |0|PHPExcel_Style_NumberFormat::FORMAT_NUMBER
 8 | |0.00|PHPExcel_Style_NumberFormat::FORMAT_NUMBER_00
 9 | |#,##0.00|PHPExcel_Style_NumberFormat::FORMAT_NUMBER_COMMA_SEPARATED1
10 | |#,##0.00_-|PHPExcel_Style_NumberFormat::FORMAT_NUMBER_COMMA_SEPARATED2
11 | |0%|PHPExcel_Style_NumberFormat::FORMAT_PERCENTAGE
12 | |0.00%|PHPExcel_Style_NumberFormat::FORMAT_PERCENTAGE_00
13 | |yyyy-mm-dd|PHPExcel_Style_NumberFormat::FORMAT_DATE_YYYYMMDD2
14 | |yy-mm-dd|PHPExcel_Style_NumberFormat::FORMAT_DATE_YYYYMMDD
15 | |dd/mm/yy|PHPExcel_Style_NumberFormat::FORMAT_DATE_DDMMYYYY
16 | |d/m/y|PHPExcel_Style_NumberFormat::FORMAT_DATE_DMYSLASH
17 | |d-m-y|PHPExcel_Style_NumberFormat::FORMAT_DATE_DMYMINUS
18 | |d-m|PHPExcel_Style_NumberFormat::FORMAT_DATE_DMMINUS
19 | |m-y|PHPExcel_Style_NumberFormat::FORMAT_DATE_MYMINUS
20 | |mm-dd-yy|PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX14
21 | |d-mmm-yy|PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX15
22 | |d-mmm|PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX16
23 | |mmm-yy|PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX17
24 | |m/d/yy h:mm|PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX22
25 | |d/m/y h:mm|PHPExcel_Style_NumberFormat::FORMAT_DATE_DATETIME
26 | |h:mm AM/PM|PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME1
27 | |h:mm:ss AM/PM|PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME2
28 | |h:mm|PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME3
29 | |h:mm:ss|PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME4
30 | |mm:ss|PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME5
31 | |h:mm:ss|PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME6
32 | |i:s.S|PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME7
33 | |h:mm:ss;@|PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME8
34 | |yy/mm/dd;@|PHPExcel_Style_NumberFormat::FORMAT_DATE_YYYYMMDDSLASH
35 | |"$"#,##0.00_-|PHPExcel_Style_NumberFormat::FORMAT_CURRENCY_USD_SIMPLE
36 | |$#,##0_-|PHPExcel_Style_NumberFormat::FORMAT_CURRENCY_USD
37 | |[$EUR ]#,##0.00_-|PHPExcel_Style_NumberFormat::FORMAT_CURRENCY_EUR_SIMPLE


--------------------------------------------------------------------------------
/docs/reference-guide/sheet-properties.md:
--------------------------------------------------------------------------------
 1 | # Available sheet properties
 2 | 
 3 | Properties that can be set with `$sheet->set{$property}()`
 4 | 
 5 | | Property name  | Possible value|
 6 | | ------------- |-----------------|
 7 | |orientation| string
 8 | |paperSize| integer
 9 | |scale| integer
10 | |fitToPage| boolean
11 | |fitToHeight| boolean
12 | |fitToWidth| boolean
13 | |columnsToRepeatAtLeft| array
14 | |rowsToRepeatAtTop| array
15 | |horizontalCentered| boolean
16 | |verticalCentered| boolean
17 | |printArea| range
18 | |firstPageNumber| integer


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit backupGlobals="false"
 3 |          backupStaticAttributes="false"
 4 |          bootstrap="vendor/autoload.php"
 5 |          colors="true"
 6 |          convertErrorsToExceptions="true"
 7 |          convertNoticesToExceptions="true"
 8 |          convertWarningsToExceptions="true"
 9 |          processIsolation="false"
10 |          stopOnFailure="false"
11 |          syntaxCheck="false"
12 | >
13 |     <testsuites>
14 |         <testsuite name="Package Test Suite">
15 |             <directory suffix=".php">./tests/</directory>
16 |         </testsuite>
17 |     </testsuites>
18 | </phpunit>
19 | 


--------------------------------------------------------------------------------
/provides.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "providers": [
 3 |     "Maatwebsite\\Excel\\ExcelServiceProvider"
 4 |   ],
 5 |   "aliases": [
 6 |     {
 7 |       "alias": "Excel",
 8 |       "facade": "Maatwebsite\\Excel\\Facades\\Excel"
 9 |     }
10 |   ]
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Classes/Cache.php:
--------------------------------------------------------------------------------
  1 | <?php namespace Maatwebsite\Excel\Classes;
  2 | 
  3 | use PHPExcel_Settings;
  4 | use Illuminate\Support\Facades\Config;
  5 | use PHPExcel_CachedObjectStorageFactory;
  6 | 
  7 | class Cache {
  8 | 
  9 |     /**
 10 |      * PHPExcel cache class
 11 |      * @var string
 12 |      */
 13 |     protected $class = 'PHPExcel_CachedObjectStorageFactory';
 14 | 
 15 |     /**
 16 |      * Available caching drivers
 17 |      * @var array
 18 |      */
 19 |     protected $available = array(
 20 |         'memory'     => 'cache_in_memory',
 21 |         'gzip'       => 'cache_in_memory_gzip',
 22 |         'serialized' => 'cache_in_memory_serialized',
 23 |         'igbinary'   => 'cache_igbinary',
 24 |         'discISAM'   => 'cache_to_discISAM',
 25 |         'apc'        => 'cache_to_apc',
 26 |         'memcache'   => 'cache_to_memcache',
 27 |         'temp'       => 'cache_to_phpTemp',
 28 |         'wincache'   => 'cache_to_wincache',
 29 |         'sqlite'     => 'cache_to_sqlite',
 30 |         'sqlite3'    => 'cache_to_sqlite3'
 31 |     );
 32 | 
 33 |     /**
 34 |      * The name of the config file
 35 |      * @var string
 36 |      */
 37 |     private $configName = 'excel.cache';
 38 | 
 39 |     /**
 40 |      * Cache constructor
 41 |      */
 42 |     public function __construct()
 43 |     {
 44 |         // Get driver and settings from the config
 45 |         $this->driver = Config::get($this->configName . '.driver', 'memory');
 46 |         $this->settings = Config::get($this->configName . '.settings', array());
 47 | 
 48 |         // Init if caching is enabled
 49 |         if ($this->isEnabled())
 50 |             $this->init();
 51 |     }
 52 | 
 53 |     /**
 54 |      * Init the cache
 55 |      * @return void
 56 |      */
 57 |     public function init()
 58 |     {
 59 |         // Find the cache driver
 60 |         $this->findDriver();
 61 | 
 62 |         // Set the storage driver
 63 |         PHPExcel_Settings::setCacheStorageMethod($this->method, $this->settings);
 64 |     }
 65 | 
 66 |     /**
 67 |      * Set the right driver
 68 |      * @return void
 69 |      */
 70 |     public function findDriver()
 71 |     {
 72 |         $property = $this->detect();
 73 |         $this->method = constant($this->class . '::' . $property);
 74 |     }
 75 | 
 76 |     /**
 77 |      * Detect the caching driver
 78 |      * @return string $driver
 79 |      */
 80 |     protected function detect()
 81 |     {
 82 |         // Add additional settings
 83 |         $this->addAdditionalSettings();
 84 | 
 85 |         // return the driver
 86 |         return isset($this->available[$this->driver]) ? $this->available[$this->driver] : reset($this->available);
 87 |     }
 88 | 
 89 |     /**
 90 |      * Add additional settings for the current driver
 91 |      * @return  void
 92 |      */
 93 |     protected function addAdditionalSettings()
 94 |     {
 95 |         switch ($this->driver)
 96 |         {
 97 |             case 'memcache':
 98 | 
 99 |                 // Add extra memcache settings
100 |                 $this->settings = array_merge($this->settings, array(
101 |                     'memcacheServer' => Config::get($this->configName . '.memcache.host', 'localhost'),
102 |                     'memcachePort'   => Config::get($this->configName . '.memcache.port', 11211)
103 |                 ));
104 | 
105 |                 break;
106 | 
107 |             case 'discISAM':
108 | 
109 |                 // Add dir
110 |                 $this->settings = array_merge($this->settings, array(
111 |                     'dir' => Config::get($this->configName . '.dir', storage_path('cache')),
112 |                 ));
113 | 
114 |                 break;
115 |         }
116 |     }
117 | 
118 |     /**
119 |      * Check if caching is enabled
120 |      * @return boolean
121 |      */
122 |     public function isEnabled()
123 |     {
124 |         return Config::get($this->configName . '.enable', true) ? true : false;
125 |     }
126 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Classes/FormatIdentifier.php:
--------------------------------------------------------------------------------
  1 | <?php namespace Maatwebsite\Excel\Classes;
  2 | 
  3 | use PHPExcel_IOFactory;
  4 | use Illuminate\Filesystem\Filesystem;
  5 | use Maatwebsite\Excel\Exceptions\LaravelExcelException;
  6 | 
  7 | class FormatIdentifier {
  8 | 
  9 |     /**
 10 |      * Available formats
 11 |      *
 12 |      * @var array
 13 |      * @access  protected
 14 |      */
 15 |     protected $formats = array(
 16 |         'Excel2007',
 17 |         'Excel5',
 18 |         'Excel2003XML',
 19 |         'OOCalc',
 20 |         'SYLK',
 21 |         'Gnumeric',
 22 |         'CSV',
 23 |         'HTML',
 24 |         'PDF'
 25 |     );
 26 | 
 27 |     /**
 28 |      * Construct new format identifier
 29 |      * @param Filesystem $filesystem
 30 |      */
 31 |     public function __construct(Filesystem $filesystem)
 32 |     {
 33 |         $this->filesystem = $filesystem;
 34 |     }
 35 | 
 36 |     /**
 37 |      * Get the file format by file
 38 |      * @param $file
 39 |      * @throws LaravelExcelException
 40 |      * @return string $format
 41 |      */
 42 |     public function getFormatByFile($file)
 43 |     {
 44 |         // get the file extension
 45 |         $ext = $this->getExtension($file);
 46 | 
 47 |         // get the file format
 48 |         $format = $this->getFormatByExtension($ext);
 49 | 
 50 |         // Check if the file can be read
 51 |         if ($this->canRead($format, $file))
 52 |             return $format;
 53 | 
 54 |         // Do a last try to init the file with all available readers
 55 |         return $this->lastResort($file, $format, $ext);
 56 |     }
 57 | 
 58 |     /**
 59 |      * Identify file format
 60 |      * @param $ext
 61 |      * @return  string $format
 62 |      */
 63 |     public function getFormatByExtension($ext)
 64 |     {
 65 |         switch ($ext)
 66 |         {
 67 | 
 68 |             /*
 69 |             |--------------------------------------------------------------------------
 70 |             | Excel 2007
 71 |             |--------------------------------------------------------------------------
 72 |             */
 73 |             case 'xlsx':
 74 |             case 'xlsm':
 75 |             case 'xltx':
 76 |             case 'xltm':
 77 |                 return 'Excel2007';
 78 |                 break;
 79 | 
 80 |             /*
 81 |             |--------------------------------------------------------------------------
 82 |             | Excel5
 83 |             |--------------------------------------------------------------------------
 84 |             */
 85 |             case 'xls':
 86 |             case 'xlt':
 87 |                 return 'Excel5';
 88 |                 break;
 89 | 
 90 |             /*
 91 |             |--------------------------------------------------------------------------
 92 |             | OOCalc
 93 |             |--------------------------------------------------------------------------
 94 |             */
 95 |             case 'ods':
 96 |             case 'ots':
 97 |                 return 'OOCalc';
 98 |                 break;
 99 | 
100 |             /*
101 |             |--------------------------------------------------------------------------
102 |             | SYLK
103 |             |--------------------------------------------------------------------------
104 |             */
105 |             case 'slk':
106 |                 return 'SYLK';
107 |                 break;
108 | 
109 |             /*
110 |             |--------------------------------------------------------------------------
111 |             | Excel2003XML
112 |             |--------------------------------------------------------------------------
113 |             */
114 |             case 'xml':
115 |                 return 'Excel2003XML';
116 |                 break;
117 | 
118 |             /*
119 |             |--------------------------------------------------------------------------
120 |             | Gnumeric
121 |             |--------------------------------------------------------------------------
122 |             */
123 |             case 'gnumeric':
124 |                 return 'Gnumeric';
125 |                 break;
126 | 
127 |             /*
128 |             |--------------------------------------------------------------------------
129 |             | HTML
130 |             |--------------------------------------------------------------------------
131 |             */
132 |             case 'htm':
133 |             case 'html':
134 |                 return 'HTML';
135 |                 break;
136 | 
137 |             /*
138 |             |--------------------------------------------------------------------------
139 |             | CSV
140 |             |--------------------------------------------------------------------------
141 |             */
142 |             case 'csv':
143 |             case 'txt':
144 |                 return 'CSV';
145 |                 break;
146 | 
147 |             /*
148 |             |--------------------------------------------------------------------------
149 |             | PDF
150 |             |--------------------------------------------------------------------------
151 |             */
152 |              case 'pdf':
153 |                  return 'PDF';
154 |                  break;
155 |         }
156 |     }
157 | 
158 |     /**
159 |      * Get the content type by file format
160 |      * @param  string $format
161 |      * @return string $contentType
162 |      */
163 |     public function getContentTypeByFormat($format)
164 |     {
165 |         switch ($format)
166 |         {
167 | 
168 |             /*
169 |             |--------------------------------------------------------------------------
170 |             | Excel 2007
171 |             |--------------------------------------------------------------------------
172 |             */
173 |             case 'Excel2007':
174 |                 return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet; charset=UTF-8';
175 |                 break;
176 | 
177 |             /*
178 |             |--------------------------------------------------------------------------
179 |             | Excel5
180 |             |--------------------------------------------------------------------------
181 |             */
182 |             case 'Excel5':
183 |                 return 'application/vnd.ms-excel; charset=UTF-8';
184 |                 break;
185 | 
186 |             /*
187 |             |--------------------------------------------------------------------------
188 |             | HTML
189 |             |--------------------------------------------------------------------------
190 |             */
191 |             case 'HTML':
192 |                 return 'HTML';
193 |                 break;
194 | 
195 |             /*
196 |             |--------------------------------------------------------------------------
197 |             | CSV
198 |             |--------------------------------------------------------------------------
199 |             */
200 |             case 'CSV':
201 |                 return 'application/csv; charset=UTF-8';
202 |                 break;
203 | 
204 |             /*
205 |             |--------------------------------------------------------------------------
206 |             | PDF
207 |             |--------------------------------------------------------------------------
208 |             */
209 |              case 'PDF':
210 |                  return'application/pdf; charset=UTF-8';
211 |                  break;
212 |         }
213 |     }
214 | 
215 |     /**
216 |      * Try every reader we have
217 |      * @param        $file
218 |      * @param bool   $wrongFormat
219 |      * @param string $ext
220 |      * @throws LaravelExcelException
221 |      * @return string $format
222 |      */
223 |     protected function lastResort($file, $wrongFormat = false, $ext = 'xls')
224 |     {
225 |         // Loop through all available formats
226 |         foreach ($this->formats as $format)
227 |         {
228 |             // Check if the file could be read
229 |             if ($wrongFormat != $format && $this->canRead($format, $file))
230 |                 return $format;
231 |         }
232 | 
233 |         // Give up searching and throw an exception
234 |         throw new LaravelExcelException('[ERROR] Reader could not identify file format for file [' . $file . '] with extension [' . $ext . ']');
235 |     }
236 | 
237 |     /**
238 |      * Check if we can read the file
239 |      * @param $format
240 |      * @param $file
241 |      * @return boolean
242 |      */
243 |     protected function canRead($format, $file)
244 |     {
245 |         if ($format)
246 |         {
247 |             $reader = $this->initReader($format);
248 | 
249 |             return $reader && $reader->canRead($file);
250 |         }
251 | 
252 |         return false;
253 |     }
254 | 
255 |     /**
256 |      * Init the reader based on the format
257 |      * @param  string $format
258 |      * @return \PHPExcel_Reader_IReader
259 |      */
260 |     protected function initReader($format)
261 |     {
262 |         return PHPExcel_IOFactory::createReader($format);
263 |     }
264 | 
265 |     /**
266 |      * Get the file extension
267 |      * @param  string $file
268 |      * @return string
269 |      */
270 |     protected function getExtension($file)
271 |     {
272 |         return strtolower($this->filesystem->extension($file));
273 |     }
274 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Classes/PHPExcel.php:
--------------------------------------------------------------------------------
  1 | <?php namespace Maatwebsite\Excel\Classes;
  2 | 
  3 | use PHPExcel as PHPOffice_PHPExcel;
  4 | use Illuminate\Support\Facades\Config;
  5 | 
  6 | /**
  7 |  *
  8 |  * Laravel wrapper for PHPExcel
  9 |  *
 10 |  * @category   Laravel Excel
 11 |  * @package    maatwebsite/excel
 12 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
 13 |  * @copyright  Original Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
 14 |  * @author     Maatwebsite <info@maatwebsite.nl>
 15 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
 16 |  */
 17 | class PHPExcel extends PHPOffice_PHPExcel {
 18 | 
 19 |     /**
 20 |      * Allowed autofill properties
 21 |      * @var array
 22 |      */
 23 |     public $allowedProperties = array(
 24 |         'creator',
 25 |         'lastModifiedBy',
 26 |         'description',
 27 |         'subject',
 28 |         'keywords',
 29 |         'category',
 30 |         'manager',
 31 |         'company'
 32 |     );
 33 | 
 34 |     /**
 35 |      * Create sheet and add it to this workbook
 36 |      *
 37 |      * @param  int|null   $iSheetIndex Index where sheet should go (0,1,..., or null for last)
 38 |      * @param bool|string $title
 39 |      * @throws \PHPExcel_Exception
 40 |      * @return LaravelExcelWorksheet
 41 |      */
 42 |     public function createSheet($iSheetIndex = null, $title = false)
 43 |     {
 44 |         // Init new Laravel Excel worksheet
 45 |         $newSheet = new LaravelExcelWorksheet($this, $title);
 46 | 
 47 |         // Add the sheet
 48 |         $this->addSheet($newSheet, $iSheetIndex);
 49 | 
 50 |         // Return the sheet
 51 |         return $newSheet;
 52 |     }
 53 | 
 54 |     /**
 55 |      * Check if the user change change the workbook property
 56 |      * @param  string $method
 57 |      * @return boolean
 58 |      */
 59 |     public function isChangeableProperty($method)
 60 |     {
 61 |         $name = lcfirst(str_replace('set', '', $method));
 62 | 
 63 |         return in_array($name, $this->getAllowedProperties()) ? true : false;
 64 |     }
 65 | 
 66 |     /**
 67 |      * Set default properties
 68 |      * @param array $custom
 69 |      * @return  void
 70 |      */
 71 |     public function setDefaultProperties($custom = [])
 72 |     {
 73 |         // Get the properties
 74 |         $properties = $this->getProperties();
 75 | 
 76 |         // Get fillable properties
 77 |         foreach ($this->getAllowedProperties() as $prop)
 78 |         {
 79 |             // Get the method
 80 |             $method = 'set' . ucfirst($prop);
 81 | 
 82 |             // get the value
 83 |             $value = in_array($prop, array_keys($custom)) ? $custom[$prop] : Config::get('excel.properties.' . $prop, null);
 84 | 
 85 |             // set the property
 86 |             call_user_func_array(array($properties, $method), array($value));
 87 |         }
 88 |     }
 89 | 
 90 |     /**
 91 |      * load info from parent obj
 92 |      * @param \PHPExcel $object
 93 |      * @return $this
 94 |      */
 95 |     function cloneParent(\PHPExcel $object)
 96 |     {
 97 |         // Init new reflection object
 98 |         $class = new \ReflectionClass(get_class($object));
 99 | 
100 |         // Loop through all properties
101 |         foreach($class->getProperties() as $property)
102 |         {
103 |             // Make the property public
104 |             $property->setAccessible(true);
105 | 
106 |             // Set the found value to this sheet
107 |             $property->setValue(
108 |                 $this,
109 |                 $property->getValue($object)
110 |             );
111 |         }
112 | 
113 |         return $this;
114 |     }
115 | 
116 |     /**
117 |      * Return all allowed properties
118 |      * @return array
119 |      */
120 |     public function getAllowedProperties()
121 |     {
122 |         return $this->allowedProperties;
123 |     }
124 | }
125 | 


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Collections/CellCollection.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Maatwebsite\Excel\Collections;
 2 | 
 3 | /**
 4 |  *
 5 |  * LaravelExcel CellCollection
 6 |  *
 7 |  * @category   Laravel Excel
 8 |  * @package    maatwebsite/excel
 9 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
10 |  * @author     Maatwebsite <info@maatwebsite.nl>
11 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
12 |  */
13 | class CellCollection extends ExcelCollection {
14 | 
15 |     /**
16 |      * Create a new collection.
17 |      * @param  array $items
18 |      * @return \Maatwebsite\Excel\Collections\CellCollection
19 |      */
20 |     public function __construct(array $items = array())
21 |     {
22 |         $this->setItems($items);
23 |     }
24 | 
25 |     /**
26 |      * Set the items
27 |      * @param array $items
28 |      * @return void
29 |      */
30 |     public function setItems($items)
31 |     {
32 |         foreach ($items as $name => $value)
33 |         {
34 |             $value = !empty($value) || is_numeric($value) ? $value : null;
35 | 
36 |             if ($name && !is_numeric($name))
37 |             {
38 |                 $this->put($name, $value);
39 |             }
40 |             else
41 |             {
42 |                 $this->push($value);
43 |             }
44 |         }
45 |     }
46 | 
47 |     /**
48 |      * Dynamically get values
49 |      * @param  string $key
50 |      * @return string
51 |      */
52 |     public function __get($key)
53 |     {
54 |         if ($this->has($key))
55 |             return $this->get($key);
56 |     }
57 | 
58 |     /**
59 |      * Determine if an attribute exists on the model.
60 |      *
61 |      * @param  string  $key
62 |      * @return bool
63 |      */
64 |     public function __isset($key)
65 |     {
66 |         return $this->has($key);
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Collections/ExcelCollection.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Maatwebsite\Excel\Collections;
 2 | 
 3 | use Illuminate\Support\Collection;
 4 | 
 5 | /**
 6 |  *
 7 |  * LaravelExcel ExcelCollection
 8 |  *
 9 |  * @category   Laravel Excel
10 |  * @version    1.0.0
11 |  * @package    maatwebsite/excel
12 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
13 |  * @author     Maatwebsite <info@maatwebsite.nl>
14 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
15 |  */
16 | class ExcelCollection extends Collection {
17 | 
18 |     /**
19 |      * Sheet title
20 |      * @var [type]
21 |      */
22 |     protected $title;
23 | 
24 |     /**
25 |      * Get the title
26 |      * @return string
27 |      */
28 |     public function getTitle()
29 |     {
30 |         return $this->title;
31 |     }
32 | 
33 |     /**
34 |      * Set the title
35 |      * @param $title
36 |      */
37 |     public function setTitle($title)
38 |     {
39 |         $this->title = $title;
40 |     }
41 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Collections/RowCollection.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Maatwebsite\Excel\Collections;
 2 | 
 3 | /**
 4 |  *
 5 |  * LaravelExcel RowCollection
 6 |  *
 7 |  * @category   Laravel Excel
 8 |  * @version    1.0.0
 9 |  * @package    maatwebsite/excel
10 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
11 |  * @author     Maatwebsite <info@maatwebsite.nl>
12 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
13 |  */
14 | class RowCollection extends ExcelCollection {
15 | 
16 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Collections/SheetCollection.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Maatwebsite\Excel\Collections;
 2 | 
 3 | /**
 4 |  *
 5 |  * LaravelExcel SheetCollection
 6 |  *
 7 |  * @category   Laravel Excel
 8 |  * @version    1.0.0
 9 |  * @package    maatwebsite/excel
10 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
11 |  * @author     Maatwebsite <info@maatwebsite.nl>
12 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
13 |  */
14 | class SheetCollection extends ExcelCollection {
15 | 
16 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Excel.php:
--------------------------------------------------------------------------------
  1 | <?php namespace Maatwebsite\Excel;
  2 | 
  3 | use Closure;
  4 | use Maatwebsite\Excel\Readers\Batch;
  5 | use Maatwebsite\Excel\Classes\PHPExcel;
  6 | use Maatwebsite\Excel\Readers\LaravelExcelReader;
  7 | use Maatwebsite\Excel\Writers\LaravelExcelWriter;
  8 | use Maatwebsite\Excel\Exceptions\LaravelExcelException;
  9 | 
 10 | /**
 11 |  *
 12 |  * Laravel wrapper for PHPExcel
 13 |  *
 14 |  * @category   Laravel Excel
 15 |  * @version    1.0.0
 16 |  * @package    maatwebsite/excel
 17 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
 18 |  * @author     Maatwebsite <info@maatwebsite.nl>
 19 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
 20 |  */
 21 | class Excel {
 22 | 
 23 |     /**
 24 |      * Filter
 25 |      * @var array
 26 |      */
 27 |     protected $filters = array(
 28 |         'registered' =>  array(),
 29 |         'enabled'    =>  array()
 30 |     );
 31 | 
 32 |     /**
 33 |      * Excel object
 34 |      * @var PHPExcel
 35 |      */
 36 |     protected $excel;
 37 | 
 38 |     /**
 39 |      * Reader object
 40 |      * @var LaravelExcelReader
 41 |      */
 42 |     protected $reader;
 43 | 
 44 |     /**
 45 |      * Writer object
 46 |      * @var LaravelExcelWriter
 47 |      */
 48 |     protected $writer;
 49 | 
 50 |     /**
 51 |      * Construct Excel
 52 |      * @param  PHPExcel           $excel
 53 |      * @param  LaravelExcelReader $reader
 54 |      * @param  LaravelExcelWriter $writer
 55 |      */
 56 |     public function __construct(PHPExcel $excel, LaravelExcelReader $reader, LaravelExcelWriter $writer)
 57 |     {
 58 |         // Set Excel dependencies
 59 |         $this->excel = $excel;
 60 |         $this->reader = $reader;
 61 |         $this->writer = $writer;
 62 |     }
 63 | 
 64 |     /**
 65 |      * Create a new file
 66 |      * @param                $filename
 67 |      * @param  callable|null $callback
 68 |      * @return LaravelExcelWriter
 69 |      */
 70 |     public function create($filename, $callback = null)
 71 |     {
 72 |         // Writer instance
 73 |         $writer = clone $this->writer;
 74 | 
 75 |         // Disconnect worksheets to prevent unnecessary ones
 76 |         $this->excel->disconnectWorksheets();
 77 | 
 78 |         // Inject our excel object
 79 |         $writer->injectExcel($this->excel);
 80 | 
 81 |         // Set the filename and title
 82 |         $writer->setFileName($filename);
 83 |         $writer->setTitle($filename);
 84 | 
 85 |         // Do the callback
 86 |         if ($callback instanceof Closure)
 87 |             call_user_func($callback, $writer);
 88 | 
 89 |         // Return the writer object
 90 |         return $writer;
 91 |     }
 92 | 
 93 |     /**
 94 |      *
 95 |      *  Load an existing file
 96 |      *
 97 |      * @param  string        $file The file we want to load
 98 |      * @param  callback|null $callback
 99 |      * @param  string|null   $encoding
100 |      * @param bool           $noBasePath
101 |      * @return LaravelExcelReader
102 |      */
103 |     public function load($file, $callback = null, $encoding = null, $noBasePath = false)
104 |     {
105 |         // Reader instance
106 |         $reader = clone $this->reader;
107 | 
108 |         // Inject excel object
109 |         $reader->injectExcel($this->excel);
110 | 
111 |         // Enable filters
112 |         $reader->setFilters($this->filters);
113 | 
114 |         // Set the encoding
115 |         $encoding = is_string($callback) ? $callback : $encoding;
116 | 
117 |         // Start loading
118 |         $reader->load($file, $encoding, $noBasePath);
119 | 
120 |         // Do the callback
121 |         if ($callback instanceof Closure)
122 |             call_user_func($callback, $reader);
123 | 
124 |         // Return the reader object
125 |         return $reader;
126 |     }
127 | 
128 |     /**
129 |      * Set select sheets
130 |      * @param  $sheets
131 |      * @return LaravelExcelReader
132 |      */
133 |     public function selectSheets($sheets = array())
134 |     {
135 |         $sheets = is_array($sheets) ? $sheets : func_get_args();
136 |         $this->reader->setSelectedSheets($sheets);
137 | 
138 |         return $this;
139 |     }
140 | 
141 |     /**
142 |      * Select sheets by index
143 |      * @param array $sheets
144 |      * @return $this
145 |      */
146 |     public function selectSheetsByIndex($sheets = array())
147 |     {
148 |         $sheets = is_array($sheets) ? $sheets : func_get_args();
149 |         $this->reader->setSelectedSheetIndices($sheets);
150 | 
151 |         return $this;
152 |     }
153 | 
154 |     /**
155 |      * Batch import
156 |      * @param           $files
157 |      * @param  callback $callback
158 |      * @return PHPExcel
159 |      */
160 |     public function batch($files, Closure $callback)
161 |     {
162 |         $batch = new Batch;
163 | 
164 |         return $batch->start($this, $files, $callback);
165 |     }
166 | 
167 |     /**
168 |      * Create a new file and share a view
169 |      * @param  string $view
170 |      * @param  array  $data
171 |      * @param  array  $mergeData
172 |      * @return LaravelExcelWriter
173 |      */
174 |     public function shareView($view, $data = array(), $mergeData = array())
175 |     {
176 |         return $this->create($view)->shareView($view, $data, $mergeData);
177 |     }
178 | 
179 |     /**
180 |      * Create a new file and load a view
181 |      * @param  string $view
182 |      * @param  array  $data
183 |      * @param  array  $mergeData
184 |      * @return LaravelExcelWriter
185 |      */
186 |     public function loadView($view, $data = array(), $mergeData = array())
187 |     {
188 |         return $this->shareView($view, $data, $mergeData);
189 |     }
190 | 
191 |     /**
192 |      * Set filters
193 |      * @param   array $filters
194 |      * @return  Excel
195 |      */
196 |     public function registerFilters($filters = array())
197 |     {
198 |         // If enabled array key exists
199 |         if(array_key_exists('enabled', $filters))
200 |         {
201 |             // Set registered array
202 |             $registered = $filters['registered'];
203 | 
204 |             // Filter on enabled
205 |             $this->filter($filters['enabled']);
206 |         }
207 |         else
208 |         {
209 |             $registered = $filters;
210 |         }
211 | 
212 |         // Register the filters
213 |         $this->filters['registered'] = !empty($this->filters['registered']) ? array_merge($this->filters['registered'], $registered) : $registered;
214 |         return $this;
215 |     }
216 | 
217 |     /**
218 |      * Enable certain filters
219 |      * @param  string|array     $filter
220 |      * @param bool|false|string $class
221 |      * @return Excel
222 |      */
223 |     public function filter($filter, $class = false)
224 |     {
225 |         // Add multiple filters
226 |         if(is_array($filter))
227 |         {
228 |             $this->filters['enabled'] = !empty($this->filters['enabled']) ? array_merge($this->filters['enabled'], $filter) : $filter;
229 |         }
230 |         else
231 |         {
232 |             // Add single filter
233 |             $this->filters['enabled'][] = $filter;
234 | 
235 |             // Overrule filter class for this request
236 |             if($class)
237 |                 $this->filters['registered'][$filter] = $class;
238 |         }
239 | 
240 |         // Remove duplicates
241 |         $this->filters['enabled'] = array_unique($this->filters['enabled']);
242 | 
243 |         return $this;
244 |     }
245 | 
246 |     /**
247 |      * Get register, enabled (or both) filters
248 |      * @param  string|boolean $key [description]
249 |      * @return array
250 |      */
251 |     public function getFilters($key = false)
252 |     {
253 |         return $key ? $this->filters[$key] : $this->filters;
254 |     }
255 | 
256 |     /**
257 |      * Dynamically call methods
258 |      * @throws LaravelExcelException
259 |      */
260 |     public function __call($method, $params)
261 |     {
262 |         // If the dynamic call starts with "with", add the var to the data array
263 |         if (method_exists($this->excel, $method))
264 |         {
265 |             // Call the method from the excel object with the given params
266 |             return call_user_func_array(array($this->excel, $method), $params);
267 |         }
268 | 
269 |         // If reader method exists, call that one
270 |         if (method_exists($this->reader, $method))
271 |         {
272 |             // Call the method from the reader object with the given params
273 |             return call_user_func_array(array($this->reader, $method), $params);
274 |         }
275 | 
276 |         throw new LaravelExcelException('Laravel Excel method [' . $method . '] does not exist');
277 |     }
278 | }
279 | 


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/ExcelServiceProvider.php:
--------------------------------------------------------------------------------
  1 | <?php namespace Maatwebsite\Excel;
  2 | 
  3 | use PHPExcel_Settings;
  4 | use PHPExcel_Shared_Font;
  5 | use Maatwebsite\Excel\Readers\Html;
  6 | use Maatwebsite\Excel\Classes\Cache;
  7 | use Illuminate\Support\Facades\Config;
  8 | use Maatwebsite\Excel\Classes\PHPExcel;
  9 | use Illuminate\Support\ServiceProvider;
 10 | use Maatwebsite\Excel\Parsers\CssParser;
 11 | use Maatwebsite\Excel\Parsers\ViewParser;
 12 | use Maatwebsite\Excel\Classes\FormatIdentifier;
 13 | use Maatwebsite\Excel\Readers\LaravelExcelReader;
 14 | use Maatwebsite\Excel\Writers\LaravelExcelWriter;
 15 | use TijsVerkoyen\CssToInlineStyles\CssToInlineStyles;
 16 | 
 17 | /**
 18 |  *
 19 |  * LaravelExcel Excel ServiceProvider
 20 |  *
 21 |  * @category   Laravel Excel
 22 |  * @package    maatwebsite/excel
 23 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
 24 |  * @author     Maatwebsite <info@maatwebsite.nl>
 25 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
 26 |  */
 27 | class ExcelServiceProvider extends ServiceProvider {
 28 | 
 29 |     /**
 30 |      * Indicates if loading of the provider is deferred.
 31 |      *
 32 |      * @var bool
 33 |      */
 34 |     protected $defer = false;
 35 | 
 36 |     /**
 37 |      * Bootstrap the application events.
 38 |      *
 39 |      * @return void
 40 |      */
 41 | 
 42 |     public function boot()
 43 |     {
 44 |         $this->publishes([
 45 |             __DIR__ . '/../../config/excel.php' => config_path('excel.php'),
 46 |         ]);
 47 | 
 48 |         $this->mergeConfigFrom(
 49 |             __DIR__ . '/../../config/excel.php', 'excel'
 50 |         );
 51 | 
 52 |         //Set the autosizing settings
 53 |         $this->setAutoSizingSettings();
 54 |     }
 55 | 
 56 |     /**
 57 |      * Register the service provider.
 58 |      *
 59 |      * @return void
 60 |      */
 61 |     public function register()
 62 |     {
 63 |         $this->bindClasses();
 64 |         $this->bindCssParser();
 65 |         $this->bindReaders();
 66 |         $this->bindParsers();
 67 |         $this->bindPHPExcelClass();
 68 |         $this->bindWriters();
 69 |         $this->bindExcel();
 70 |     }
 71 | 
 72 |     /**
 73 |      * Bind PHPExcel classes
 74 |      * @return void
 75 |      */
 76 |     protected function bindPHPExcelClass()
 77 |     {
 78 |         // Set object
 79 |         $me = $this;
 80 | 
 81 |         // Bind the PHPExcel class
 82 |         $this->app['phpexcel'] = $this->app->share(function () use ($me)
 83 |         {
 84 |             // Set locale
 85 |             $me->setLocale();
 86 | 
 87 |             // Set the caching settings
 88 |             $me->setCacheSettings();
 89 | 
 90 |             // Init phpExcel
 91 |             $excel = new PHPExcel();
 92 |             $excel->setDefaultProperties();
 93 |             return $excel;
 94 |         });
 95 |     }
 96 | 
 97 |     /**
 98 |      * Bind the css parser
 99 |      */
100 |     protected function bindCssParser()
101 |     {
102 |         // Bind css parser
103 |         $this->app['excel.parsers.css'] = $this->app->share(function ()
104 |         {
105 |             return new CssParser(
106 |                 new CssToInlineStyles()
107 |             );
108 |         });
109 |     }
110 | 
111 |     /**
112 |      * Bind writers
113 |      * @return void
114 |      */
115 |     protected function bindReaders()
116 |     {
117 |         // Bind the laravel excel reader
118 |         $this->app['excel.reader'] = $this->app->share(function ($app)
119 |         {
120 |             return new LaravelExcelReader(
121 |                 $app['files'],
122 |                 $app['excel.identifier']
123 |             );
124 |         });
125 | 
126 |         // Bind the html reader class
127 |         $this->app['excel.readers.html'] = $this->app->share(function ($app)
128 |         {
129 |             return new Html(
130 |                 $app['excel.parsers.css']
131 |             );
132 |         });
133 |     }
134 | 
135 |     /**
136 |      * Bind writers
137 |      * @return void
138 |      */
139 |     protected function bindParsers()
140 |     {
141 |         // Bind the view parser
142 |         $this->app['excel.parsers.view'] = $this->app->share(function ($app)
143 |         {
144 |             return new ViewParser(
145 |                 $app['excel.readers.html']
146 |             );
147 |         });
148 |     }
149 | 
150 |     /**
151 |      * Bind writers
152 |      * @return void
153 |      */
154 |     protected function bindWriters()
155 |     {
156 |         // Bind the excel writer
157 |         $this->app['excel.writer'] = $this->app->share(function ($app)
158 |         {
159 |             return new LaravelExcelWriter(
160 |                 $app->make('Response'),
161 |                 $app['files'],
162 |                 $app['excel.identifier']
163 |             );
164 |         });
165 |     }
166 | 
167 |     /**
168 |      * Bind Excel class
169 |      * @return void
170 |      */
171 |     protected function bindExcel()
172 |     {
173 |         // Bind the Excel class and inject its dependencies
174 |         $this->app['excel'] = $this->app->share(function ($app)
175 |         {
176 |             $excel = new Excel(
177 |                 $app['phpexcel'],
178 |                 $app['excel.reader'],
179 |                 $app['excel.writer'],
180 |                 $app['excel.parsers.view']
181 |             );
182 | 
183 |             $excel->registerFilters($app['config']->get('excel.filters', array()));
184 | 
185 |             return $excel;
186 |         });
187 |     }
188 | 
189 |     /**
190 |      * Bind other classes
191 |      * @return void
192 |      */
193 |     protected function bindClasses()
194 |     {
195 |         // Bind the format identifier
196 |         $this->app['excel.identifier'] = $this->app->share(function ($app)
197 |         {
198 |             return new FormatIdentifier($app['files']);
199 |         });
200 |     }
201 | 
202 |     /**
203 |      * Set cache settings
204 |      * @return Cache
205 |      */
206 |     public function setCacheSettings()
207 |     {
208 |         return new Cache();
209 |     }
210 | 
211 |     /**
212 |      * Set locale
213 |      */
214 |     public function setLocale()
215 |     {
216 |         $locale = Config::get('app.locale', 'en_us');
217 |         PHPExcel_Settings::setLocale($locale);
218 |     }
219 | 
220 |     /**
221 |      * Set the autosizing settings
222 |      */
223 |     public function setAutoSizingSettings()
224 |     {
225 |         $method = Config::get('excel.export.autosize-method', PHPExcel_Shared_Font::AUTOSIZE_METHOD_APPROX);
226 |         PHPExcel_Shared_Font::setAutoSizeMethod($method);
227 |     }
228 | 
229 |     /**
230 |      * Get the services provided by the provider.
231 |      *
232 |      * @return array
233 |      */
234 |     public function provides()
235 |     {
236 |         return array(
237 |             'excel',
238 |             'phpexcel',
239 |             'excel.reader',
240 |             'excel.readers.html',
241 |             'excel.parsers.view',
242 |             'excel.writer'
243 |         );
244 |     }
245 | }
246 | 


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Exceptions/LaravelExcelException.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Maatwebsite\Excel\Exceptions;
 2 | 
 3 | use PHPExcel_Exception;
 4 | 
 5 | /**
 6 |  *
 7 |  * LaravelExcel Exception
 8 |  *
 9 |  * @category   Laravel Excel
10 |  * @version    1.0.0
11 |  * @package    maatwebsite/excel
12 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
13 |  * @author     Maatwebsite <info@maatwebsite.nl>
14 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
15 |  */
16 | class LaravelExcelException extends PHPExcel_Exception {
17 | 
18 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Facades/Excel.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Maatwebsite\Excel\Facades;
 2 | 
 3 | use Illuminate\Support\Facades\Facade;
 4 | 
 5 | /**
 6 |  *
 7 |  * LaravelExcel Facade
 8 |  *
 9 |  * @category   Laravel Excel
10 |  * @version    1.0.0
11 |  * @package    maatwebsite/excel
12 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
13 |  * @author     Maatwebsite <info@maatwebsite.nl>
14 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
15 |  */
16 | class Excel extends Facade {
17 | 
18 |     /**
19 |      * Return facade accessor
20 |      * @return string
21 |      */
22 |     protected static function getFacadeAccessor()
23 |     {
24 |         return 'excel';
25 |     }
26 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Files/ExcelFile.php:
--------------------------------------------------------------------------------
  1 | <?php namespace Maatwebsite\Excel\Files;
  2 | 
  3 | use Illuminate\Foundation\Application;
  4 | use Maatwebsite\Excel\Excel;
  5 | use Maatwebsite\Excel\Exceptions\LaravelExcelException;
  6 | 
  7 | abstract class ExcelFile extends File {
  8 | 
  9 |     /**
 10 |      * @var bool|string
 11 |      */
 12 |     protected $delimiter;
 13 | 
 14 |     /**
 15 |      * @var bool|string
 16 |      */
 17 |     protected $enclosure;
 18 | 
 19 |     /**
 20 |      * @param Application $app
 21 |      * @param Excel       $excel
 22 |      */
 23 |     public function __construct(Application $app, Excel $excel)
 24 |     {
 25 |         parent::__construct($app, $excel);
 26 |         $this->file = $this->loadFile();
 27 |     }
 28 | 
 29 |     /**
 30 |      * Get file
 31 |      * @return string
 32 |      */
 33 |     abstract public function getFile();
 34 | 
 35 |     /**
 36 |      * Get delimiter
 37 |      * @return string
 38 |      */
 39 |     protected function getDelimiter()
 40 |     {
 41 |         return $this->delimiter;
 42 |     }
 43 | 
 44 |     /**
 45 |      * Get enclosure
 46 |      * @return string
 47 |      */
 48 |     protected function getEnclosure()
 49 |     {
 50 |         return $this->enclosure;
 51 |     }
 52 | 
 53 |     /**
 54 |      * Get filters
 55 |      * @return array
 56 |      */
 57 |     public function getFilters()
 58 |     {
 59 |         return [];
 60 |     }
 61 | 
 62 |     /**
 63 |      * Start importing
 64 |      */
 65 |     public function handleImport()
 66 |     {
 67 |         return $this->handle('Import');
 68 |     }
 69 | 
 70 |     /**
 71 |      * Load the file
 72 |      * @return \Maatwebsite\Excel\Readers\LaravelExcelReader
 73 |      */
 74 |     public function loadFile()
 75 |     {
 76 |         // Load filters
 77 |         $this->loadFilters();
 78 | 
 79 |         // Load base settings
 80 |         $this->loadBaseSettings();
 81 | 
 82 |         // Load the file
 83 |         $file = $this->excel->load(
 84 |             $this->getFile()
 85 |         );
 86 | 
 87 |         return $file;
 88 |     }
 89 | 
 90 |     /**
 91 |      * Load the filter
 92 |      * @return void
 93 |      */
 94 |     protected function loadFilters()
 95 |     {
 96 |         // Register the filters
 97 |         $this->excel->registerFilters(
 98 |             $this->getFilters()
 99 |         );
100 | 
101 |         // Loop through the filters
102 |         foreach($this->getFilters() as $filter)
103 |         {
104 |             // Enable the filter
105 |             $this->excel->filter($filter);
106 |         }
107 |     }
108 | 
109 |     /**
110 |      * Load base settings
111 |      */
112 |     protected function loadBaseSettings()
113 |     {
114 |         $this->loadCSVSettings();
115 |     }
116 | 
117 |     /**
118 |      * Load CSV Settings
119 |      */
120 |     protected function loadCSVSettings()
121 |     {
122 |         // Get user provided delimiter
123 |         $delimiter = $this->getDelimiter();
124 | 
125 |         // Set it when given
126 |         if($delimiter)
127 |             $this->excel->setDelimiter($delimiter);
128 | 
129 |         // Get user provided enclosure
130 |         $enclosure = $this->getEnclosure();
131 | 
132 |         // Set it when given
133 |         if($enclosure)
134 |             $this->excel->setEnclosure($enclosure);
135 |     }
136 | 
137 |     /**
138 |      * Dynamically call methods
139 |      * @param  string $method
140 |      * @param  array  $params
141 |      * @return mixed
142 |      */
143 |     public function __call($method, $params)
144 |     {
145 |         return call_user_func_array([$this->file, $method], $params);
146 |     }
147 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Files/ExportHandler.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Maatwebsite\Excel\Files;
 2 | 
 3 | interface ExportHandler {
 4 | 
 5 |     /**
 6 |      * Handle the export
 7 |      * @param $file
 8 |      * @return mixed
 9 |      */
10 |     public function handle($file);
11 | 
12 | } 


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Files/File.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Maatwebsite\Excel\Files;
 2 | 
 3 | use Illuminate\Foundation\Application;
 4 | use Maatwebsite\Excel\Excel;
 5 | use Maatwebsite\Excel\Exceptions\LaravelExcelException;
 6 | 
 7 | abstract class File {
 8 | 
 9 |     /**
10 |      * @var Application
11 |      */
12 |     protected $app;
13 | 
14 |     /**
15 |      * Excel instance
16 |      * @var Excel
17 |      */
18 |     protected $excel;
19 | 
20 |     /**
21 |      * Loaded file
22 |      * @var \Maatwebsite\Excel\Readers\LaravelExcelReader
23 |      */
24 |     protected $file;
25 | 
26 |     /**
27 |      * @param Application $app
28 |      * @param Excel       $excel
29 |      */
30 |     public function __construct(Application $app, Excel $excel)
31 |     {
32 |         $this->app = $app;
33 |         $this->excel = $excel;
34 |     }
35 | 
36 |     /**
37 |      * Handle the import/export of the file
38 |      * @param $type
39 |      * @throws LaravelExcelException
40 |      * @return mixed
41 |      */
42 |     public function handle($type)
43 |     {
44 |         // Get the handler
45 |         $handler = $this->getHandler($type);
46 | 
47 |         // Call the handle method and inject the file
48 |         return $handler->handle($this);
49 |     }
50 | 
51 |     /**
52 |      * Get handler
53 |      * @param $type
54 |      * @throws LaravelExcelException
55 |      * @return mixed
56 |      */
57 |     protected function getHandler($type)
58 |     {
59 |         return $this->app->make(
60 |             $this->getHandlerClassName($type)
61 |         );
62 |     }
63 | 
64 |     /**
65 |      * Get the file instance
66 |      * @return mixed
67 |      */
68 |     public function getFileInstance()
69 |     {
70 |         return $this->file;
71 |     }
72 | 
73 |     /**
74 |      * Get the handler class name
75 |      * @throws LaravelExcelException
76 |      * @return string
77 |      */
78 |     protected function getHandlerClassName($type)
79 |     {
80 |         // Translate the file into a FileHandler
81 |         $class = get_class($this);
82 |         $handler = substr_replace($class, $type . 'Handler', strrpos($class, $type));
83 | 
84 |         // Check if the handler exists
85 |         if (!class_exists($handler))
86 |             throw new LaravelExcelException("$type handler [$handler] does not exist.");
87 | 
88 |         return $handler;
89 |     }
90 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Files/ImportHandler.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Maatwebsite\Excel\Files;
 2 | 
 3 | interface ImportHandler {
 4 | 
 5 |     /**
 6 |      * Handle the import
 7 |      * @param $file
 8 |      * @return mixed
 9 |      */
10 |     public function handle($file);
11 | 
12 | } 


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Files/NewExcelFile.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Maatwebsite\Excel\Files;
 2 | 
 3 | use Illuminate\Foundation\Application;
 4 | use Maatwebsite\Excel\Excel;
 5 | 
 6 | abstract class NewExcelFile extends File {
 7 | 
 8 |     /**
 9 |      * @param Application $app
10 |      * @param Excel       $excel
11 |      */
12 |     public function __construct(Application $app, Excel $excel)
13 |     {
14 |         parent::__construct($app, $excel);
15 |         $this->file = $this->createNewFile();
16 |     }
17 | 
18 |     /**
19 |      * Get file
20 |      * @return string
21 |      */
22 |     abstract public function getFilename();
23 | 
24 |     /**
25 |      * Start importing
26 |      */
27 |     public function handleExport()
28 |     {
29 |         return $this->handle('Export');
30 |     }
31 | 
32 | 
33 |     /**
34 |      * Load the file
35 |      * @return \Maatwebsite\Excel\Readers\LaravelExcelReader
36 |      */
37 |     public function createNewFile()
38 |     {
39 |         // Load the file
40 |         $file = $this->excel->create(
41 |             $this->getFilename()
42 |         );
43 | 
44 |         return $file;
45 |     }
46 | 
47 |     /**
48 |      * Dynamically call methods
49 |      * @param  string $method
50 |      * @param  array  $params
51 |      * @return mixed
52 |      */
53 |     public function __call($method, $params)
54 |     {
55 |         return call_user_func_array([$this->file, $method], $params);
56 |     }
57 | 
58 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Filters/ChunkReadFilter.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Maatwebsite\Excel\Filters;
 2 | 
 3 | use PHPExcel_Reader_IReadFilter;
 4 | 
 5 | class ChunkReadFilter implements PHPExcel_Reader_IReadFilter
 6 | {
 7 |     /**
 8 |      * Start row
 9 |      * @var integer
10 |      */
11 |     private $_startRow = 0;
12 | 
13 |     /**
14 |      * End row
15 |      * @var integer
16 |      */
17 |     private $_endRow = 0;
18 | 
19 |     /**
20 |      * Set the list of rows that we want to read
21 |      * @param   integer $startRow
22 |      * @param   integer $chunkSize
23 |      * @return  void
24 |      */
25 |     public function setRows($startRow, $chunkSize)
26 |     {
27 |         $this->_startRow = $startRow;
28 |         $this->_endRow   = $startRow + $chunkSize;
29 |     }
30 | 
31 |     /**
32 |      * Read the cell
33 |      * @param  string   $column
34 |      * @param  integer  $row
35 |      * @param  string   $worksheetName
36 |      * @return booleaan
37 |      */
38 |     public function readCell($column, $row, $worksheetName = '')
39 |     {
40 |         //  Only read the heading row, and the rows that are configured in $this->_startRow and $this->_endRow
41 |         if (($row == config('excel.import.startRow')) || ($row >= $this->_startRow && $row <= $this->_endRow)) {
42 |             return true;
43 |         }
44 |         return false;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Parsers/CssParser.php:
--------------------------------------------------------------------------------
  1 | <?php namespace Maatwebsite\Excel\Parsers;
  2 | 
  3 | use DOMDocument;
  4 | use Illuminate\Support\Facades\URL;
  5 | use TijsVerkoyen\CssToInlineStyles\CssToInlineStyles;
  6 | 
  7 | /**
  8 |  *
  9 |  * LaravelExcel CSS Parser
 10 |  *
 11 |  * @category   Laravel Excel
 12 |  * @version    1.0.0
 13 |  * @package    maatwebsite/excel
 14 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
 15 |  * @author     Maatwebsite <info@maatwebsite.nl>
 16 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
 17 |  */
 18 | class CssParser {
 19 | 
 20 |     /**
 21 |      * @var CssToInlineStyles
 22 |      */
 23 |     protected $cssInliner;
 24 | 
 25 |     /**
 26 |      * DOM xml
 27 |      * @var \SimpleXMLElement
 28 |      */
 29 |     protected $xml;
 30 | 
 31 |     /**
 32 |      * Style sheet links
 33 |      * @var array
 34 |      */
 35 |     protected $links = array();
 36 | 
 37 |     /**
 38 |      * Construct the css parser
 39 |      * @param CssToInlineStyles $cssInliner
 40 |      */
 41 |     public function __construct(CssToInlineStyles $cssInliner)
 42 |     {
 43 |         $this->cssInliner = $cssInliner;
 44 |     }
 45 | 
 46 |     /**
 47 |      * Transform the found css to inline styles
 48 |      */
 49 |     public function transformCssToInlineStyles($html)
 50 |     {
 51 |         // Clean-up html
 52 |         $this->cssInliner->setCleanup(true);
 53 | 
 54 |         // Set html
 55 |         $this->cssInliner->setHtml($html);
 56 | 
 57 |         // Use inline style blocks
 58 |         $this->cssInliner->setUseInlineStylesBlock(true);
 59 | 
 60 |         // Loop through all stylesheets
 61 |         foreach($this->links as $link)
 62 |         {
 63 |             $css = file_get_contents($link);
 64 |             $this->cssInliner->setCSS($css);
 65 |         }
 66 | 
 67 |         return $this->cssInliner->convert();
 68 |     }
 69 | 
 70 |     /**
 71 |      * Find the stylesheets inside the view
 72 |      * @param DOMDocument $dom
 73 |      * @return CssParser
 74 |      */
 75 |     public function findStyleSheets(DOMDocument $dom)
 76 |     {
 77 |         // Import the dom
 78 |         $this->importDom($dom);
 79 | 
 80 |         // Get all stylesheet tags
 81 |         $tags = $this->getStyleSheetTags();
 82 | 
 83 |         foreach ($tags as $node)
 84 |         {
 85 |             $this->links[] = $this->getCleanStyleSheetLink($node);
 86 |         }
 87 | 
 88 |         // We don't need duplicate css files
 89 |         $this->links = array_unique($this->links);
 90 | 
 91 |         return $this;
 92 |     }
 93 | 
 94 |     /**
 95 |      * Import the dom
 96 |      * @return SimpleXMLElement
 97 |      */
 98 |     protected function importDom(DOMDocument $dom)
 99 |     {
100 |         return $this->xml = simplexml_import_dom($dom);
101 |     }
102 | 
103 |     /**
104 |      * Get all stylesheet tags
105 |      * @return array
106 |      */
107 |     protected function getStyleSheetTags()
108 |     {
109 |         return $this->xml->xpath('//link[@rel="stylesheet"]');
110 |     }
111 | 
112 |     /**
113 |      * Get the clean link to the stylesheet
114 |      * @param  string $node
115 |      * @return string
116 |      */
117 |     protected function getCleanStyleSheetLink($node)
118 |     {
119 |         // Get the link
120 |         $link = $node->attributes()->href;
121 | 
122 |         return url($link);
123 |     }
124 | 
125 |     /**
126 |      * Get css from link
127 |      * @param  string $link
128 |      * @return string|boolean
129 |      */
130 |     protected function getCssFromLink($link)
131 |     {
132 |         return file_get_contents($link);
133 |     }
134 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Parsers/ViewParser.php:
--------------------------------------------------------------------------------
  1 | <?php namespace Maatwebsite\Excel\Parsers;
  2 | 
  3 | use Maatwebsite\Excel\Readers\Html;
  4 | use Illuminate\Support\Facades\View;
  5 | 
  6 | /**
  7 |  *
  8 |  * LaravelExcel ViewParser
  9 |  *
 10 |  * @category   Laravel Excel
 11 |  * @version    1.0.0
 12 |  * @package    maatwebsite/excel
 13 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
 14 |  * @author     Maatwebsite <info@maatwebsite.nl>
 15 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
 16 |  */
 17 | class ViewParser {
 18 | 
 19 |     /**
 20 |      * View file
 21 |      * @var string
 22 |      */
 23 |     public $view;
 24 | 
 25 |     /**
 26 |      * Data array
 27 |      * @var array
 28 |      */
 29 |     public $data = array();
 30 | 
 31 |     /**
 32 |      * View merge data
 33 |      * @var array
 34 |      */
 35 |     public $mergeData = array();
 36 | 
 37 |     /**
 38 |      * Construct the view parser
 39 |      * @param Html $reader
 40 |      * @return \Maatwebsite\Excel\Parsers\ViewParser
 41 |      */
 42 |     public function __construct(Html $reader)
 43 |     {
 44 |         $this->reader = $reader;
 45 |     }
 46 | 
 47 |     /**
 48 |      * Parse the view
 49 |      * @param  \Maatwebsite\Excel\Classes\LaravelExcelWorksheet $sheet
 50 |      * @return \Maatwebsite\Excel\Classes\LaravelExcelWorksheet
 51 |      */
 52 |     public function parse($sheet)
 53 |     {
 54 |         $html = View::make($this->getView(), $this->getData(), $this->getMergeData())->render();
 55 | 
 56 |         return $this->_loadHTML($sheet, $html);
 57 |     }
 58 | 
 59 |     /**
 60 |      * Load the HTML
 61 |      * @param  \Maatwebsite\Excel\Classes\LaravelExcelWorksheet $sheet
 62 |      * @param  string                                           $html
 63 |      * @return \Maatwebsite\Excel\Classes\LaravelExcelWorksheet
 64 |      */
 65 |     protected function _loadHTML($sheet, $html)
 66 |     {
 67 |         return $this->reader->load($html, true, $sheet);
 68 |     }
 69 | 
 70 |     /**
 71 |      * Get the view
 72 |      * @return string
 73 |      */
 74 |     public function getView()
 75 |     {
 76 |         return $this->view;
 77 |     }
 78 | 
 79 |     /**
 80 |      * Get data
 81 |      * @return array
 82 |      */
 83 |     public function getData()
 84 |     {
 85 |         return $this->data;
 86 |     }
 87 | 
 88 |     /**
 89 |      * Get merge data
 90 |      * @return array
 91 |      */
 92 |     public function getMergeData()
 93 |     {
 94 |         return $this->mergeData;
 95 |     }
 96 | 
 97 |     /**
 98 |      * Set the view
 99 |      * @param bool|string $view
100 |      */
101 |     public function setView($view = false)
102 |     {
103 |         if ($view)
104 |             $this->view = $view;
105 |     }
106 | 
107 |     /**
108 |      * Set the data
109 |      * @param array $data
110 |      */
111 |     public function setData($data = array())
112 |     {
113 |         if (!empty($data))
114 |             $this->data = array_merge($this->data, $data);
115 |     }
116 | 
117 |     /**
118 |      * Set the merge data
119 |      * @param array $mergeData
120 |      */
121 |     public function setMergeData($mergeData = array())
122 |     {
123 |         if (!empty($mergeData))
124 |             $this->mergeData = array_merge($this->mergeData, $mergeData);
125 |     }
126 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Readers/Batch.php:
--------------------------------------------------------------------------------
  1 | <?php namespace Maatwebsite\Excel\Readers;
  2 | 
  3 | use Closure;
  4 | use Maatwebsite\Excel\Excel;
  5 | use Maatwebsite\Excel\Exceptions\LaravelExcelException;
  6 | 
  7 | /**
  8 |  *
  9 |  * LaravelExcel Batch Importer
 10 |  *
 11 |  * @category   Laravel Excel
 12 |  * @version    1.0.0
 13 |  * @package    maatwebsite/excel
 14 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
 15 |  * @author     Maatwebsite <info@maatwebsite.nl>
 16 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
 17 |  */
 18 | class Batch {
 19 | 
 20 |     /**
 21 |      * Excel object
 22 |      * @var Excel
 23 |      */
 24 |     protected $excel;
 25 | 
 26 |     /**
 27 |      * Batch files
 28 |      * @var array
 29 |      */
 30 |     public $files = array();
 31 | 
 32 |     /**
 33 |      * Set allowed file extensions
 34 |      * @var array
 35 |      */
 36 |     protected $allowedFileExtensions = array(
 37 |         'xls',
 38 |         'xlsx',
 39 |         'csv'
 40 |     );
 41 | 
 42 |     /**
 43 |      * Start the Batach
 44 |      * @param  Excel   $excel
 45 |      * @param  array   $files
 46 |      * @param  Closure $callback
 47 |      * @return Excel
 48 |      */
 49 |     public function start(Excel $excel, $files, Closure $callback)
 50 |     {
 51 |         // Set excel object
 52 |         $this->excel = $excel;
 53 | 
 54 |         // Set files
 55 |         $this->_setFiles($files);
 56 | 
 57 |         // Do the callback
 58 |         if ($callback instanceof Closure)
 59 |         {
 60 |             foreach ($this->getFiles() as $file)
 61 |             {
 62 |                 // Load the file
 63 |                 $excel = $this->excel->load($file);
 64 | 
 65 |                 // Do a callback with the loaded file
 66 |                 call_user_func($callback, $excel, $file);
 67 |             }
 68 |         }
 69 | 
 70 |         // Return our excel object
 71 |         return $this->excel;
 72 |     }
 73 | 
 74 |     /**
 75 |      * Get the files
 76 |      * @return array
 77 |      */
 78 |     public function getFiles()
 79 |     {
 80 |         return $this->files;
 81 |     }
 82 | 
 83 |     /**
 84 |      * Set the batch files
 85 |      * @param array|string $files
 86 |      * @throws LaravelExcelException
 87 |      * @return void
 88 |      */
 89 |     protected function _setFiles($files)
 90 |     {
 91 |         // If the param is an array, these will be the files for the batch import
 92 |         if (is_array($files))
 93 |         {
 94 |             $this->files = $this->_getFilesByArray($files);
 95 |         }
 96 | 
 97 |         // Get all the files inside a folder
 98 |         elseif (is_string($files))
 99 |         {
100 |             $this->files = $this->_getFilesByFolder($files);
101 |         }
102 | 
103 |         // Check if files were found
104 |         if (empty($this->files))
105 |             throw new LaravelExcelException('[ERROR]: No files were found. Batch terminated.');
106 |     }
107 | 
108 |     /**
109 |      * Set files by array
110 |      * @param  array $array
111 |      * @return array
112 |      */
113 |     protected function _getFilesByArray($array)
114 |     {
115 |         $files = array();
116 |         // Make sure we have real paths
117 |         foreach ($array as $i => $file)
118 |         {
119 |             $files[$i] = realpath($file) ? $file : base_path($file);
120 |         }
121 | 
122 |         return $files;
123 |     }
124 | 
125 |     /**
126 |      * Get all files inside a folder
127 |      * @param  string $folder
128 |      * @return array
129 |      */
130 |     protected function _getFilesByFolder($folder)
131 |     {
132 |         // Check if it's a real path
133 |         if (!realpath($folder))
134 |             $folder = base_path($folder);
135 | 
136 |         // Find path names matching our pattern of excel extensions
137 |         $glob = glob($folder . '/*.{' . implode(',', $this->allowedFileExtensions) . '}', GLOB_BRACE);
138 | 
139 |         // If no matches, return empty array
140 |         if ($glob === false) return array();
141 | 
142 |         // Return files
143 |         return array_filter($glob, function ($file)
144 |         {
145 |             return filetype($file) == 'file';
146 |         });
147 |     }
148 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Readers/ConfigReader.php:
--------------------------------------------------------------------------------
  1 | <?php namespace Maatwebsite\Excel\Readers;
  2 | 
  3 | use Closure;
  4 | use PHPExcel;
  5 | use Maatwebsite\Excel\Excel;
  6 | use Illuminate\Support\Facades\Config;
  7 | use Maatwebsite\Excel\Collections\SheetCollection;
  8 | use Maatwebsite\Excel\Exceptions\LaravelExcelException;
  9 | 
 10 | /**
 11 |  *
 12 |  * LaravelExcel ConfigReader
 13 |  *
 14 |  * @category   Laravel Excel
 15 |  * @version    1.0.0
 16 |  * @package    maatwebsite/excel
 17 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
 18 |  * @author     Maatwebsite <info@maatwebsite.nl>
 19 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
 20 |  */
 21 | class ConfigReader {
 22 | 
 23 |     /**
 24 |      * Excel object
 25 |      * @var PHPExcel
 26 |      */
 27 |     public $excel;
 28 | 
 29 |     /**
 30 |      * The sheet
 31 |      * @var LaravelExcelWorksheet
 32 |      */
 33 |     public $sheet;
 34 | 
 35 |     /**
 36 |      * The sheetname
 37 |      * @var string
 38 |      */
 39 |     public $sheetName;
 40 | 
 41 |     /**
 42 |      * Collection of sheets (through the config reader)
 43 |      * @var SheetCollection
 44 |      */
 45 |     public $sheetCollection;
 46 | 
 47 |     /**
 48 |      * Constructor
 49 |      * @param PHPExcel $excel
 50 |      * @param string   $config
 51 |      * @param callback $callback
 52 |      */
 53 |     public function __construct(PHPExcel $excel, $config = 'excel.import', $callback = null)
 54 |     {
 55 |         // Set excel object
 56 |         $this->excel = $excel;
 57 | 
 58 |         // config name
 59 |         $this->configName = $config;
 60 | 
 61 |         // start
 62 |         $this->start($callback);
 63 |     }
 64 | 
 65 |     /**
 66 |      * Start the import
 67 |      * @param bool|callable $callback $callback
 68 |      * @throws \PHPExcel_Exception
 69 |      * @return void
 70 |      */
 71 |     public function start($callback = false)
 72 |     {
 73 |         // Init a new sheet collection
 74 |         $this->sheetCollection = new SheetCollection();
 75 | 
 76 |         // Get the sheet names
 77 |         if ($sheets = $this->excel->getSheetNames())
 78 |         {
 79 |             // Loop through the sheets
 80 |             foreach ($sheets as $index => $name)
 81 |             {
 82 |                 // Set sheet name
 83 |                 $this->sheetName = $name;
 84 | 
 85 |                 // Set sheet
 86 |                 $this->sheet = $this->excel->setActiveSheetIndex($index);
 87 | 
 88 |                 // Do the callback
 89 |                 if ($callback instanceof Closure)
 90 |                 {
 91 |                     call_user_func($callback, $this);
 92 |                 }
 93 |                 // If no callback, put it inside the sheet collection
 94 |                 else
 95 |                 {
 96 |                     $this->sheetCollection->push(clone $this);
 97 |                 }
 98 |             }
 99 |         }
100 |     }
101 | 
102 |     /**
103 |      * Get the sheet collection
104 |      * @return SheetCollection
105 |      */
106 |     public function getSheetCollection()
107 |     {
108 |         return $this->sheetCollection;
109 |     }
110 | 
111 |     /**
112 |      * Get value by index
113 |      * @param  string $field
114 |      * @return string|null
115 |      */
116 |     protected function valueByIndex($field)
117 |     {
118 |         // Convert field name
119 |         $field = snake_case($field);
120 | 
121 |         // Get coordinate
122 |         if ($coordinate = $this->getCoordinateByKey($field))
123 |         {
124 |             // return cell value by coordinate
125 |             return $this->getCellValueByCoordinate($coordinate);
126 |         }
127 | 
128 |         return null;
129 |     }
130 | 
131 |     /**
132 |      * Return cell value
133 |      * @param  string $coordinate
134 |      * @return string|null
135 |      */
136 |     protected function getCellValueByCoordinate($coordinate)
137 |     {
138 |         if ($this->sheet)
139 |         {
140 |             if (str_contains($coordinate, ':'))
141 |             {
142 |                 // We want to get a range of cells
143 |                 $values = $this->sheet->rangeToArray($coordinate);
144 | 
145 |                 return $values;
146 |             }
147 |             else
148 |             {
149 |                 // We want 1 specific cell
150 |                 return $this->sheet->getCell($coordinate)->getValue();
151 |             }
152 |         }
153 | 
154 |         return null;
155 |     }
156 | 
157 |     /**
158 |      * Get the coordinates from the config file
159 |      * @param  string $field
160 |      * @return string|boolean
161 |      */
162 |     protected function getCoordinateByKey($field)
163 |     {
164 |         return Config::get($this->configName . '.' . $this->sheetName . '.' . $field, false);
165 |     }
166 | 
167 |     /**
168 |      * Dynamically get a value by config
169 |      * @param  string $field
170 |      * @return string
171 |      */
172 |     public function __get($field)
173 |     {
174 |         return $this->valueByIndex($field);
175 |     }
176 | }


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Writers/CellWriter.php:
--------------------------------------------------------------------------------
  1 | <?php namespace Maatwebsite\Excel\Writers;
  2 | 
  3 | use Maatwebsite\Excel\Classes\LaravelExcelWorksheet;
  4 | 
  5 | /**
  6 |  *
  7 |  * LaravelExcel Excel writer
  8 |  *
  9 |  * @category   Laravel Excel
 10 |  * @version    1.0.0
 11 |  * @package    maatwebsite/excel
 12 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
 13 |  * @author     Maatwebsite <info@maatwebsite.nl>
 14 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
 15 |  */
 16 | class CellWriter {
 17 | 
 18 |     /**
 19 |      * Current $sheet
 20 |      * @var LaravelExcelWorksheet
 21 |      */
 22 |     public $sheet;
 23 | 
 24 |     /**
 25 |      * Selected cells
 26 |      * @var array
 27 |      */
 28 |     public $cells;
 29 | 
 30 |     /**
 31 |      * Constructor
 32 |      * @param array                 $cells
 33 |      * @param LaravelExcelWorksheet $sheet
 34 |      */
 35 |     public function __construct($cells, LaravelExcelWorksheet $sheet)
 36 |     {
 37 |         $this->cells = $cells;
 38 |         $this->sheet = $sheet;
 39 |     }
 40 | 
 41 |     /**
 42 |      * Set cell value
 43 |      * @param [type] $value
 44 |      * @return  CellWriter
 45 |      */
 46 |     public function setValue($value)
 47 |     {
 48 |         // Only set cell value for single cells
 49 |         if (!str_contains($this->cells, ':'))
 50 |         {
 51 |             $this->sheet->setCellValue($this->cells, $value);
 52 |         }
 53 | 
 54 |         return $this;
 55 |     }
 56 | 
 57 |     /**
 58 |      * Set the background
 59 |      * @param string $color
 60 |      * @param string $type
 61 |      * @param string $colorType
 62 |      * @return  CellWriter
 63 |      */
 64 |     public function setBackground($color, $type = 'solid', $colorType = 'rgb')
 65 |     {
 66 |         return $this->setColorStyle('fill', $color, $type, $colorType);
 67 |     }
 68 | 
 69 |     /**
 70 |      * Set the font color
 71 |      * @param string $color
 72 |      * @param string $colorType
 73 |      * @return  CellWriter
 74 |      */
 75 |     public function setFontColor($color, $colorType = 'rgb')
 76 |     {
 77 |         return $this->setColorStyle('font', $color, false, $colorType);
 78 |     }
 79 | 
 80 |     /**
 81 |      * Set the font
 82 |      * @param $styles
 83 |      * @return  CellWriter
 84 |      */
 85 |     public function setFont($styles)
 86 |     {
 87 |         return $this->setStyle('font', $styles);
 88 |     }
 89 | 
 90 |     /**
 91 |      * Set font family
 92 |      * @param string $family
 93 |      * @return  CellWriter
 94 |      */
 95 |     public function setFontFamily($family)
 96 |     {
 97 |         return $this->setStyle('font', array(
 98 |             'name' => $family
 99 |         ));
100 |     }
101 | 
102 |     /**
103 |      * Set font size
104 |      * @param  string $size
105 |      * @return  CellWriter
106 |      */
107 |     public function setFontSize($size)
108 |     {
109 |         return $this->setStyle('font', array(
110 |             'size' => $size
111 |         ));
112 |     }
113 | 
114 |     /**
115 |      * Set font weight
116 |      * @param  boolean|string $bold
117 |      * @return  CellWriter
118 |      */
119 |     public function setFontWeight($bold = true)
120 |     {
121 |         return $this->setStyle('font', array(
122 |             'bold' => ($bold == 'bold' || $bold) ? true : false
123 |         ));
124 |     }
125 | 
126 |     /**
127 |      * Set border
128 |      * @param string      $top
129 |      * @param bool|string $right
130 |      * @param bool|string $bottom
131 |      * @param bool|string $left
132 |      * @return  CellWriter
133 |      */
134 |     public function setBorder($top = 'none', $right = 'none', $bottom = 'none', $left = 'none')
135 |     {
136 |         // Set the border styles
137 |         $styles = is_array($top) ? $top : array(
138 |             'top'    => array(
139 |                 'style' => $top
140 |             ),
141 |             'left'   => array(
142 |                 'style' => $left,
143 |             ),
144 |             'right'  => array(
145 |                 'style' => $right,
146 |             ),
147 |             'bottom' => array(
148 |                 'style' => $bottom,
149 |             )
150 |         );
151 | 
152 |         return $this->setStyle('borders', $styles);
153 |     }
154 | 
155 |     /**
156 |      * Set the alignment
157 |      * @param string $alignment
158 |      * @return  CellWriter
159 |      */
160 |     public function setAlignment($alignment)
161 |     {
162 |         return $this->setStyle('alignment', array(
163 |             'horizontal' => $alignment
164 |         ));
165 |     }
166 | 
167 |     /**
168 |      * Set vertical alignment
169 |      * @param string $alignment
170 |      * @return  CellWriter
171 |      */
172 |     public function setValignment($alignment)
173 |     {
174 |         return $this->setStyle('alignment', array(
175 |             'vertical' => $alignment
176 |         ));
177 |     }
178 | 
179 |     /**
180 |      * Set the color style
181 |      * @param         $styleType
182 |      * @param string  $color
183 |      * @param boolean $type
184 |      * @param string  $colorType
185 |      * @return  CellWriter
186 |      */
187 |     protected function setColorStyle($styleType, $color, $type = false, $colorType = 'rgb')
188 |     {
189 |         // Set the styles
190 |         $styles = is_array($color) ? $color : array(
191 |             'type'  => $type,
192 |             'color' => array($colorType => str_replace('#', '', $color))
193 |         );
194 | 
195 |         return $this->setStyle($styleType, $styles);
196 |     }
197 | 
198 |     /**
199 |      * Set style
200 |      * @param        $styleType
201 |      * @param string $styles
202 |      * @return  CellWriter
203 |      */
204 |     protected function setStyle($styleType, $styles)
205 |     {
206 |         // Get the cell style
207 |         $style = $this->getCellStyle();
208 | 
209 |         // Apply style from array
210 |         $style->applyFromArray(array(
211 |             $styleType => $styles
212 |         ));
213 | 
214 |         return $this;
215 |     }
216 | 
217 |     /**
218 |      * Get the cell style
219 |      * @return \PHPExcel_Style
220 |      */
221 |     protected function getCellStyle()
222 |     {
223 |         return $this->sheet->getStyle($this->cells);
224 |     }
225 | }
226 | 


--------------------------------------------------------------------------------
/src/Maatwebsite/Excel/Writers/LaravelExcelWriter.php:
--------------------------------------------------------------------------------
  1 | <?php namespace Maatwebsite\Excel\Writers;
  2 | 
  3 | use Closure;
  4 | use Carbon\Carbon;
  5 | use PHPExcel_IOFactory;
  6 | use Illuminate\Filesystem\Filesystem;
  7 | use Illuminate\Support\Facades\Config;
  8 | use Illuminate\Support\Facades\Response;
  9 | use Maatwebsite\Excel\Classes\FormatIdentifier;
 10 | use Maatwebsite\Excel\Classes\LaravelExcelWorksheet;
 11 | use Maatwebsite\Excel\Exceptions\LaravelExcelException;
 12 | 
 13 | /**
 14 |  *
 15 |  * LaravelExcel Excel writer
 16 |  *
 17 |  * @category   Laravel Excel
 18 |  * @version    1.0.0
 19 |  * @package    maatwebsite/excel
 20 |  * @copyright  Copyright (c) 2013 - 2014 Maatwebsite (http://www.maatwebsite.nl)
 21 |  * @author     Maatwebsite <info@maatwebsite.nl>
 22 |  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
 23 |  */
 24 | class LaravelExcelWriter {
 25 | 
 26 |     /**
 27 |      * Spreadsheet filename
 28 |      * @var string
 29 |      */
 30 |     public $filename;
 31 | 
 32 |     /**
 33 |      * Spreadsheet title
 34 |      * @var string
 35 |      */
 36 |     public $title;
 37 | 
 38 |     /**
 39 |      * Excel object
 40 |      * @var \PHPExcel
 41 |      */
 42 |     public $excel;
 43 | 
 44 |     /**
 45 |      * Laravel response
 46 |      * @var Response
 47 |      */
 48 |     protected $response;
 49 | 
 50 |     /**
 51 |      * Spreadsheet writer
 52 |      * @var object
 53 |      */
 54 |     public $writer;
 55 | 
 56 |     /**
 57 |      * Excel sheet
 58 |      * @var LaravelExcelWorksheet
 59 |      */
 60 |     protected $sheet;
 61 | 
 62 |     /**
 63 |      * Parser
 64 |      * @var ViewParser
 65 |      */
 66 |     public $parser;
 67 | 
 68 |     /**
 69 |      * Default extension
 70 |      * @var string
 71 |      */
 72 |     public $ext = 'xls';
 73 | 
 74 |     /**
 75 |      * Path the file will be stored to
 76 |      * @var string
 77 |      */
 78 |     public $storagePath = 'exports';
 79 | 
 80 |     /**
 81 |      * Header Content-type
 82 |      * @var string
 83 |      */
 84 |     protected $contentType;
 85 | 
 86 |     /**
 87 |      * Spreadsheet is rendered
 88 |      * @var boolean
 89 |      */
 90 |     protected $rendered = false;
 91 | 
 92 |     /**
 93 |      * Construct writer
 94 |      * @param Response         $response
 95 |      * @param FileSystem       $filesystem
 96 |      * @param FormatIdentifier $identifier
 97 |      */
 98 |     public function __construct(Response $response, FileSystem $filesystem, FormatIdentifier $identifier)
 99 |     {
100 |         $this->response = $response;
101 |         $this->filesystem = $filesystem;
102 |         $this->identifier = $identifier;
103 |     }
104 | 
105 |     /**
106 |      * Inject the excel object
107 |      * @param  PHPExcel $excel
108 |      * @param bool      $reset
109 |      * @return void
110 |      */
111 |     public function injectExcel($excel, $reset = true)
112 |     {
113 |         $this->excel = $excel;
114 | 
115 |         if ($reset)
116 |             $this->_reset();
117 |     }
118 | 
119 |     /**
120 |      * Set the spreadsheet title
121 |      * @param string $title
122 |      * @return  LaravelExcelWriter
123 |      */
124 |     public function setTitle($title)
125 |     {
126 |         $this->title = $title;
127 |         $this->getProperties()->setTitle($title);
128 | 
129 |         return $this;
130 |     }
131 | 
132 |     /**
133 |      * Set the filename
134 |      * @param  $name
135 |      * @return $this
136 |      */
137 |     public function setFileName($name)
138 |     {
139 |         $this->filename = $name;
140 | 
141 |         return $this;
142 |     }
143 | 
144 |     /**
145 |      * Get the title
146 |      * @return string
147 |      */
148 |     public function getTitle()
149 |     {
150 |         return $this->title;
151 |     }
152 | 
153 |     /**
154 |      * Get the title
155 |      * @return string
156 |      */
157 |     public function getFileName()
158 |     {
159 |         return $this->filename;
160 |     }
161 | 
162 |     /**
163 |      * Share view with all sheets
164 |      * @param  string $view
165 |      * @param  array  $data
166 |      * @param  array  $mergeData
167 |      * @return  LaravelExcelWriter
168 |      */
169 |     public function shareView($view, $data = array(), $mergeData = array())
170 |     {
171 |         // Get the parser
172 |         $this->getParser();
173 | 
174 |         // Set the view inside the parser
175 |         $this->parser->setView($view);
176 |         $this->parser->setData($data);
177 |         $this->parser->setMergeData($mergeData);
178 | 
179 |         return $this;
180 |     }
181 | 
182 |     /**
183 |      * Set the view
184 |      * @return  LaravelExcelWriter
185 |      */
186 |     public function setView()
187 |     {
188 |         return call_user_func_array(array($this, 'shareView'), func_get_args());
189 |     }
190 | 
191 |     /**
192 |      * Load the view
193 |      * @return  LaravelExcelWriter
194 |      */
195 |     public function loadView()
196 |     {
197 |         return call_user_func_array(array($this, 'shareView'), func_get_args());
198 |     }
199 | 
200 |     /**
201 |      * Create a new sheet
202 |      * @param  string        $title
203 |      * @param  callback|null $callback
204 |      * @return  LaravelExcelWriter
205 |      */
206 |     public function sheet($title, $callback = null)
207 |     {
208 |         // Clone the active sheet
209 |         $this->sheet = $this->excel->createSheet(null, $title);
210 | 
211 |         // If a parser was set, inject it
212 |         if ($this->parser)
213 |             $this->sheet->setParser($this->parser);
214 | 
215 |         // Set the sheet title
216 |         $this->sheet->setTitle($title);
217 | 
218 |         // Set the default page setup
219 |         $this->sheet->setDefaultPageSetup();
220 | 
221 |         // Do the callback
222 |         if ($callback instanceof Closure)
223 |             call_user_func($callback, $this->sheet);
224 | 
225 |         // Autosize columns when no user didn't change anything about column sizing
226 |         if (!$this->sheet->hasFixedSizeColumns())
227 |             $this->sheet->setAutosize(Config::get('excel.export.autosize', false));
228 | 
229 |         // Parse the sheet
230 |         $this->sheet->parsed();
231 | 
232 |         return $this;
233 |     }
234 | 
235 |     /**
236 |      * Set data for the current sheet
237 |      * @param  array $array
238 |      * @return  LaravelExcelWriter
239 |      */
240 |     public function with(Array $array)
241 |     {
242 |         // Add the vars
243 |         $this->fromArray($array);
244 | 
245 |         return $this;
246 |     }
247 | 
248 |     /**
249 |      * Export the spreadsheet
250 |      * @param string $ext
251 |      * @param array  $headers
252 |      * @throws LaravelExcelException
253 |      */
254 |     public function export($ext = 'xls', Array $headers = array())
255 |     {
256 |         // Set the extension
257 |         $this->ext = $ext;
258 | 
259 |         // Render the file
260 |         $this->_render();
261 | 
262 |         // Download the file
263 |         $this->_download($headers);
264 |     }
265 | 
266 |     /**
267 |      * Convert and existing file to newly requested extension
268 |      * @param       $ext
269 |      * @param array $headers
270 |      */
271 |     public function convert($ext, Array $headers = array())
272 |     {
273 |         $this->export($ext, $headers);
274 |     }
275 | 
276 |     /**
277 |      * Export and download the spreadsheet
278 |      * @param  string $ext
279 |      * @param array   $headers
280 |      */
281 |     public function download($ext = 'xls', Array $headers = array())
282 |     {
283 |         $this->export($ext, $headers);
284 |     }
285 | 
286 |     /**
287 |      * Download a file
288 |      * @param array $headers
289 |      * @throws LaravelExcelException
290 |      */
291 |     protected function _download(Array $headers = array())
292 |     {
293 |         // Set the headers
294 |         $this->_setHeaders(
295 |             $headers,
296 |             array(
297 |                 'Content-Type'        => $this->contentType,
298 |                 'Content-Disposition' => 'attachment; filename="' . $this->filename . '.' . $this->ext . '"',
299 |                 'Expires'             => 'Mon, 26 Jul 1997 05:00:00 GMT', // Date in the past
300 |                 'Last-Modified'       => Carbon::now()->format('D, d M Y H:i:s'),
301 |                 'Cache-Control'       => 'cache, must-revalidate',
302 |                 'Pragma'              => 'public'
303 |             )
304 |         );
305 | 
306 |         // Check if writer isset
307 |         if (!$this->writer)
308 |             throw new LaravelExcelException('[ERROR] No writer was set.');
309 | 
310 | 
311 |         // Download
312 |         $this->writer->save('php://output');
313 | 
314 |         // End the script to prevent corrupted xlsx files
315 |         exit;
316 |     }
317 | 
318 |     /**
319 |      * Store the excel file to the server
320 |      * @param  string  $ext
321 |      * @param  boolean $path
322 |      * @param  boolean $returnInfo
323 |      * @return LaravelExcelWriter
324 |      */
325 |     public function store($ext = 'xls', $path = false, $returnInfo = false)
326 |     {
327 |         // Set the storage path
328 |         $this->_setStoragePath($path);
329 | 
330 |         // Set the extension
331 |         $this->ext = $ext;
332 | 
333 |         // Render the XLS
334 |         $this->_render();
335 | 
336 |         // Set the storage path and file
337 |         $toStore = $this->storagePath . '/' . $this->filename . '.' . $this->ext;
338 | 
339 |         // Save the file to specified location
340 |         $this->writer->save($toStore);
341 | 
342 |         // Return file info
343 |         if ($this->returnInfo($returnInfo))
344 |         {
345 |             // Send back information about the stored file
346 |             return array(
347 |                 'full'  => $toStore,
348 |                 'path'  => $this->storagePath,
349 |                 'file'  => $this->filename . '.' . $this->ext,
350 |                 'title' => $this->filename,
351 |                 'ext'   => $this->ext
352 |             );
353 |         }
354 | 
355 |         // Return itself
356 |         return $this;
357 |     }
358 | 
359 |     /**
360 |      * Check if we want to return info or itself
361 |      * @param  boolean $returnInfo
362 |      * @return boolean
363 |      */
364 |     public function returnInfo($returnInfo = false)
365 |     {
366 |         return $returnInfo ? $returnInfo : Config::get('excel.export.store.returnInfo', false);
367 |     }
368 | 
369 |     /**
370 |      *  Store the excel file to the server
371 |      * @param str|string $ext  The file extension
372 |      * @param bool|str   $path The save path
373 |      * @param bool       $returnInfo
374 |      * @return LaravelExcelWriter
375 |      */
376 |     public function save($ext = 'xls', $path = false, $returnInfo = false)
377 |     {
378 |         return $this->store($ext, $path, $returnInfo);
379 |     }
380 | 
381 |     /**
382 |      * Start render of a new spreadsheet
383 |      * @throws LaravelExcelException
384 |      * @return void
385 |      */
386 |     protected function _render()
387 |     {
388 |         // There should be enough sheets to continue rendering
389 |         if ($this->excel->getSheetCount() < 0)
390 |             throw new LaravelExcelException('[ERROR] Aborting spreadsheet render: no sheets were created.');
391 | 
392 |         // Set the format
393 |         $this->_setFormat();
394 | 
395 |         // Set the writer
396 |         $this->_setWriter();
397 | 
398 |         // File has been rendered
399 |         $this->rendered = true;
400 |     }
401 | 
402 |     /**
403 |      * Get the view parser
404 |      * @return PHPExcel
405 |      */
406 |     public function getExcel()
407 |     {
408 |         return $this->excel;
409 |     }
410 | 
411 |     /**
412 |      * Get the view parser
413 |      * @return ViewParser
414 |      */
415 |     public function getParser()
416 |     {
417 |         // Init the parser
418 |         if (!$this->parser)
419 |             $this->parser = app('excel.parsers.view');
420 | 
421 |         return $this->parser;
422 |     }
423 | 
424 |     /**
425 |      * Get the sheet
426 |      * @return LaravelExcelWorksheet
427 |      */
428 |     public function getSheet()
429 |     {
430 |         return $this->sheet;
431 |     }
432 | 
433 |     /**
434 |      * Set attributes
435 |      * @param string $setter
436 |      * @param array  $params
437 |      */
438 |     protected function _setAttribute($setter, $params)
439 |     {
440 |         // Get the key
441 |         $key = lcfirst(str_replace('set', '', $setter));
442 | 
443 |         // If is an allowed property
444 |         if ($this->excel->isChangeableProperty($setter))
445 |         {
446 |             // Set the properties
447 |             call_user_func_array(array($this->excel->getProperties(), $setter), $params);
448 |         }
449 |     }
450 | 
451 |     /**
452 |      * Set the write format
453 |      * @return  void
454 |      */
455 |     protected function _setFormat()
456 |     {
457 |         // Get extension
458 |         $this->ext = strtolower($this->ext);
459 | 
460 |         // get the file format
461 |         $this->format = $this->identifier->getFormatByExtension($this->ext);
462 | 
463 |         // Get content type
464 |         $this->contentType = $this->identifier->getContentTypeByFormat($this->format);
465 |     }
466 | 
467 |     /**
468 |      * Set the writer
469 |      * @return PHPExcel_***_Writer
470 |      */
471 |     protected function _setWriter()
472 |     {
473 |         // Set pdf renderer
474 |         if ($this->format == 'PDF')
475 |         {
476 |             $this->setPdfRenderer();
477 |         }
478 | 
479 |         // Create the writer
480 |         $this->writer = PHPExcel_IOFactory::createWriter($this->excel, $this->format);
481 | 
482 |         // Set CSV delimiter
483 |         if ($this->format == 'CSV')
484 |         {
485 |             $this->writer->setDelimiter(Config::get('excel.csv.delimiter', ','));
486 |             $this->writer->setEnclosure(Config::get('excel.csv.enclosure', '"'));
487 |             $this->writer->setLineEnding(Config::get('excel::csv.line_ending', "\r\n"));
488 |         }
489 | 
490 |         // Set CSV delimiter
491 |         if ($this->format == 'PDF')
492 |         {
493 |             $this->writer->writeAllSheets();
494 |         }
495 | 
496 |         // Calculation settings
497 |         $this->writer->setPreCalculateFormulas(Config::get('excel.export.calculate', false));
498 | 
499 |         // Include Charts
500 |         $this->writer->setIncludeCharts(Config::get('excel.export.includeCharts', false));
501 | 
502 |         return $this->writer;
503 |     }
504 | 
505 |     /**
506 |      * Set the pdf renderer
507 |      * @throws \Exception
508 |      */
509 |     protected function setPdfRenderer()
510 |     {
511 |         // Get the driver name
512 |         $driver = Config::get('excel.export.pdf.driver');
513 |         $path = Config::get('excel.export.pdf.drivers.' . $driver . '.path');
514 | 
515 |         // Disable autoloading for dompdf
516 |         define("DOMPDF_ENABLE_AUTOLOAD", false);
517 | 
518 |         // Set the pdf renderer
519 |         if (!\PHPExcel_Settings::setPdfRenderer($driver, $path))
520 |             throw new \Exception("{$driver} could not be found. Make sure you've included it in your composer.json");
521 |     }
522 | 
523 |     /**
524 |      * Set the headers
525 |      * @param $headers
526 |      * @throws LaravelExcelException
527 |      */
528 |     protected function _setHeaders(Array $headers = array(), Array $default)
529 |     {
530 |         if (headers_sent()) throw new LaravelExcelException('[ERROR]: Headers already sent');
531 | 
532 |         // Merge the default headers with the overruled headers
533 |         $headers = array_merge($default, $headers);
534 | 
535 |         foreach ($headers as $header => $value)
536 |         {
537 |             header($header . ': ' . $value);
538 |         }
539 |     }
540 | 
541 |     /**
542 |      * Set the storage path
543 |      * @param bool $path
544 |      * @return  void
545 |      */
546 |     protected function _setStoragePath($path = false)
547 |     {
548 |         // Get the default path
549 |         $path = $path ? $path : Config::get('excel.export.store.path', storage_path($this->storagePath));
550 | 
551 |         // Trim of slashes, to makes sure we won't add them double
552 |         $this->storagePath = rtrim($path, '/');
553 | 
554 |         // Make sure the storage path exists
555 |         if (!$this->filesystem->isWritable($this->storagePath))
556 |             $this->filesystem->makeDirectory($this->storagePath, 0777, true);
557 |     }
558 | 
559 |     /**
560 |      * Reset the writer
561 |      * @return void
562 |      */
563 |     protected function _reset()
564 |     {
565 |         $this->excel->disconnectWorksheets();
566 |     }
567 | 
568 |     /**
569 |      * Dynamically call methods
570 |      * @param  string $method
571 |      * @param  array  $params
572 |      * @throws LaravelExcelException
573 |      * @return LaravelExcelWriter
574 |      */
575 |     public function __call($method, $params)
576 |     {
577 |         // If the dynamic call starts with "set"
578 |         if (starts_with($method, 'set') && $this->excel->isChangeableProperty($method))
579 |         {
580 |             $this->_setAttribute($method, $params);
581 | 
582 |             return $this;
583 |         }
584 | 
585 |         // Call a php excel method
586 |         elseif (method_exists($this->excel, $method))
587 |         {
588 |             // Call the method from the excel object with the given params
589 |             $return = call_user_func_array(array($this->excel, $method), $params);
590 | 
591 |             return $return ? $return : $this;
592 |         }
593 | 
594 |         throw new LaravelExcelException('[ERROR] Writer method [' . $method . '] does not exist.');
595 |     }
596 | }
597 | 


--------------------------------------------------------------------------------
/tests/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/barryvdh/Laravel-Excel/0ade0c2b0795d185bcf598ef41f55283a30dbd79/tests/.gitkeep


--------------------------------------------------------------------------------
/tests/Collections/CellCollectionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Maatwebsite\Excel\Collections\CellCollection;
 4 | 
 5 | class CellCollectionTest extends TestCase {
 6 | 
 7 | 
 8 |     public function __construct()
 9 |     {
10 |         $this->collection = new CellCollection([
11 |             'one' => 'one',
12 |             'two' => 'two'
13 |         ]);
14 |     }
15 | 
16 | 
17 |     public function testSetItems()
18 |     {
19 |         $this->collection->setItems([
20 |             'three' => 'three'
21 |         ]);
22 | 
23 |         $this->assertContains('three', $this->collection);
24 |         $this->assertCount(3, $this->collection);
25 |     }
26 | 
27 | 
28 |     public function testDynamicGetters()
29 |     {
30 |         $this->assertEquals('two', $this->collection->two);
31 |     }
32 | 
33 | 
34 |     public function testIsset()
35 |     {
36 |         $this->assertTrue(isset($this->collection->two));
37 |         $this->assertFalse(isset($this->collection->nonexisting));
38 |     }
39 | 
40 | 
41 |     public function testEmpty()
42 |     {
43 |         $this->assertFalse(empty($this->collection->two));
44 |         $this->assertTrue(empty($this->collection->nonexisting));
45 |     }
46 | 
47 | 
48 |     public function testDynamicCheck()
49 |     {
50 |         $this->assertTrue($this->collection->two ? true : false);
51 |         $this->assertFalse($this->collection->nonexisting ? true : false);
52 |     }
53 | }


--------------------------------------------------------------------------------
/tests/Excel/ExcelTestCase.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use Mockery as m;
  4 | use Maatwebsite\Excel\Excel;
  5 | use Illuminate\Filesystem\Filesystem;
  6 | 
  7 | class ExcelTestCase extends PHPUnit_Framework_TestCase {
  8 | 
  9 |     /**
 10 |      * Mocks
 11 |      * @var [type]
 12 |      */
 13 |     public $phpexcel;
 14 |     public $reader;
 15 |     public $writer;
 16 |     public $excel;
 17 |     public $batch;
 18 | 
 19 |     /**
 20 |      * Setup test case
 21 |      */
 22 |     public function setUp()
 23 |     {
 24 |         parent::setUp();
 25 | 
 26 |         // Set the mocks
 27 |         $this->setMocks();
 28 | 
 29 |         // Init our excel class
 30 |         $this->excel = new Excel($this->phpexcel, $this->reader, $this->writer);
 31 |     }
 32 | 
 33 |     /**
 34 |      * Test the constructor
 35 |      * @return [type] [description]
 36 |      */
 37 |     public function testConstructor()
 38 |     {
 39 |         $this->assertInstanceOf('Maatwebsite\Excel\Excel', $this->excel);
 40 |     }
 41 | 
 42 |     /**
 43 |      * Set the mocks
 44 |      */
 45 |     public function setMocks()
 46 |     {
 47 |         $this->mockPHPExcel();
 48 |         $this->mockReader();
 49 |         $this->mockWriter();
 50 |         $this->mockBatch();
 51 |     }
 52 | 
 53 |     /**
 54 |      * Mock PHPExcel class
 55 |      * @return [type] [description]
 56 |      */
 57 |     public function mockPHPExcel()
 58 |     {
 59 |         $this->phpexcel = m::mock('Maatwebsite\Excel\Classes\PHPExcel');
 60 |         $this->phpexcel->shouldReceive('getID');
 61 |         $this->phpexcel->shouldReceive('disconnectWorksheets');
 62 |         $this->phpexcel->shouldReceive('setDefaultProperties');
 63 |     }
 64 | 
 65 |     /**
 66 |      * Mock Reader class
 67 |      * @return [type] [description]
 68 |      */
 69 |     public function mockReader()
 70 |     {
 71 |         $this->reader = m::mock('Maatwebsite\Excel\Readers\LaravelExcelReader');
 72 |         $this->reader->shouldReceive('injectExcel')->with($this->phpexcel);
 73 |         $this->reader->shouldReceive('load');
 74 |         $this->reader->shouldReceive('setSelectedSheets');
 75 |         $this->reader->shouldReceive('setSelectedSheetIndices');
 76 |         $this->reader->shouldReceive('setFilters');
 77 |     }
 78 | 
 79 |     /**
 80 |      * Mock Writer class
 81 |      * @return [type] [description]
 82 |      */
 83 |     public function mockWriter()
 84 |     {
 85 |         $this->writer = m::mock('Maatwebsite\Excel\Writers\LaravelExcelWriter');
 86 |         $this->writer->shouldReceive('injectExcel')->with($this->phpexcel);
 87 |         $this->writer->shouldReceive('setTitle');
 88 |         $this->writer->shouldReceive('setFileName');
 89 |         $this->writer->shouldReceive('shareView')->andReturn($this->writer);
 90 |     }
 91 | 
 92 |     /**
 93 |      * Mock Writer class
 94 |      * @return [type] [description]
 95 |      */
 96 |     public function mockBatch()
 97 |     {
 98 |         $this->batch = m::mock('Maatwebsite\Excel\Readers\Batch');
 99 |         $this->batch->shouldReceive('start')->andReturn('foo');
100 |     }
101 | 
102 |     /**
103 |      * Teardown
104 |      * @return [type] [description]
105 |      */
106 |     public function tearDown()
107 |     {
108 |         m::close();
109 |     }
110 | 
111 | }


--------------------------------------------------------------------------------
/tests/Excel/ExcelTester.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Mockery as m;
 4 | 
 5 | class ExcelTester extends ExcelTestCase {
 6 | 
 7 |     /**
 8 |      * Test select sheets
 9 |      * @return
10 |      */
11 |     public function testSelectSheets()
12 |     {
13 |         $selected = $this->excel->selectSheets(array('sheet'));
14 |         $this->assertEquals($this->excel, $selected);
15 |     }
16 | 
17 |     /**
18 |      * Test select sheets
19 |      * @return
20 |      */
21 |     public function testSelectSheetsByIndex()
22 |     {
23 |         $selected = $this->excel->selectSheetsByIndex(array('0'));
24 |         $this->assertEquals($this->excel, $selected);
25 |     }
26 | 
27 |     /**
28 |      * Test the share view
29 |      * @return
30 |      */
31 |     public function testShareView()
32 |     {
33 |         $selected = $this->excel->shareView('filename', array('test'), array('test'));
34 |         $this->assertEquals($this->writer, $selected);
35 |     }
36 | 
37 |     /**
38 |      * Test load view
39 |      * @return
40 |      */
41 |     public function testLoadView()
42 |     {
43 |         $selected = $this->excel->loadView('filename', array('test'), array('test'));
44 |         $this->assertEquals($this->writer, $selected);
45 |     }
46 | }


--------------------------------------------------------------------------------
/tests/Files/CsvExcelFileTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | include_once 'classes/CsvTestImport.php';
 4 | 
 5 | class CsvExcelFileTest extends TestCase {
 6 | 
 7 | 
 8 |     public function testInit()
 9 |     {
10 |         $importer = app('CsvTestImport');
11 |         $this->assertInstanceOf('Maatwebsite\Excel\Files\ExcelFile', $importer);
12 |     }
13 | 
14 | 
15 |     public function testGetResultsDirectlyWithCustomDelimiterSetAsProperty()
16 |     {
17 |         $importer = app('TestImport');
18 |         $results = $importer->get();
19 | 
20 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\RowCollection', $results);
21 |         $this->assertCount(5, $results);
22 |     }
23 | 
24 | }


--------------------------------------------------------------------------------
/tests/Files/ExcelFileTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | include_once 'classes/TestImport.php';
 4 | include_once 'classes/TestImportHandler.php';
 5 | 
 6 | class ExcelFileTest extends TestCase {
 7 | 
 8 | 
 9 |     public function testInit()
10 |     {
11 |         $importer = app('TestImport');
12 |         $this->assertInstanceOf('Maatwebsite\Excel\Files\ExcelFile', $importer);
13 |     }
14 | 
15 | 
16 |     public function testGetFile()
17 |     {
18 |         $importer = app('TestImport');
19 |         $file = $importer->getFile();
20 |         $exploded = explode('/',$file);
21 |         $filename = end($exploded);
22 | 
23 |         $this->assertEquals('test.csv', $filename);
24 |     }
25 | 
26 | 
27 |     public function testGetFilters()
28 |     {
29 |         $importer = app('TestImport');
30 |         $this->assertContains('chunk', $importer->getFilters());
31 |         $this->assertContains('chunk', $importer->getFileInstance()->filters['enabled']);
32 |     }
33 | 
34 | 
35 |     public function testLoadFile()
36 |     {
37 |         $importer = app('TestImport');
38 |         $importer->loadFile();
39 |         $this->assertInstanceOf('Maatwebsite\Excel\Readers\LaravelExcelReader', $importer->getFileInstance());
40 |     }
41 | 
42 | 
43 |     public function testGetResultsDirectly()
44 |     {
45 |         $importer = app('TestImport');
46 |         $results = $importer->get();
47 | 
48 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\RowCollection', $results);
49 |         $this->assertCount(5, $results);
50 |     }
51 | 
52 | 
53 |     public function testImportHandler()
54 |     {
55 |         $importer = app('TestImport');
56 |         $results = $importer->handleImport();
57 | 
58 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\RowCollection', $results);
59 |         $this->assertCount(5, $results);
60 |     }
61 | 
62 | 
63 | }


--------------------------------------------------------------------------------
/tests/Files/NewExcelFileTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | include_once 'classes/TestExport.php';
 4 | include_once 'classes/TestExportHandler.php';
 5 | 
 6 | class NewExcelFileTest extends TestCase {
 7 | 
 8 | 
 9 |     public function testInit()
10 |     {
11 |         $exporter = app('TestExport');
12 |         $this->assertInstanceOf('Maatwebsite\Excel\Files\NewExcelFile', $exporter);
13 |     }
14 | 
15 | 
16 |     public function testGetFilename()
17 |     {
18 |         $exporter = app('TestExport');
19 |         $this->assertEquals('test-file', $exporter->getFilename());
20 |     }
21 | 
22 | 
23 |     public function testCreateNewFile()
24 |     {
25 |         $exporter = app('TestExport');
26 |         $exporter->createNewFile();
27 |         $this->assertInstanceOf('Maatwebsite\Excel\Writers\LaravelExcelWriter', $exporter->getFileInstance());
28 |     }
29 | 
30 | 
31 |     public function testDirectUsage()
32 |     {
33 |         $exporter = app('TestExport');
34 |         $exporter->setTitle('New title');
35 | 
36 |         $this->assertEquals('New title', $exporter->getFileInstance()->getTitle());
37 |     }
38 | 
39 | 
40 |     public function testExportHandler()
41 |     {
42 |         $exporter = app('TestExport');
43 |         $result = $exporter->handleExport();
44 | 
45 |         $this->assertEquals('exported', $result);
46 |     }
47 | 
48 | }


--------------------------------------------------------------------------------
/tests/Files/classes/CsvTestImport.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Maatwebsite\Excel\Files\ExcelFile;
 4 | 
 5 | class CsvTestImport extends ExcelFile {
 6 | 
 7 |     /**
 8 |      * Custom delimiter
 9 |      * @var string
10 |      */
11 |     protected $delimiter  = ';';
12 | 
13 |     /**
14 |      * Get file to import
15 |      * @return string
16 |      */
17 |     public function getFile()
18 |     {
19 |         return __DIR__ . '/../files/test-custom.csv';
20 |     }
21 | } 


--------------------------------------------------------------------------------
/tests/Files/classes/TestExport.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Maatwebsite\Excel\Files\NewExcelFile;
 4 | 
 5 | class TestExport extends NewExcelFile {
 6 | 
 7 |     /**
 8 |      * Get file to import
 9 |      * @return string
10 |      */
11 |     public function getFilename()
12 |     {
13 |         return 'test-file';
14 |     }
15 | 
16 | } 


--------------------------------------------------------------------------------
/tests/Files/classes/TestExportHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Maatwebsite\Excel\Files\ExportHandler;
 4 | 
 5 | class TestExportHandler implements ExportHandler {
 6 | 
 7 |     /**
 8 |      * Handle
 9 |      * @param $file
10 |      * @return mixed|void
11 |      */
12 |     public function handle($file)
13 |     {
14 |         return 'exported';
15 |     }
16 | 
17 | } 


--------------------------------------------------------------------------------
/tests/Files/classes/TestImport.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Maatwebsite\Excel\Files\ExcelFile;
 4 | 
 5 | class TestImport extends ExcelFile {
 6 | 
 7 |     protected $delimiter  = ',';
 8 |     protected $enclosure  = '"';
 9 |     protected $lineEnding = '\r\n';
10 | 
11 |     /**
12 |      * Get file to import
13 |      * @return string
14 |      */
15 |     public function getFile()
16 |     {
17 |         return __DIR__ . '/../files/test.csv';
18 |     }
19 | 
20 |     /**
21 |      * Get filters
22 |      * @return array
23 |      */
24 |     public function getFilters()
25 |     {
26 |         return [
27 |             'chunk'
28 |         ];
29 |     }
30 | 
31 | } 


--------------------------------------------------------------------------------
/tests/Files/classes/TestImportHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Maatwebsite\Excel\Files\ImportHandler;
 4 | 
 5 | class TestImportHandler implements ImportHandler {
 6 | 
 7 |     /**
 8 |      * Handle
 9 |      * @param $file
10 |      * @return mixed|void
11 |      */
12 |     public function handle($file)
13 |     {
14 |         return $file->get();
15 |     }
16 | 
17 | } 


--------------------------------------------------------------------------------
/tests/Files/files/test-custom.csv:
--------------------------------------------------------------------------------
1 | heading one;heading two;heading three
2 | test;test;test
3 | test;test;test
4 | test;test;test
5 | test;test;test
6 | test;test;test


--------------------------------------------------------------------------------
/tests/Files/files/test.csv:
--------------------------------------------------------------------------------
1 | heading one,heading two,heading three
2 | test,test,test
3 | test,test,test
4 | test,test,test
5 | test,test,test
6 | test,test,test


--------------------------------------------------------------------------------
/tests/Filters/ChunkReadFilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Mockery as m;
 4 | 
 5 | class ChunkReadFilterTest extends TestCase {
 6 | 
 7 |     public function setUp()
 8 |     {
 9 |         parent::setUp();
10 |         $this->excel = app('excel');
11 |     }
12 | 
13 | 
14 |     public function testCanChunkXls()
15 |     {
16 |         $this->assertCanChunkIntoGroups(1,"sample.xls",20);
17 |         $this->assertCanChunkIntoGroups(1,"sample.xls",15);
18 |         $this->assertCanChunkIntoGroups(2,"sample.xls",10);
19 |         $this->assertCanChunkIntoGroups(3,"sample.xls",5);
20 |         $this->assertCanChunkIntoGroups(15,"sample.xls",1);
21 |     }
22 | 
23 | 
24 |     public function testCanChunkXlsx()
25 |     {
26 |     	$this->assertCanChunkIntoGroups(1,"sample.xlsx",20);
27 |     	$this->assertCanChunkIntoGroups(1,"sample.xlsx",15);
28 |     	$this->assertCanChunkIntoGroups(2,"sample.xlsx",10);
29 |         $this->assertCanChunkIntoGroups(3,"sample.xlsx",5);
30 |     	$this->assertCanChunkIntoGroups(15,"sample.xlsx",1);
31 |     }
32 | 
33 | 
34 |     public function testCanChunkCsv()
35 |     {
36 |     	$this->assertCanChunkIntoGroups(1,"sample.csv", 20);
37 |     	$this->assertCanChunkIntoGroups(1,"sample.csv", 15);
38 |     	$this->assertCanChunkIntoGroups(2,"sample.csv", 10);
39 |         $this->assertCanChunkIntoGroups(3,"sample.csv", 5);
40 |     	$this->assertCanChunkIntoGroups(15,"sample.csv", 1);
41 |     }
42 | 
43 | 
44 |     public function testCanChunkMultipleSheets()
45 |     {
46 |         $output = [];
47 | 
48 |         $rounds = 0;
49 | 
50 |         // test with small chunks
51 |         $chunk_size = 2;
52 |         $expected = "1,3,5,7,9,11,13,15,17,19,1,3,5,7,9,11,13,15,17,19";
53 |         $expected_chunks = 10;
54 | 
55 |         // Sheet2 has more rows than sheet 1
56 |         $this->excel->filter('chunk')->selectSheets('Sheet2')->load(__DIR__ . "/files/multi.xls")->chunk($chunk_size,function($results) use (&$output, &$rounds){
57 |             $rounds++;
58 |             foreach ($results as $row) {
59 |                 $output[] = (int) $row->header;
60 |             }
61 |         });
62 | 
63 |         $this->assertEquals($expected, implode(",", $output ), "Chunked ($chunk_size) value not equal with source data.");
64 |         $this->assertEquals($expected_chunks, $rounds, "Expecting total chunks is $expected_chunks when chunk with size $chunk_size");
65 | 
66 |     }
67 | 
68 | 
69 |     private function assertCanChunkIntoGroups($expected_chunks, $file, $chunk_size)
70 |     {
71 |     	$output = [];
72 |         
73 |         $rounds = 0;
74 | 
75 |         $this->excel->filter('chunk')->load(__DIR__ . "/files/{$file}")->chunk($chunk_size,function($results) use (&$output, &$rounds){
76 |         	$rounds++;
77 |             foreach ($results as $row) {
78 |         		$output[] = (int) $row->header;
79 |         	}
80 |         });
81 | 
82 |         $expected = "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15";
83 | 
84 |         $this->assertEquals($expected, implode(",", $output ), "Chunked ($chunk_size) value not equal with source data.");
85 |         $this->assertEquals($expected_chunks, $rounds, "Expecting total chunks is $expected_chunks when chunk with size $chunk_size");
86 | 
87 |     }
88 | }


--------------------------------------------------------------------------------
/tests/Filters/RegisterFilterTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Mockery as m;
 4 | 
 5 | class RegisterFilterTestCase extends TestCase {
 6 | 
 7 |     public function setUp()
 8 |     {
 9 |         parent::setUp();
10 |         $this->excel = app('excel');
11 |     }
12 | 
13 |     public function testRegisterThroughConfig()
14 |     {
15 |         $registered = Config::get('excel.filters.registered');
16 | 
17 |         $filters = $this->excel->getFilters('registered');
18 |         $this->assertEquals($registered, $filters);
19 |     }
20 | 
21 |     public function testOnlyRegister()
22 |     {
23 |         $toRegister = array(
24 |             'chunk' =>  'ChunkFilter'
25 |         );
26 | 
27 |         $excel = $this->excel->registerFilters($toRegister);
28 | 
29 |         $filters = $this->excel->getFilters('registered');
30 |         $this->assertEquals($toRegister, $filters);
31 |     }
32 | 
33 |     public function testRegisterAndEnabled()
34 |     {
35 |         $toRegister = array(
36 |             'registered'    =>  array(
37 |                 'chunk' =>  'ChunkFilter'
38 |             ),
39 |             'enabled'   =>  array(
40 |                 'chunk'
41 |             )
42 |         );
43 | 
44 |         $excel = $this->excel->registerFilters($toRegister);
45 | 
46 |         $filters = $this->excel->getFilters();
47 |         $this->assertEquals($toRegister, $filters);
48 | 
49 |     }
50 | 
51 |     public function testEnableOneFilter()
52 |     {
53 |         $excel = $this->excel->filter('chunk');
54 | 
55 |         $filters = $this->excel->getFilters('enabled');
56 |         $this->assertContains('chunk', $filters);
57 |     }
58 | 
59 |     public function testEnableMultipleFilter()
60 |     {
61 |         $excel = $this->excel->filter(array('chunk', 'range'));
62 | 
63 |         $filters = $this->excel->getFilters('enabled');
64 |         $this->assertContains('chunk', $filters);
65 |         $this->assertContains('range', $filters);
66 |     }
67 | 
68 |     public function testEnableFilterAndOverruleFilterClass()
69 |     {
70 |         $excel = $this->excel->filter('chunk', 'ChunkFilter');
71 | 
72 |         $registered = $this->excel->getFilters('registered');
73 |         $this->assertEquals(array('chunk' => 'ChunkFilter'), $registered);
74 | 
75 |         $enabled    = $this->excel->getFilters('enabled');
76 |         $this->assertContains('chunk', $enabled);
77 | 
78 |     }
79 | }


--------------------------------------------------------------------------------
/tests/Filters/files/multi.xls:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/barryvdh/Laravel-Excel/0ade0c2b0795d185bcf598ef41f55283a30dbd79/tests/Filters/files/multi.xls


--------------------------------------------------------------------------------
/tests/Filters/files/sample.csv:
--------------------------------------------------------------------------------
 1 | HEADER
 2 | 1
 3 | 2
 4 | 3
 5 | 4
 6 | 5
 7 | 6
 8 | 7
 9 | 8
10 | 9
11 | 10
12 | 11
13 | 12
14 | 13
15 | 14
16 | 15


--------------------------------------------------------------------------------
/tests/Filters/files/sample.xls:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/barryvdh/Laravel-Excel/0ade0c2b0795d185bcf598ef41f55283a30dbd79/tests/Filters/files/sample.xls


--------------------------------------------------------------------------------
/tests/Filters/files/sample.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/barryvdh/Laravel-Excel/0ade0c2b0795d185bcf598ef41f55283a30dbd79/tests/Filters/files/sample.xlsx


--------------------------------------------------------------------------------
/tests/Readers/ChineseXlsReaderTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use Mockery as m;
  4 | use Maatwebsite\Excel\Readers\LaravelExcelReader;
  5 | use Maatwebsite\Excel\Classes;
  6 | 
  7 | class ChineseXlsReaderTest extends TestCase {
  8 | 
  9 |     /**
 10 |      * Test csv file
 11 |      * @var [type]
 12 |      */
 13 |     protected $xls;
 14 | 
 15 |     /**
 16 |      * Loaded csv file
 17 |      * @var [type]
 18 |      */
 19 |     protected $loadedXls;
 20 | 
 21 |     /**
 22 |      * Setup
 23 |      */
 24 |     public function setUp()
 25 |     {
 26 |         parent::setUp();
 27 | 
 28 |         // Disable to ascii
 29 |         Config::set('excel.import.to_ascii', false);
 30 | 
 31 |         // Set excel class
 32 |         $this->excel    = App::make('phpexcel');
 33 | 
 34 |         // Set writer class
 35 |         $this->reader   = App::make('excel.reader');
 36 |         $this->reader->injectExcel($this->excel);
 37 | 
 38 |         // Load csv file
 39 |         $this->loadChineseXls();
 40 |     }
 41 | 
 42 |     /**
 43 |      * Test loading a csv file
 44 |      * @return [type] [description]
 45 |      */
 46 |     public function testloadChineseXls()
 47 |     {
 48 |         $this->assertEquals($this->reader, $this->loadedXls);
 49 |         $this->assertInstanceOf('PHPExcel', $this->reader->getExcel());
 50 |     }
 51 | 
 52 |     /**
 53 |      * Test get
 54 |      * @return [type] [description]
 55 |      */
 56 |     public function testGet()
 57 |     {
 58 |         $got = $this->loadedXls->get();
 59 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\RowCollection', $got);
 60 |         $this->assertCount(2, $got);
 61 |     }
 62 | 
 63 | 
 64 |     /**
 65 |      * Test toArray
 66 |      * @return [type] [description]
 67 |      */
 68 |     public function testToArray()
 69 |     {
 70 |         $array = $this->loadedXls->toArray();
 71 |         $this->assertEquals(array(
 72 | 
 73 |             array(
 74 |                 '商品編號'  => 'L01A01SY047',
 75 |                 '商品名稱'  => 'LED T8燈管',
 76 |                 '實際數量'  => 1,
 77 |             ),
 78 |             array(
 79 |                 '商品編號'  => 'L01A01SY046',
 80 |                 '商品名稱'  => 'LED T8燈管',
 81 |                 '實際數量'  => 1,
 82 |             )
 83 | 
 84 |         ), $array);
 85 |     }
 86 | 
 87 |     /**
 88 |      * Load a csv file
 89 |      * @return [type] [description]
 90 |      */
 91 |     protected function loadChineseXls()
 92 |     {
 93 |         // Set test csv file
 94 |         $this->xls = __DIR__ . '/files/' . 'chinese.xls';
 95 | 
 96 |         // Loaded csv
 97 |         $this->loadedXls = $this->reader->load($this->xls);
 98 |     }
 99 | 
100 | }


--------------------------------------------------------------------------------
/tests/Readers/CsvReaderTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once('traits/ImportTrait.php');
 4 | require_once('traits/SingleImportTestingTrait.php');
 5 | 
 6 | use Mockery as m;
 7 | use Maatwebsite\Excel\Readers\LaravelExcelReader;
 8 | use Maatwebsite\Excel\Classes;
 9 | 
10 | class CsvReaderTest extends TestCase {
11 | 
12 |     /**
13 |      * Import trait
14 |      */
15 |     use ImportTrait, SingleImportTestingTrait;
16 | 
17 |     /**
18 |      * Filename
19 |      * @var string
20 |      */
21 |     protected $fileName = 'files/test.csv';
22 | 
23 | 
24 |     public function testSeparator()
25 |     {
26 |         $this->assertEquals('_', $this->loadedFile->getSeparator());
27 |     }
28 | 
29 | 
30 |     public function testSetSeparator()
31 |     {
32 |         $set = $this->loadedFile->setSeparator('-');
33 |         $this->assertEquals('-', $set->getSeparator());
34 |     }
35 | 
36 | 
37 |     public function testSetDelimiter()
38 |     {
39 |         $this->loadedFile->setDelimiter(';');
40 |         $this->reload();
41 |         $this->assertEquals(';', $this->loadedFile->getDelimiter());
42 |     }
43 | 
44 | 
45 |     public function testSetEnclosure()
46 |     {
47 |         $this->loadedFile->setEnclosure('d');
48 |         $this->reload();
49 |         $this->assertEquals('d', $this->loadedFile->getEnclosure());
50 |     }
51 | }


--------------------------------------------------------------------------------
/tests/Readers/CustomValueBinderTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | class CustomValuBinderTest extends TestCase {
  4 | 
  5 |     /**
  6 |      * Setup
  7 |      */
  8 |     public function setUp()
  9 |     {
 10 |         parent::setUp();
 11 | 
 12 |         // Set excel class
 13 |         $this->excel    = App::make('phpexcel');
 14 | 
 15 |         // Set writer class
 16 |         $this->reader   = App::make('excel.reader');
 17 |         $this->reader->injectExcel($this->excel);
 18 |         $this->reader->noHeading(true);
 19 | 
 20 |         // Set value binder
 21 |         $binder = new StubValueBinder();
 22 |         $this->reader->setValueBinder($binder);
 23 | 
 24 |         // Load csv file
 25 |         $this->loadFile();
 26 |     }
 27 | 
 28 |     /**
 29 |      * Tear down
 30 |      */
 31 |     public function tearDown()
 32 |     {
 33 |         // Necessary to reset the value binder back to default so that future test classes are unaffected.
 34 |         $this->reader->resetValueBinder();
 35 |     }
 36 | 
 37 |     public function testDefaultGet()
 38 |     {
 39 |         $got = $this->loadedFile->get();
 40 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\RowCollection', $got);
 41 |         $this->assertCount(5, $got);
 42 |     }
 43 | 
 44 |     public function testNumeric()
 45 |     {
 46 |         $got = $this->loadedFile->toArray();
 47 | 
 48 |         $this->assertTrue(is_string($got[0][0]));
 49 |         $this->assertEquals('00123', $got[0][0]);
 50 |     }
 51 | 
 52 |     public function testRealNull()
 53 |     {
 54 |         $got = $this->loadedFile->toArray();
 55 | 
 56 |         $this->assertTrue(is_null($got[1][0]));
 57 |         $this->assertEquals('', $got[1][0]);
 58 |     }
 59 | 
 60 |     public function testStringNull()
 61 |     {
 62 |         $got = $this->loadedFile->toArray();
 63 | 
 64 |         $this->assertTrue(is_string($got[2][0]));
 65 |         $this->assertEquals('null', $got[2][0]);
 66 |     }
 67 | 
 68 |     public function testEquation()
 69 |     {
 70 |         $got = $this->loadedFile->toArray();
 71 | 
 72 |         $this->assertTrue(is_string($got[3][0]));
 73 |         $this->assertEquals('=1+2', $got[3][0]);
 74 |     }
 75 | 
 76 |     public function testBoolean()
 77 |     {
 78 |         $got = $this->loadedFile->toArray();
 79 | 
 80 |         $this->assertTrue(is_string($got[4][0]));
 81 |         $this->assertEquals('true', $got[4][0]);
 82 |     }
 83 | 
 84 |     /**
 85 |      * Load a csv file
 86 |      * @return [type] [description]
 87 |      */
 88 |     protected function loadFile()
 89 |     {
 90 |         // Set test csv file
 91 |         $file = __DIR__ . '/files/' . 'customBinder.csv';
 92 | 
 93 |         // Loaded csv
 94 |         $this->loadedFile = $this->reader->load($file);
 95 |     }
 96 | }
 97 | 
 98 | class StubValueBinder extends PHPExcel_Cell_DefaultValueBinder implements PHPExcel_Cell_IValueBinder
 99 | {
100 |     public function bindValue(PHPExcel_Cell $cell, $value = null)
101 |     {
102 |         $cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_STRING);
103 | 
104 |         return true;
105 |     }
106 | }


--------------------------------------------------------------------------------
/tests/Readers/MultipleSheetsXlsReaderTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | require_once('traits/ImportTrait.php');
  4 | 
  5 | use Mockery as m;
  6 | use Maatwebsite\Excel\Readers\LaravelExcelReader;
  7 | use Maatwebsite\Excel\Classes;
  8 | 
  9 | class MultipleSheetsXlsReaderTest extends TestCase {
 10 | 
 11 |     /**
 12 |      * Import trait
 13 |      */
 14 |     use ImportTrait;
 15 | 
 16 |     /**
 17 |      * Filename
 18 |      * @var string
 19 |      */
 20 |     protected $fileName = 'files/multiple.xls';
 21 | 
 22 |     /**
 23 |      * Test get
 24 |      * @return [type] [description]
 25 |      */
 26 |     public function testGet()
 27 |     {
 28 |         $got = $this->loadedFile->get();
 29 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\SheetCollection', $got);
 30 |         $this->assertCount(2, $got);
 31 |     }
 32 | 
 33 |     /**
 34 |      * Test get
 35 |      * @return [type] [description]
 36 |      */
 37 |     public function testGetAndGetFirstSheetName()
 38 |     {
 39 |         $got = $this->loadedFile->get();
 40 | 
 41 |         // get first sheet
 42 |         $sheet = $got->first();
 43 | 
 44 |         // assert sheet title
 45 |         $this->assertEquals('Sheet1', $sheet->getTitle());
 46 | 
 47 |         // 5 rows
 48 |         $this->assertCount(5, $sheet);
 49 |     }
 50 | 
 51 |     public function testSelectSheet()
 52 |     {
 53 |         $this->reader->setSelectedSheets('Sheet2');
 54 |         $this->reload();
 55 | 
 56 |         $sheet = $this->loadedFile->get();
 57 | 
 58 |         $this->assertEquals('Sheet2', $sheet->getTitle());
 59 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\RowCollection', $sheet);
 60 |         $this->assertCount(5, $sheet);
 61 |     }
 62 | 
 63 |     public function testSelectSheetByIndex()
 64 |     {
 65 |         $this->reader->setSelectedSheetIndices(array(1));
 66 |         $this->reload();
 67 | 
 68 |         $sheet = $this->loadedFile->get();
 69 | 
 70 |         $this->assertEquals('Sheet2', $sheet->getTitle());
 71 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\RowCollection', $sheet);
 72 |         $this->assertCount(5, $sheet);
 73 |     }
 74 | 
 75 |     public function testSelectMultipleSheets()
 76 |     {
 77 |         $this->reader->setSelectedSheets(array('Sheet1', 'Sheet2'));
 78 |         $this->reload();
 79 | 
 80 |         $got = $this->loadedFile->get();
 81 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\SheetCollection', $got);
 82 |         $this->assertCount(2, $got);
 83 | 
 84 |         // get first sheet
 85 |         $sheet = $got->first();
 86 | 
 87 |         // assert sheet title
 88 |         $this->assertEquals('Sheet1', $sheet->getTitle());
 89 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\RowCollection', $sheet);
 90 |         $this->assertCount(5, $sheet);
 91 |     }
 92 | 
 93 |     public function testSelectMultipleSheetsByIndex()
 94 |     {
 95 |         $this->reader->setSelectedSheetIndices(array(0,1));
 96 |         $this->reload();
 97 | 
 98 |         $got = $this->loadedFile->get();
 99 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\SheetCollection', $got);
100 |         $this->assertCount(2, $got);
101 | 
102 |         // get first sheet
103 |         $sheet = $got->first();
104 | 
105 |         // assert sheet title
106 |         $this->assertEquals('Sheet1', $sheet->getTitle());
107 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\RowCollection', $sheet);
108 |         $this->assertCount(5, $sheet);
109 |     }
110 | 
111 | }


--------------------------------------------------------------------------------
/tests/Readers/ReaderTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Mockery as m;
 4 | use Maatwebsite\Excel\Readers\LaravelExcelReader;
 5 | use Maatwebsite\Excel\Classes;
 6 | 
 7 | class ReaderTest extends TestCase {
 8 | 
 9 |     /**
10 |      * Setup
11 |      */
12 |     public function setUp()
13 |     {
14 |         parent::setUp();
15 | 
16 |         // Set excel class
17 |         $this->excel    = App::make('phpexcel');
18 | 
19 |         // Set writer class
20 |         $this->reader   = App::make('excel.reader');
21 |         $this->reader->injectExcel($this->excel);
22 |     }
23 | 
24 |     /**
25 |      * Test the excel injection
26 |      * @return [type] [description]
27 |      */
28 |     public function testExcelInjection()
29 |     {
30 |         $this->assertEquals($this->excel, $this->reader->getExcel());
31 |     }
32 | 
33 | }


--------------------------------------------------------------------------------
/tests/Readers/XlsReaderTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once('traits/ImportTrait.php');
 4 | require_once('traits/SingleImportTestingTrait.php');
 5 | 
 6 | use Mockery as m;
 7 | use Maatwebsite\Excel\Readers\LaravelExcelReader;
 8 | use Maatwebsite\Excel\Classes;
 9 | 
10 | class XlsReaderTest extends TestCase {
11 | 
12 |     /**
13 |      * Import trait
14 |      */
15 |     use ImportTrait, SingleImportTestingTrait;
16 | 
17 |     /**
18 |      * Filename
19 |      * @var string
20 |      */
21 |     protected $fileName = 'files/test.xls';
22 | 
23 | }


--------------------------------------------------------------------------------
/tests/Readers/XlsxReaderTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once('traits/ImportTrait.php');
 4 | require_once('traits/SingleImportTestingTrait.php');
 5 | 
 6 | use Mockery as m;
 7 | use Maatwebsite\Excel\Readers\LaravelExcelReader;
 8 | use Maatwebsite\Excel\Classes;
 9 | 
10 | class XlsxReaderTest extends TestCase {
11 | 
12 |     /**
13 |      * Import trait
14 |      */
15 |     use ImportTrait, SingleImportTestingTrait;
16 | 
17 |     /**
18 |      * Filename
19 |      * @var string
20 |      */
21 |     protected $fileName = 'files/test.xlsx';
22 | 
23 | }


--------------------------------------------------------------------------------
/tests/Readers/ZerosHandlingReaderTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once('traits/ImportTrait.php');
 4 | require_once('traits/SingleImportTestingTrait.php');
 5 | 
 6 | use Mockery as m;
 7 | 
 8 | class ZerosHandlingReaderTest extends TestCase {
 9 | 
10 |     /**
11 |      * Traits
12 |      */
13 |     use ImportTrait;
14 | 
15 |     /**
16 |      * Filename
17 |      * @var string
18 |      */
19 |     protected $fileName = 'files/zeros.xls';
20 | 
21 |     /**
22 |      * @var bool
23 |      */
24 |     protected $noHeadings = false;
25 | 
26 | 
27 |     public function testDefaultGet()
28 |     {
29 |         $got = $this->loadedFile->get();
30 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\RowCollection', $got);
31 |         $this->assertCount(6, $got);
32 |     }
33 | 
34 |     //
35 |     //public function testStringsAppendedPrependedWithZeros()
36 |     //{
37 |     //    $got = $this->loadedFile->toArray();
38 |     //
39 |     //    $this->assertContains('TEST000', $got[3]);
40 |     //    $this->assertContains('000TEST', $got[4]);
41 |     //}
42 |     //
43 |     //
44 |     //public function testStringZeros()
45 |     //{
46 |     //    $got = $this->loadedFile->toArray();
47 |     //
48 |     //    $this->assertContains('000', $got[0]);
49 |     //}
50 | 
51 | 
52 |     public function testMoney()
53 |     {
54 |         $got = $this->loadedFile->toArray();
55 | 
56 |         $this->assertContains((double) 0, $got[1]);
57 |     }
58 | 
59 | 
60 |     public function testEmptyCellHandling()
61 |     {
62 |         $got = $this->loadedFile->toArray();
63 | 
64 |         $this->assertContains(null, $got[2]);
65 |     }
66 | 
67 | 
68 |     public function testNormalZeros()
69 |     {
70 |         $got = $this->loadedFile->toArray();
71 | 
72 |         $this->assertContains((double) 0, $got[5]);
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/tests/Readers/files/chinese.xls:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/barryvdh/Laravel-Excel/0ade0c2b0795d185bcf598ef41f55283a30dbd79/tests/Readers/files/chinese.xls


--------------------------------------------------------------------------------
/tests/Readers/files/customBinder.csv:
--------------------------------------------------------------------------------
1 | 00123
2 | 
3 | null
4 | =1+2
5 | true


--------------------------------------------------------------------------------
/tests/Readers/files/multiple.xls:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/barryvdh/Laravel-Excel/0ade0c2b0795d185bcf598ef41f55283a30dbd79/tests/Readers/files/multiple.xls


--------------------------------------------------------------------------------
/tests/Readers/files/test.csv:
--------------------------------------------------------------------------------
1 | heading one,heading two,heading three
2 | test,test,test
3 | test,test,test
4 | test,test,test
5 | test,test,test
6 | test,test,test


--------------------------------------------------------------------------------
/tests/Readers/files/test.xls:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/barryvdh/Laravel-Excel/0ade0c2b0795d185bcf598ef41f55283a30dbd79/tests/Readers/files/test.xls


--------------------------------------------------------------------------------
/tests/Readers/files/test.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/barryvdh/Laravel-Excel/0ade0c2b0795d185bcf598ef41f55283a30dbd79/tests/Readers/files/test.xlsx


--------------------------------------------------------------------------------
/tests/Readers/files/zeros.xls:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/barryvdh/Laravel-Excel/0ade0c2b0795d185bcf598ef41f55283a30dbd79/tests/Readers/files/zeros.xls


--------------------------------------------------------------------------------
/tests/Readers/traits/ImportTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | trait ImportTrait {
 4 | 
 5 |     /**
 6 |      * Test csv file
 7 |      * @var [type]
 8 |      */
 9 |     protected $file;
10 | 
11 |     /**
12 |      * Loaded csv file
13 |      * @var [type]
14 |      */
15 |     protected $loadedFile;
16 | 
17 |     /**
18 |      * Setup
19 |      */
20 |     public function setUp()
21 |     {
22 |         parent::setUp();
23 | 
24 |         // Set default heading
25 |         Config::set('excel.import.heading', 'slugged');
26 | 
27 |         // Set excel class
28 |         $this->excel    = App::make('phpexcel');
29 | 
30 |         // Set writer class
31 |         $this->reader   = App::make('excel.reader');
32 |         $this->reader->injectExcel($this->excel);
33 | 
34 |         // Disable heading usage
35 |         if(isset($this->noHeadings) && $this->noHeadings)
36 |             $this->reader->noHeading(true);
37 | 
38 |         // Load csv file
39 |         $this->loadFile();
40 |     }
41 | 
42 |     /**
43 |      * Test loading a csv file
44 |      * @return [type] [description]
45 |      */
46 |     public function testLoadFile()
47 |     {
48 |         $this->assertEquals($this->reader, $this->loadedFile);
49 |         $this->assertInstanceOf('PHPExcel', $this->reader->getExcel());
50 |     }
51 | 
52 |     /**
53 |      * Load a csv file
54 |      * @return [type] [description]
55 |      */
56 |     protected function loadFile()
57 |     {
58 |         // Set test csv file
59 |         $this->file = __DIR__ . '/..' . DIRECTORY_SEPARATOR . $this->fileName;
60 | 
61 |         // Loaded csv
62 |         $this->loadedFile = $this->reader->load($this->file);
63 |     }
64 | 
65 |     /**
66 |      * Load a csv file
67 |      * @return [type] [description]
68 |      */
69 |     protected function reload()
70 |     {
71 |         // Set test csv file
72 |         $this->file = __DIR__ . '/..' . DIRECTORY_SEPARATOR . $this->fileName;
73 | 
74 |         // Loaded csv
75 |         return $this->reader->load($this->file);
76 |     }
77 | }


--------------------------------------------------------------------------------
/tests/Readers/traits/SingleImportTestingTrait.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | trait SingleImportTestingTrait {
  4 | 
  5 | 
  6 |     public function testGet()
  7 |     {
  8 |         $got = $this->loadedFile->get();
  9 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\RowCollection', $got);
 10 |         $this->assertCount(5, $got);
 11 |     }
 12 | 
 13 | 
 14 |     public function testGetWithColumns()
 15 |     {
 16 |         $columns = array('heading_one', 'heading_two');
 17 |         $got = $this->loadedFile->get($columns);
 18 | 
 19 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\RowCollection', $got);
 20 |         $this->assertCount(5, $got);
 21 |     }
 22 | 
 23 | 
 24 |     public function testAll()
 25 |     {
 26 |         $all = $this->loadedFile->all();
 27 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\RowCollection', $all);
 28 |         $this->assertCount(5, $all);
 29 |     }
 30 | 
 31 | 
 32 |     public function testFirst()
 33 |     {
 34 |         $first = $this->loadedFile->first();
 35 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\CellCollection', $first);
 36 | 
 37 |         // 3 columns
 38 |         $this->assertCount(3, $first);
 39 |     }
 40 | 
 41 | 
 42 |     public function testFirstWithColumns()
 43 |     {
 44 |         $columns = array('heading_one', 'heading_two');
 45 |         $first = $this->loadedFile->first($columns);
 46 | 
 47 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\CellCollection', $first);
 48 |         $this->assertCount(count($columns), $first);
 49 |     }
 50 | 
 51 | 
 52 |     public function testEach()
 53 |     {
 54 |         $me = $this;
 55 | 
 56 |         $this->loadedFile->each(function($cells) use($me) {
 57 | 
 58 |             $me->assertInstanceOf('Maatwebsite\Excel\Collections\CellCollection', $cells);
 59 | 
 60 |         });
 61 |     }
 62 | 
 63 | 
 64 |     public function testToArray()
 65 |     {
 66 |         $array = $this->loadedFile->toArray();
 67 |         $this->assertEquals(array(
 68 | 
 69 |             array(
 70 |                 'heading_one'  => 'test',
 71 |                 'heading_two'  => 'test',
 72 |                 'heading_three'  => 'test',
 73 |             ),
 74 |             array(
 75 |                 'heading_one'  => 'test',
 76 |                 'heading_two'  => 'test',
 77 |                 'heading_three'  => 'test',
 78 |             ),
 79 |             array(
 80 |                 'heading_one'  => 'test',
 81 |                 'heading_two'  => 'test',
 82 |                 'heading_three'  => 'test',
 83 |             ),
 84 |             array(
 85 |                 'heading_one'  => 'test',
 86 |                 'heading_two'  => 'test',
 87 |                 'heading_three'  => 'test',
 88 |             ),
 89 |             array(
 90 |                 'heading_one'  => 'test',
 91 |                 'heading_two'  => 'test',
 92 |                 'heading_three'  => 'test',
 93 |             )
 94 | 
 95 |         ), $array);
 96 |     }
 97 | 
 98 | 
 99 |     public function testImportedHeadingsSlugged()
100 |     {
101 |         $first = $this->loadedFile->first()->toArray();
102 |         $keys  = array_keys($first);
103 | 
104 |         $this->assertEquals(array(
105 |             'heading_one',
106 |             'heading_two',
107 |             'heading_three'
108 |         ), $keys);
109 |     }
110 | 
111 | 
112 |     public function testImportedHeadingsHashed()
113 |     {
114 |         Config::set('excel.import.heading', 'hashed');
115 | 
116 |         $loaded = $this->reload();
117 | 
118 |         $first = $loaded->first()->toArray();
119 |         $keys  = array_keys($first);
120 | 
121 |         $this->assertEquals(array(
122 |             md5('heading one'),
123 |             md5('heading two'),
124 |             md5('heading three')
125 |         ), $keys);
126 |     }
127 | 
128 | 
129 |     public function testImportedHeadingsNumeric()
130 |     {
131 |         Config::set('excel.import.heading', 'numeric');
132 | 
133 |         $loaded = $this->reload();
134 | 
135 |         $first = $loaded->first()->toArray();
136 |         $keys  = array_keys($first);
137 | 
138 |         $this->assertEquals(array(
139 |             0,
140 |             1,
141 |             2
142 |         ), $keys);
143 |     }
144 | 
145 | 
146 |     public function testImportedHeadingsOriginal()
147 |     {
148 |         Config::set('excel.import.heading', 'original');
149 | 
150 |         $loaded = $this->reload();
151 | 
152 |         $first = $loaded->first()->toArray();
153 |         $keys  = array_keys($first);
154 | 
155 |         $this->assertEquals(array(
156 |             'heading one',
157 |             'heading two',
158 |             'heading three'
159 |         ), $keys);
160 |     }
161 | 
162 | 
163 |     public function testRemember()
164 |     {
165 |         $remembered = $this->loadedFile->remember(10);
166 | 
167 |         $this->assertEquals($this->reader, $remembered);
168 |         $this->assertEquals(10, $remembered->cacheMinutes);
169 |         $this->assertTrue($remembered->remembered);
170 |     }
171 | 
172 | 
173 |     public function testByConfig()
174 |     {
175 |         $config = $this->loadedFile->byConfig('excel.import.sheets');
176 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\SheetCollection', $config);
177 |     }
178 | 
179 | 
180 |     public function testByConfigCallback()
181 |     {
182 |         $me = $this;
183 | 
184 |         $config = $this->loadedFile->byConfig('excel.import.sheets', function($config) use($me)
185 |         {
186 |             $me->assertInstanceOf('Maatwebsite\Excel\Readers\ConfigReader', $config);
187 |         });
188 | 
189 |         $this->assertInstanceOf('Maatwebsite\Excel\Collections\SheetCollection', $config);
190 |     }
191 | 
192 | 
193 |     public function testTake()
194 |     {
195 |         $taken = $this->loadedFile->take(2);
196 |         $this->assertEquals(2, $taken->getLimit());
197 |         $this->assertCount(2, $taken->get());
198 |     }
199 | 
200 | 
201 |     public function testSkip()
202 |     {
203 |         $taken = $this->loadedFile->skip(1);
204 |         $this->assertEquals(1, $taken->getSkip());
205 |         $this->assertCount(4, $taken->get());
206 |     }
207 | 
208 | 
209 |     public function testLimit()
210 |     {
211 |         $taken = $this->loadedFile->limit(2, 1);
212 |         $this->assertEquals(2, $taken->getLimit());
213 |         $this->assertEquals(1, $taken->getSkip());
214 |         $this->assertCount(2, $taken->get());
215 |     }
216 | 
217 | 
218 |     public function testSelect()
219 |     {
220 |         $columns = array('heading_one', 'heading_two');
221 | 
222 |         $taken = $this->loadedFile->select($columns);
223 |         $this->assertEquals($columns, $taken->columns);
224 |     }
225 | 
226 | 
227 |     public function testSetDateFormat()
228 |     {
229 |         $set = $this->loadedFile->setDateFormat('Y-m-d');
230 |         $this->assertEquals('Y-m-d', $set->getDateFormat());
231 |     }
232 | 
233 | 
234 |     public function testFormatDates()
235 |     {
236 |         $set = $this->loadedFile->formatDates(true, 'Y-m-d');
237 |         $this->assertTrue($set->needsDateFormatting());
238 |         $this->assertEquals('Y-m-d', $set->getDateFormat());
239 |     }
240 | 
241 | 
242 |     public function testSetDateColumns()
243 |     {
244 |         $set = $this->loadedFile->setDateColumns('created_at', 'deleted_at');
245 |         $this->assertTrue($set->needsDateFormatting());
246 |         $this->assertEquals(array('created_at', 'deleted_at'), $set->getDateColumns());
247 |     }
248 | 
249 | 
250 |     public function testCalculate()
251 |     {
252 |         $set = $this->loadedFile->calculate();
253 |         $this->assertTrue($set->needsCalculation());
254 |     }
255 | 
256 | 
257 |     public function testIgnoreEmpty()
258 |     {
259 |         $set = $this->loadedFile->ignoreEmpty();
260 |         $this->assertTrue($set->needsIgnoreEmpty());
261 |     }
262 | }


--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Orchestra\Testbench\TestCase as TestBenchTestCase;
 4 | 
 5 | class TestCase extends TestBenchTestCase
 6 | {
 7 | 
 8 |     public function testExcelClass()
 9 |     {
10 |         $excel = App::make('Maatwebsite\Excel\Excel');
11 |         $this->assertInstanceOf('Maatwebsite\Excel\Excel', $excel);
12 |     }
13 | 
14 | 
15 |     protected function getPackageProviders($app)
16 |     {
17 |         return array('Maatwebsite\Excel\ExcelServiceProvider');
18 |     }
19 | 
20 | 
21 |     protected function getPackagePath()
22 |     {
23 |         return realpath(implode(DIRECTORY_SEPARATOR, array(
24 |             __DIR__,
25 |             '..',
26 |             'src',
27 |             'Maatwebsite',
28 |             'Excel'
29 |         )));
30 |     }
31 | 
32 | }


--------------------------------------------------------------------------------
/tests/TestConfig.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Mockery as m;
 4 | 
 5 | class TestConfig extends TestCase
 6 | {
 7 | 
 8 |     public function tearDown()
 9 |     {
10 |         parent::tearDown();
11 |         m::close();
12 |     }
13 | 
14 |     public function testCreatorConfig()
15 |     {
16 |         $this->assertEquals(Config::get('excel.creator'), 'Maatwebsite');
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/tests/TestServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Maatwebsite\Excel\ExcelServiceProvider;
 4 | use Mockery as m;
 5 | 
 6 | class TestServiceProvider extends TestCase
 7 | {
 8 | 
 9 |     public function setUp()
10 |     {
11 |         parent::setUp();
12 |     }
13 | 
14 |     public function tearDown()
15 |     {
16 |         parent::tearDown();
17 |         m::close();
18 |     }
19 | 
20 |     public function testProviders()
21 |     {
22 |         $app = m::mock('Illuminate\Foundation\Application');
23 |         $provider = new ExcelServiceProvider($app);
24 | 
25 |         $this->assertCount(6, $provider->provides());
26 | 
27 |         $this->assertContains('excel', $provider->provides());
28 |         $this->assertContains('phpexcel', $provider->provides());
29 |         $this->assertContains('excel.reader', $provider->provides());
30 |         $this->assertContains('excel.readers.html', $provider->provides());
31 |         $this->assertContains('excel.parsers.view', $provider->provides());
32 |         $this->assertContains('excel.writer', $provider->provides());
33 |     }
34 | }


--------------------------------------------------------------------------------
/tests/Writers/ExcelWriterTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use Mockery as m;
  4 | use Maatwebsite\Excel\Facades\Excel;
  5 | use Maatwebsite\Excel\Classes;
  6 | use Maatwebsite\Excel\Writers\LaravelExcelWriter;
  7 | 
  8 | class ExcelWriterTest extends TestCase {
  9 | 
 10 |     /**
 11 |      * Setup
 12 |      */
 13 |     public function setUp()
 14 |     {
 15 |         parent::setUp();
 16 | 
 17 |         // Set excel class
 18 |         $this->excel = App::make('phpexcel');
 19 | 
 20 |         // Set writer class
 21 |         $this->writer = App::make('excel.writer');
 22 |         $this->writer->injectExcel($this->excel);
 23 |     }
 24 | 
 25 |     /**
 26 |      * Test the excel injection
 27 |      * @return [type] [description]
 28 |      */
 29 |     public function testExcelInjection()
 30 |     {
 31 |         $this->assertEquals($this->excel, $this->writer->getExcel());
 32 |     }
 33 | 
 34 |     /**
 35 |      * Test setTitle()
 36 |      * @return [type] [description]
 37 |      */
 38 |     public function testSetTitle()
 39 |     {
 40 |         $title = 'Workbook Title';
 41 |         $titleSet = $this->writer->setTitle($title);
 42 |         $this->assertEquals($this->writer, $titleSet);
 43 | 
 44 |         // Test if title was really set
 45 |         $this->assertEquals($this->writer->getTitle(),                  $title);
 46 |         $this->assertEquals($this->writer->getProperties()->getTitle(), $title);
 47 |     }
 48 | 
 49 |     /**
 50 |      * Test setTitle()
 51 |      * @return [type] [description]
 52 |      */
 53 |     public function testSetFilename()
 54 |     {
 55 |         $filename       = 'filename';
 56 |         $filenameSet    = $this->writer->setFileName($filename);
 57 |         $this->assertEquals($this->writer, $filenameSet);
 58 | 
 59 |         // Test if title was really set
 60 |         $this->assertEquals($this->writer->getFileName(), $filename);
 61 |     }
 62 | 
 63 | 
 64 |     /**
 65 |      * Test the share view
 66 |      * @return [type] [description]
 67 |      */
 68 |     public function testShareView()
 69 |     {
 70 |         // Set params
 71 |         $view = 'excel';
 72 |         $data = array();
 73 |         $mergeData = array();
 74 | 
 75 |         $viewShared = $this->writer->shareView($view, $data, $mergeData);
 76 |         $this->assertEquals($this->writer, $viewShared);
 77 | 
 78 |         // Get the parser
 79 |         $parser = $this->writer->getParser();
 80 | 
 81 |         // Test if parse data was set
 82 |         $this->assertEquals($parser->getView(),         $view);
 83 |         $this->assertEquals($parser->getData(),         $data);
 84 |         $this->assertEquals($parser->getMergeData(),    $mergeData);
 85 |     }
 86 | 
 87 |     /**
 88 |      * Test basic sheet creation
 89 |      * @return [type] [description]
 90 |      */
 91 |     public function testSheet()
 92 |     {
 93 |         $title = 'Worksheet Title';
 94 |         $sheetCreated = $this->writer->sheet($title);
 95 | 
 96 |         $this->assertEquals($this->writer, $sheetCreated);
 97 | 
 98 |         // Test if title was really set
 99 |         $this->assertEquals($this->writer->getSheet()->getTitle(), $title);
100 |     }
101 | 
102 |     /**
103 |      * Test sheet closure
104 |      * @return [type] [description]
105 |      */
106 |     public function testSheetClosure()
107 |     {
108 |         $title = 'Worksheet Title';
109 |         $closureTitle = 'Closure Title';
110 | 
111 |         $this->writer->sheet($title, function($sheet) use($closureTitle) {
112 |             $sheet->setTitle($closureTitle);
113 |         });
114 | 
115 |         // Test if title was really set
116 |         $this->assertEquals($this->writer->getSheet()->getTitle(), $closureTitle);
117 |     }
118 | 
119 |     /**
120 |      * Test multiple sheet creation
121 |      * @return [type] [description]
122 |      */
123 |     public function testMultipleSheets()
124 |     {
125 |         // Set sheet titles
126 |         $sheets = array(
127 |             'Worksheet 1 title',
128 |             'Worksheet 2 title',
129 |             'Worksheet 3 title'
130 |         );
131 | 
132 |         // Create the sheets
133 |         foreach($sheets as $sheetTitle)
134 |         {
135 |             $this->writer->sheet($sheetTitle);
136 |         }
137 | 
138 |         // Count amount of sheets
139 |         $this->assertEquals(count($sheets), $this->writer->getSheetCount());
140 | 
141 |         // Test if all sheet titles where set correctly
142 |         foreach($sheets as $sheetTitle)
143 |         {
144 |             $this->assertContains($sheetTitle, $this->writer->getSheetNames());
145 |         }
146 |     }
147 | 
148 |     /**
149 |      * Test setting properties (creator, ...)
150 |      * @return [type] [description]
151 |      */
152 |     public function testSetProperties()
153 |     {
154 |         // Get available properties
155 |         $properties = $this->excel->getAllowedProperties();
156 | 
157 |         // Loop through them
158 |         foreach($properties as $prop)
159 |         {
160 |             // Set a random value
161 |             $originalValue = rand();
162 | 
163 |             // Set needed set/get methods
164 |             $method     = 'set' . ucfirst($prop);
165 |             $getMethod  = 'get' . ucfirst($prop);
166 | 
167 |             // Set the property with the random value
168 |             call_user_func_array(array($this->writer, $method), array($originalValue));
169 | 
170 |             // Get the property back
171 |             $returnedValue = call_user_func_array(array($this->writer->getProperties(), $getMethod), array());
172 | 
173 |             // Check if the properties matches
174 |             $this->assertEquals($originalValue, $returnedValue, $prop . ' doesn\'t match');
175 |         }
176 |     }
177 | 
178 |     public function testCreateFromArray()
179 |     {
180 |         $info = Excel::create('test', function ($writer)
181 |         {
182 | 
183 |             $writer->sheet('test', function ($sheet)
184 |             {
185 |                 $sheet->fromArray([
186 |                     'test data'
187 |                 ]);
188 |             });
189 |         })->store('csv', __DIR__ . '/exports', true);
190 | 
191 |         $this->assertTrue(file_exists($info['full']));
192 |     }
193 | 
194 | 
195 |     public function testNumberPrecision()
196 |     {
197 |         $info = Excel::create('numbers', function ($writer)
198 |         {
199 |             $writer->sheet('test', function ($sheet)
200 |             {
201 |                 $sheet->fromArray([
202 |                     ['number' => '1234'],
203 |                     ['number' => '1234.020'],
204 |                     ['number' => '01234HelloWorld'],
205 |                     ['number' => '12345678901234567890'],
206 |                     ['number' => 1234],
207 |                     ['number' => 1234.02],
208 |                     ['number' => 0.0231231234423],
209 |                     ['number' => 4195.99253472222],
210 |                     ['number' => '= A6 + A6'],
211 |                 ]);
212 |             });
213 |         })->store('xls', __DIR__ . '/exports', true);
214 | 
215 |         $this->assertTrue(file_exists($info['full']));
216 | 
217 |         $results = Excel::load($info['full'], null, false, true)->calculate()->toArray();
218 | 
219 |         $this->assertEquals('1234', $results[0]['number']);
220 |         $this->assertEquals('1234.020', $results[1]['number']);
221 |         $this->assertEquals('01234HelloWorld', $results[2]['number']);
222 |         $this->assertEquals('12345678901234567890', $results[3]['number']);
223 | 
224 |         $this->assertTrue(is_double($results[4]['number']));
225 |         $this->assertEquals((double) 1234, $results[4]['number']);
226 | 
227 |         $this->assertTrue(is_double($results[5]['number']));
228 |         $this->assertEquals('1234.02', $results[5]['number']);
229 | 
230 |         $this->assertTrue(is_double($results[6]['number']));
231 |         $this->assertEquals('0.0231231234423', $results[6]['number']);
232 | 
233 |         $this->assertTrue(is_double($results[7]['number']));
234 |         $this->assertEquals(4195.99253472222, $results[7]['number']);
235 | 
236 |         $this->assertEquals(1234 + 1234, $results[8]['number']);
237 |     }
238 | }


--------------------------------------------------------------------------------
/tests/Writers/exports/.gitignore:
--------------------------------------------------------------------------------
1 | *
2 | !.gitignore


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