├── .codeclimate.yml
├── .github
    └── workflows
    │   └── push.yml
├── .gitignore
├── CONTRIBUTE.md
├── README.md
├── composer.json
├── docs
    ├── _config.yml
    ├── _data
    │   └── menu.yml
    ├── _layouts
    │   └── default.html
    ├── _reference
    │   ├── class.md.twig
    │   ├── index.md.twig
    │   ├── method.md.twig
    │   └── template.xml
    ├── bulkInserts.md
    ├── configuration.md
    ├── entities.md
    ├── entityDefinition.md
    ├── events.md
    ├── filters.md
    ├── index.md
    ├── javascripts
    │   └── scale.fix.js
    ├── querybuilder.md
    ├── reference.md
    ├── relationDefinition.md
    ├── relations.md
    ├── stylesheets
    │   ├── highlight.css
    │   └── styles.css
    ├── testing.md
    └── validate.md
├── examples
    ├── bootstrap.php
    ├── entities.php
    ├── fetch.php
    ├── filter.php
    ├── morphed.php
    └── observe.php
├── icon.svg
├── logo.svg
├── phpdoc.xml
├── phpunit.xml
├── src
    ├── BulkInsert.php
    ├── DbConfig.php
    ├── Dbal
    │   ├── Column.php
    │   ├── Dbal.php
    │   ├── Error.php
    │   ├── Error
    │   │   ├── InvalidJson.php
    │   │   ├── NoBoolean.php
    │   │   ├── NoDateTime.php
    │   │   ├── NoNumber.php
    │   │   ├── NoString.php
    │   │   ├── NoTime.php
    │   │   ├── NotAllowed.php
    │   │   ├── NotNullable.php
    │   │   ├── NotValid.php
    │   │   └── TooLong.php
    │   ├── Escaping.php
    │   ├── Expression.php
    │   ├── Mysql.php
    │   ├── Other.php
    │   ├── Pgsql.php
    │   ├── QueryLanguage
    │   │   ├── CompositeInExpression.php
    │   │   ├── CompositeInValuesExpression.php
    │   │   ├── DeleteStatement.php
    │   │   ├── InsertStatement.php
    │   │   ├── UpdateFromStatement.php
    │   │   ├── UpdateJoinStatement.php
    │   │   ├── UpdateStatement.php
    │   │   └── WhereClause.php
    │   ├── Sqlite.php
    │   ├── Table.php
    │   ├── Type.php
    │   ├── Type
    │   │   ├── Boolean.php
    │   │   ├── DateTime.php
    │   │   ├── Enum.php
    │   │   ├── Json.php
    │   │   ├── Number.php
    │   │   ├── Set.php
    │   │   ├── Text.php
    │   │   ├── Time.php
    │   │   └── VarChar.php
    │   └── TypeInterface.php
    ├── EM.php
    ├── Entity.php
    ├── Entity
    │   ├── Booting.php
    │   ├── EventHandlers.php
    │   ├── GeneratesPrimaryKeys.php
    │   ├── Naming.php
    │   ├── Relations.php
    │   └── Validation.php
    ├── EntityFetcher.php
    ├── EntityFetcher
    │   ├── AppliesFilters.php
    │   ├── CallableFilter.php
    │   ├── ExecutesQueries.php
    │   ├── FilterInterface.php
    │   ├── MakesJoins.php
    │   └── TranslatesClasses.php
    ├── EntityManager.php
    ├── Event.php
    ├── Event
    │   ├── Changed.php
    │   ├── Deleted.php
    │   ├── Deleting.php
    │   ├── Fetched.php
    │   ├── Inserted.php
    │   ├── Inserting.php
    │   ├── Saved.php
    │   ├── Saving.php
    │   ├── UpdateEvent.php
    │   ├── Updated.php
    │   └── Updating.php
    ├── Exception.php
    ├── Exception
    │   ├── IncompletePrimaryKey.php
    │   ├── InvalidArgument.php
    │   ├── InvalidConfiguration.php
    │   ├── InvalidName.php
    │   ├── InvalidRelation.php
    │   ├── InvalidType.php
    │   ├── NoConnection.php
    │   ├── NoEntity.php
    │   ├── NoEntityManager.php
    │   ├── NoOperator.php
    │   ├── NotJoined.php
    │   ├── NotScalar.php
    │   ├── UndefinedRelation.php
    │   ├── UnknownColumn.php
    │   └── UnsupportedDriver.php
    ├── Helper.php
    ├── MockTrait.php
    ├── Namer.php
    ├── Observer
    │   ├── AbstractObserver.php
    │   └── CallbackObserver.php
    ├── ObserverInterface.php
    ├── QueryBuilder
    │   ├── ExecutesQueries.php
    │   ├── HasWhereConditions.php
    │   ├── MakesJoins.php
    │   ├── Parenthesis.php
    │   ├── ParenthesisInterface.php
    │   ├── QueryBuilder.php
    │   └── QueryBuilderInterface.php
    ├── Relation.php
    ├── Relation
    │   ├── HasOpponent.php
    │   ├── HasReference.php
    │   ├── ManyToMany.php
    │   ├── Morphed.php
    │   ├── OneToMany.php
    │   ├── OneToOne.php
    │   ├── Owner.php
    │   └── ParentChildren.php
    └── Testing
    │   ├── EntityFetcherMock.php
    │   ├── EntityFetcherMock
    │       ├── Result.php
    │       └── ResultRepository.php
    │   ├── EntityManagerMock.php
    │   └── MocksEntityManager.php
└── tests
    ├── BulkInsertTest.php
    ├── ClosureWrapper.php
    ├── Constraint
        └── ArraySubset.php
    ├── DbConfigTest.php
    ├── Dbal
        ├── BasicTest.php
        ├── BulkInsertTest.php
        ├── ColumnTest.php
        ├── DataModificationTest.php
        ├── EscapeValueTest.php
        ├── Mysql
        │   ├── DescribeTest.php
        │   └── UpdateJoinTest.php
        ├── Other
        │   └── UpdateTest.php
        ├── Pgsql
        │   ├── DescribeTest.php
        │   └── UpdateFromTest.php
        ├── Sqlite
        │   ├── DescribeTest.php
        │   ├── InsertTest.php
        │   └── UpdateFromTest.php
        ├── TransactionTest.php
        ├── Type
        │   ├── BooleanTest.php
        │   ├── Custom
        │   │   ├── CustomColumn.php
        │   │   ├── Point.php
        │   │   └── PointTest.php
        │   ├── DateTimeTest.php
        │   ├── EnumTest.php
        │   ├── JsonTest.php
        │   ├── NumberTest.php
        │   ├── SetTest.php
        │   ├── TextTest.php
        │   ├── TimeTest.php
        │   └── VarCharTest.php
        └── ValidateTest.php
    ├── Entity
        ├── BasicTest.php
        ├── BootTestEntity.php
        ├── BootTestTrait.php
        ├── BootingTest.php
        ├── ColumnNameTest.php
        ├── DataTest.php
        ├── Examples
        │   ├── Article.php
        │   ├── Category.php
        │   ├── Concerns
        │   │   ├── WithCreated.php
        │   │   ├── WithTimestamps.php
        │   │   └── WithUpdated.php
        │   ├── ContactPhone.php
        │   ├── DamagedABBRVCase.php
        │   ├── GeneratesUuid.php
        │   ├── Image.php
        │   ├── Psr0_StudlyCaps.php
        │   ├── RelationExample.php
        │   ├── Snake_Ucfirst.php
        │   ├── StaticTableName.php
        │   ├── StudlyCaps.php
        │   ├── Tag.php
        │   ├── Taggable.php
        │   ├── User.php
        │   └── UserContact.php
        ├── ExistsTest.php
        ├── HelperTest.php
        ├── IssetTest.php
        ├── RelationsTest.php
        ├── SaveEntityTest.php
        ├── TableNameTest.php
        ├── ToArrayTest.php
        └── ValidateTest.php
    ├── EntityFetcher
        ├── BasicTest.php
        ├── CountTest.php
        ├── EagerLoadTest.php
        ├── Examples
        │   └── NotDeletedFilter.php
        ├── ExecutesQueriesTest.php
        └── FilterTest.php
    ├── EntityManager
        ├── BulkInsertTest.php
        ├── ConnectionsTest.php
        ├── DataModificationTest.php
        ├── DescribeTest.php
        ├── EagerLoadTest.php
        ├── Examples
        │   ├── Concrete.php
        │   ├── Entity.php
        │   ├── SubNamespace
        │   │   └── Entity.php
        │   ├── Unspecified.php
        │   └── functions.php
        ├── GetInstanceTest.php
        ├── MappingTest.php
        └── OptionsTest.php
    ├── Examples
        ├── AuditObserver.php
        ├── CustomEvent.php
        └── DateTimeDerivate.php
    ├── ExceptionsTest.php
    ├── HelperTest.php
    ├── NamerTest.php
    ├── Observer
        ├── AbstractObserverTest.php
        ├── CallbackObserverTest.php
        ├── EventTest.php
        ├── FireEventTest.php
        └── ObserverRegistrationTest.php
    ├── QueryBuilder
        ├── BasicTest.php
        ├── FetchTest.php
        ├── JoinTest.php
        └── WhereConditionsTest.php
    ├── Relation
        ├── ManyToManyTest.php
        ├── MorphedRelationTest.php
        ├── OneToManyTest.php
        ├── OneToOneTest.php
        ├── OwnerTest.php
        ├── ParentChildrenTest.php
        └── RelationsFilterTest.php
    ├── TestCase.php
    ├── TestEntity.php
    ├── TestEntityFetcher.php
    ├── TestEntityManager.php
    └── Testing
        ├── CreateMockedEntityTest.php
        ├── EntityFetcherMockTest.php
        ├── EntityFetcherResultTest.php
        ├── ExpectDeleteTest.php
        ├── ExpectFetchTest.php
        ├── ExpectInsertTest.php
        ├── ExpectUpdateTest.php
        └── InitMockTest.php


/.codeclimate.yml:
--------------------------------------------------------------------------------
 1 | version: "2"
 2 | 
 3 | checks:
 4 |     method-complexity:
 5 |         config:
 6 |             threshold: 9
 7 | 
 8 | exclude_patterns:
 9 |     - "config/"
10 |     - "db/"
11 |     - "dist/"
12 |     - "docs/"
13 |     - "features/"
14 |     - "**/node_modules/"
15 |     - "script/"
16 |     - "**/spec/"
17 |     - "**/test/"
18 |     - "**/tests/"
19 |     - "Tests/"
20 |     - "example.php"
21 |     - "examples/"
22 |     - "**/vendor/"
23 |     - "**/*_test.go"
24 |     - "**/*.d.ts"
25 | 
26 | plugins:
27 |     phpcodesniffer:
28 |         enabled: true
29 |         config:
30 |             standard: "PSR2"
31 | 


--------------------------------------------------------------------------------
/.github/workflows/push.yml:
--------------------------------------------------------------------------------
 1 | on: [push, pull_request]
 2 | jobs:
 3 |   before:
 4 |     runs-on: ubuntu-latest
 5 |     steps:
 6 |       - name: Setup Code-Climate
 7 |         uses: amancevice/setup-code-climate@v1
 8 |         with:
 9 |           cc_test_reporter_id: ${{ secrets.CC_TEST_REPORTER_ID }}
10 | 
11 |       - name: Prepare CodeClimate
12 |         run: cc-test-reporter before-build
13 | 
14 |   unit-tests:
15 |     needs: [before]
16 |     strategy:
17 |       matrix:
18 |         php-version: ["7.3", "7.4", "8.0", "8.1", "8.2"]
19 |     name: PHP Unit Tests on PHP ${{ matrix.php-version }}
20 |     runs-on: ubuntu-latest
21 |     steps:
22 |       - name: Checkout
23 |         uses: actions/checkout@v3
24 | 
25 |       - name: Setup PHP
26 |         uses: shivammathur/setup-php@v2
27 |         with:
28 |           php-version: ${{ matrix.php-version }}
29 | 
30 |       - name: Setup Code-Climate
31 |         uses: amancevice/setup-code-climate@v1
32 |         with:
33 |           cc_test_reporter_id: ${{ secrets.CC_TEST_REPORTER_ID }}
34 | 
35 |       - name: Get composer cache directory
36 |         id: composer-cache
37 |         run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
38 | 
39 |       - name: Cache dependencies
40 |         uses: actions/cache@v3
41 |         with:
42 |           path: ${{ steps.composer-cache.outputs.dir }}
43 |           key: composer-cache-${{ matrix.php-version }}
44 | 
45 |       - name: Install dependencies
46 |         run: composer install --no-interaction --ansi
47 | 
48 |       - name: Execute tests
49 |         run: |
50 |           php -dzend_extension=xdebug.so -dxdebug.mode=coverage vendor/bin/phpunit \
51 |             -c phpunit.xml \
52 |             --coverage-clover=coverage/clover.xml \
53 |             --coverage-text \
54 |             --color=always
55 | 
56 |       - name: Format Coverage
57 |         run: cc-test-reporter format-coverage -t clover -o coverage/cc-${{ matrix.php-version }}.json coverage/clover.xml
58 | 
59 |       - name: Store Coverage Result
60 |         uses: actions/upload-artifact@v3
61 |         with:
62 |           name: coverage-results
63 |           path: coverage/
64 | 
65 |   after:
66 |     needs: [unit-tests]
67 |     runs-on: ubuntu-latest
68 |     steps:
69 |       - name: Restore Coverage Result
70 |         uses: actions/download-artifact@v3
71 |         with:
72 |           name: coverage-results
73 |           path: coverage/
74 | 
75 |       - name: Setup Code-Climate
76 |         uses: amancevice/setup-code-climate@v1
77 |         with:
78 |           cc_test_reporter_id: ${{ secrets.CC_TEST_REPORTER_ID }}
79 | 
80 |       - name: Report Coverage
81 |         run: |
82 |           cc-test-reporter sum-coverage coverage/cc-*.json -p 5 -o coverage/cc-total.json
83 |           cc-test-reporter upload-coverage -i coverage/cc-total.json
84 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor/
2 | /docs/_site
3 | /composer.lock
4 | /docs/.jekyll-cache
5 | /examples/*.sqlite
6 | /examples/*.sql
7 | /.phpunit.result.cache
8 | 


--------------------------------------------------------------------------------
/CONTRIBUTE.md:
--------------------------------------------------------------------------------
 1 | # Notes for contributors
 2 | 
 3 | Please have in mind that this library is PSR-2 compliant. No changes can be merged that are not PSR-2 compliant.
 4 | 
 5 | ## Testing
 6 | 
 7 | The code should have a 100% code coverage. To run the code coverage is not necessary - it will run on pull request. If
 8 | There is something not testable we either find a solution or mark it with @ignoreCodeCoverage.
 9 | 
10 | To run the tests you just have to install the dev dependencies with `composer install`. Then you can start both:
11 | Unit tests `composer test` and code sniffer `composer code-style`.
12 | 
13 | ## Documentation
14 | 
15 | You should update the documentation according to your changes.
16 |  
17 | In order to update the API reference you will also have to install docker. Use this command to update the
18 | documentation:
19 | 
20 | ```console
21 | $ docker run --rm --user $(id -u) -v $(pwd):/data -v $(pwd)/docs/_reference:/opt/phpdoc/data/templates/_reference iras/phpdoc2:2 phpdoc -c phpdoc.xml
22 | ```
23 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "tflori/orm",
 3 |   "description": "lightweight object relational mapper",
 4 |   "license": "MIT",
 5 |   "require": {
 6 |     "php": "^7.3 || ^8.0",
 7 |     "ext-json": "*",
 8 |     "ext-mbstring": "*",
 9 |     "ext-pdo": "*"
10 |   },
11 |   "require-dev": {
12 |     "mockery/mockery": "^1.1",
13 |     "phpunit/phpunit": "*",
14 |     "tflori/phpunit-printer": "*",
15 |     "squizlabs/php_codesniffer": "^3.5"
16 |   },
17 |   "suggest": {
18 |     "mockery/mockery": "^1.1"
19 |   },
20 |   "autoload": {
21 |     "psr-4": {
22 |       "ORM\\": "src/"
23 |     }
24 |   },
25 |   "autoload-dev": {
26 |     "psr-4": {
27 |       "ORM\\Test\\": "tests/"
28 |     }
29 |   },
30 |   "archive": {
31 |     "exclude": ["/tests", "/docs", "/examples"]
32 |   },
33 |   "scripts": {
34 |     "code-style": [
35 |       "phpcs --standard=PSR2 src",
36 |       "phpcs --standard=PSR2 --ignore=Examples tests"
37 |     ],
38 |     "coverage": "phpunit --coverage-text",
39 |     "test": "phpunit --color=always"
40 |   }
41 | }
42 | 


--------------------------------------------------------------------------------
/docs/_config.yml:
--------------------------------------------------------------------------------
1 | baseurl: /orm
2 | 


--------------------------------------------------------------------------------
/docs/_data/menu.yml:
--------------------------------------------------------------------------------
 1 | Introduction: /
 2 | Configuration: /configuration.html
 3 | Entity Definition: /entityDefinition.html
 4 | Working With Entities: /entities.html
 5 | Use Filters: /filters.html
 6 | Relation Definition: /relationDefinition.html
 7 | Working With Relations: /relations.html
 8 | Events and Observers: /events.html
 9 | Use QueryBuilder: /querybuilder.html
10 | Validate Data: /validate.html
11 | Bulk Inserts: /bulkInserts.html
12 | Testing: /testing.html
13 | 
14 | ' ': /placeholder.html
15 | 
16 | API Reference: /reference.html
17 | 


--------------------------------------------------------------------------------
/docs/_layouts/default.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta http-equiv="X-UA-Compatible" content="chrome=1">
 6 |     <title>tflori/orm - {{ page.title }}</title>
 7 |     <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,600,700' rel='stylesheet' type='text/css'>
 8 |     <link rel="stylesheet" href="stylesheets/styles.css">
 9 |     <link rel="stylesheet" href="stylesheets/highlight.css">
10 |     <meta name="viewport" content="width=device-width">
11 |     <!--[if lt IE 9]>
12 |     <script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
13 |     <![endif]-->
14 |   </head>
15 |   <body class="dark">
16 |     <div class="wrapper">
17 |       <header>
18 |         <h1>tflori/orm</h1>
19 |         <p>just another orm...</p>
20 | 
21 |         <menu>
22 |           <ul>
23 |             {% for link in site.data.menu %}
24 |             <li {% if page.url == link[1] %}class="selected"{% endif %}>
25 |               <a href=".{{ link[1] }}">{{ link[0] }}</a>
26 |             </li>
27 |             {% endfor %}
28 |           </ul>
29 |         </menu>
30 | 
31 |         <p class="view"><a href="https://github.com/tflori/orm">View the Project on GitHub <small>tflori/orm</small></a></p>
32 | 
33 |         <a href="https://github.com/tflori/orm/actions/workflows/push.yml" rel="nofollow"><img src="https://github.com/tflori/orm/actions/workflows/push.yml/badge.svg" alt="Build Status" style="max-width:100%;"></a>
34 |         <a href="https://codeclimate.com/github/tflori/orm/test_coverage" rel="nofollow"><img src="https://api.codeclimate.com/v1/badges/9434ba649634cb577b87/test_coverage" alt="Test Coverage" style="max-width:100%;"></a>
35 |         <a href="https://codeclimate.com/github/tflori/orm/maintainability" rel="nofollow"><img src="https://api.codeclimate.com/v1/badges/9434ba649634cb577b87/maintainability" alt="Maintainability" data-canonical-src="https://api.codeclimate.com/v1/badges/9434ba649634cb577b87/maintainability" style="max-width:100%;"></a>
36 |         <a href="https://packagist.org/packages/tflori/orm" rel="nofollow"><img src="https://poser.pugx.org/tflori/orm/v/stable.svg" alt="Latest Stable Version" style="max-width:100%;"></a>
37 |         <a href="https://packagist.org/packages/tflori/orm" rel="nofollow"><img src="https://poser.pugx.org/tflori/orm/downloads.svg" alt="Total Downloads" style="max-width:100%;"></a>
38 | 
39 |         <ul class="row">
40 |           <li><a href="https://github.com/tflori/orm/zipball/master">Download <strong>ZIP File</strong></a></li>
41 |           <li><a href="https://github.com/tflori/orm/tarball/master">Download <strong>TAR Ball</strong></a></li>
42 |           <li><a href="https://github.com/tflori/orm">View On <strong>GitHub</strong></a></li>
43 |         </ul>
44 |       </header>
45 |       <section>
46 |         {{ content }}
47 |       </section>
48 |       <footer>
49 |         <p>This project is maintained by <a href="https://github.com/tflori">tflori</a></p>
50 |         <p><a href="https://packagist.org/packages/tflori/orm"><img src="https://poser.pugx.org/tflori/orm/license.svg" alt="License" /></a></p>
51 |         <p><small>Hosted on GitHub Pages &mdash; Theme by <a href="https://github.com/orderedlist">orderedlist</a></small></p>
52 |       </footer>
53 |     </div>
54 |     <script src="javascripts/scale.fix.js"></script>
55 | 
56 |   </body>
57 | </html>
58 | 


--------------------------------------------------------------------------------
/docs/_reference/class.md.twig:
--------------------------------------------------------------------------------
 1 | ### {{ node.FullyQualifiedStructuralElementName|trim('\\') }}
 2 | 
 3 | {% if node.parent is not empty %}
 4 | **Extends:** {% for parent in node.parent %}
 5 | [{{ parent.FullyQualifiedStructuralElementName|trim('\\') }}](#{{ parent.FullyQualifiedStructuralElementName|replace({'\\': ''})|lower }})
 6 | {% else %}[{{ node.parent.FullyQualifiedStructuralElementName|trim('\\') }}](#{{ node.parent.FullyQualifiedStructuralElementName|replace({'\\': ''})|lower }})
 7 | {% endfor %}
 8 | {% endif %}
 9 | 
10 | {% if node.interfaces is not empty %}
11 | **Implements:** {% for interface in node.interfaces %}
12 | [{{ interface.FullyQualifiedStructuralElementName|trim('\\') }}](#{{ interface.FullyQualifiedStructuralElementName|replace({'\\': ''})|lower }})
13 | {% endfor %}
14 | {% endif %}
15 | 
16 | {% if node.summary is not empty and node.summary != 'Class '~node.name %}
17 | #### {{ node.summary|raw }}
18 | {% endif %}
19 | 
20 | {{ node.description|raw }}
21 | 
22 | {% if node.deprecated %}* **Warning:** this class is **deprecated**. This means that this class will likely be removed in a future version.
23 | {% endif %}
24 | 
25 | {% if node.tags.see is not empty or node.tags.link is not empty %}
26 | **See Also:**
27 | 
28 | {% for see in node.tags.see %}
29 | * {{ see.reference }} {% if see.description %}- {{ see.description|raw }}{% endif %}
30 | {% endfor %}
31 | {% for link in node.tags.link %}
32 | * [{{ link.description ?: link.link }}]({{ link.link }})
33 | {% endfor %}
34 | 
35 | {% endif %}{# node.tags.see || node.tags.link #}
36 | 
37 | {% if node.constants is not empty %}
38 | #### Constants
39 | 
40 | | Name | Value |
41 | |------|-------|
42 | {% for constant in node.constants %}
43 | | {{ constant.name }} | `{{ constant.value|raw }}` |
44 | {% endfor %}
45 | 
46 | {% endif %}
47 | 
48 | {% if (node.inheritedProperties.merge(node.properties)) is not empty %}
49 | #### Properties
50 | 
51 | | Visibility | Name | Type | Description                           |
52 | |------------|------|------|---------------------------------------|
53 | {% for property in node.inheritedProperties.merge(node.properties).sortBy('name') %}
54 | | **{{ property.visibility }}{{ property.isStatic ? ' static' }}** | `${{ property.name }}` | {% if property.types is not empty %}**{{ property.types ? property.types|join(' &#124; ')|replace({'<mixed,': '&lt;', (node.namespace.FullyQualifiedStructuralElementName~'\\'): '', '\\': ' \\ '})|raw }}**{% endif %} | {{ property.summary }} |
55 | {% endfor %}
56 | 
57 | {% endif %}
58 | 
59 | 
60 | {% if node.methods is not empty %}
61 | #### Methods
62 | 
63 | {% for method in node.inheritedMethods.merge(node.methods)|sort_asc %}
64 | * [{{ method.name }}](#{{ node.FullyQualifiedStructuralElementName|replace({'\\': ''})|lower }}{{ method.name|lower }}) {{ method.summary }}
65 | {% endfor %}
66 | 
67 | {% for method in node.inheritedMethods.merge(node.methods)|sort_asc %}
68 | {% include 'method.md.twig' %}
69 | {% endfor %}
70 | 
71 | {% endif %}
72 | 
73 | ---
74 | 
75 | 


--------------------------------------------------------------------------------
/docs/_reference/index.md.twig:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: default
 3 | title: API Reference
 4 | permalink: /reference.html
 5 | ---
 6 | ## API Reference
 7 | 
 8 | {% for namespace in project.indexes.namespaces|sort %}
 9 | {% if not namespace.classes.merge(namespace.interfaces) is empty %}
10 | 
11 | ### {{ namespace|trim('\\') }}
12 | 
13 | {% for node in namespace.classes.merge(namespace.interfaces)|sort_asc %}
14 | * [{{ node.name }}](#{{ node.FullyQualifiedStructuralElementName|replace({'\\': ''})|lower }})
15 | {% endfor %}
16 | 
17 | {% endif %}
18 | {% endfor %}
19 | 
20 | ---
21 | 
22 | {% for node in project.indexes.classes.merge(project.indexes.interfaces)|sort_asc %}
23 | {% include 'class.md.twig' %}
24 | {% endfor %}
25 | 


--------------------------------------------------------------------------------
/docs/_reference/method.md.twig:
--------------------------------------------------------------------------------
 1 | #### {{ node.FullyQualifiedStructuralElementName|trim('\\') }}::{{ method.name }}
 2 | 
 3 | ```php
 4 | {{ method.getSignature(80)|replace({'<mixed,': '<'})|raw }}
 5 | ```
 6 | 
 7 | {% if method.summary is not empty %}
 8 | ##### {{ method.summary|raw }}
 9 | {% endif %}
10 | 
11 | {{ method.description|raw }}
12 | 
13 | {% if method.deprecated %}**Warning:** this method is **deprecated**. This means that this method will likely be removed in a future version.
14 | <br />{% endif %}
15 | {% if method.static %}**Static:** this method is **static**.
16 | <br />{% endif %}
17 | **Visibility:** this method is **{{ method.visibility }}**.
18 | <br />
19 | {%  if method.name != '__construct' and method.response %} **Returns**: this method returns **{{ method.response.types[0] == 'self' ? node.name : method.response.types|join('|') }}**
20 | <br />{% endif %}
21 | {% if method.response.description %}**Response description:** {{ method.response.description|raw }}
22 | <br />{% endif %}
23 | {% if method.tags.throws is not empty %}**Throws:** this method may throw {% for throws in method.tags.throws %}
24 | {{ not loop.first ? ' or ' }}**{{ throws.types|join('** or **')|raw }}**{% endfor %}
25 | <br />{% endif %}
26 | 
27 | 
28 | {% if method.arguments is not empty %}
29 | ##### Parameters
30 | 
31 | | Parameter | Type | Description |
32 | |-----------|------|-------------|
33 | {% for argument in method.arguments %}
34 | | `{{ argument.name }}` | {% if argument.types is not empty %}**{{ argument.types ? argument.types|join(' &#124; ')|replace({'<mixed,': '&lt;', (node.namespace.FullyQualifiedStructuralElementName~'\\'): ''})|raw }}**{% endif %}  | {{ argument.description|replace({'|': '&#124;'})|raw }} |
35 | {% endfor %}
36 | 
37 | {% endif %}
38 | 
39 | 
40 | {% if method.tags.see is not empty or method.tags.link is not empty %}
41 | **See Also:**
42 | 
43 | {% for see in method.tags.see %}
44 | * {{ see.reference }} {% if see.description %}- {{ see.description|raw }}{% endif %}
45 | {% endfor %}
46 | {% for link in method.tags.link %}
47 | * [{{ link.description ?: link.link }}]({{ link.link }})
48 | {% endfor %}
49 | 
50 | {% endif %}
51 | 


--------------------------------------------------------------------------------
/docs/_reference/template.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <template>
3 |   <transformations>
4 |     <transformation writer="twig" source="templates/_reference/index.md.twig" artifact="reference.md" />
5 |   </transformations>
6 | </template>
7 | 


--------------------------------------------------------------------------------
/docs/index.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: default
 3 | title: Introduction
 4 | permalink: /
 5 | ---
 6 | ## Introduction
 7 | 
 8 | **TL;DR** Others suck, we can do it better.
 9 | 
10 | Why to create another ORM? There are not enough ORM implementations for PHP already?
11 | 
12 | Yes, there are a lot of implementations:
13 | 
14 | - doctrine/orm
15 |   - heavy: 8,8 MB of everything that you don't need, 6 direct dependencies with own dependencies
16 |   - annotations that makes it unreadable
17 |   - big amount of queries or very slow queries when it comes to join across multiple tables
18 |   
19 | - eloquent
20 |   - no single entry package (you need illuminate/this, that and database)
21 |   - complicated setup
22 |   - I **like** this very much in laravel - so not much to say here against it
23 |   
24 | - propel/propel 
25 |   - still not stable 2.0-dev 
26 |   - even more heavy than doctrine
27 |   - requires a lot of configurations
28 |   
29 | - j4mie/idiorim and j4mie/paris
30 |   - uses a lot of static methods and gets hard to test
31 |   - not compatible to existing dependecy injection models
32 |   - last update 2 years ago
33 |   - everything in one file
34 |   - ...
35 |   
36 | This implementation will have the following features:
37 | 
38 | - no configuration required
39 |   - ok some bit for sure (e.g. how to connect to your database?)
40 |   - of course this is only possible if you setup your database as we think your database should look like. If not you
41 |     should only have to setup the rules of your system and naming conventions.
42 | - simple to use
43 | - lightweight sources
44 | - fast
45 | 
46 | How to achieve this features? The main goal of Doctrine seems to abstract everything - at the end you should be able
47 | to replace the whole DBMS behind your app and switch from postgresql to sqlite. That requires not only a lot of
48 | sources. It also requires some extra cycles to get these abstraction to work.
49 |  
50 | This library will only produce ANSI-SQL that every SQL database should understand. Other queries have to be written by
51 | hand. This has two reasons:
52 | 
53 | 1. You can write much faster and efficient queries
54 | 2. We don't need to write a lot of abstraction (more code; more bugs)
55 | 
56 | This library will not fetch any mistake a developer can make. It aims to be a helper to store data in your database. Not
57 | to replace your database and your knowledge how to use this database. You can make a lot of errors - less than without
58 | this library but still a lot. When you make an error that is not catched (mostly we catch only mistakes that would
59 | cause a fatal error instead) you will get a `PDOException`.
60 | 


--------------------------------------------------------------------------------
/docs/javascripts/scale.fix.js:
--------------------------------------------------------------------------------
 1 | var metas = document.getElementsByTagName('meta');
 2 | var i;
 3 | if (navigator.userAgent.match(/iPhone/i)) {
 4 |     for (i=0; i<metas.length; i++) {
 5 |         if (metas[i].name == "viewport") {
 6 |             metas[i].content = "width=device-width, minimum-scale=1.0, maximum-scale=1.0";
 7 |         }
 8 |     }
 9 |     document.addEventListener("gesturestart", gestureStart, false);
10 | }
11 | function gestureStart() {
12 |     for (i=0; i<metas.length; i++) {
13 |         if (metas[i].name == "viewport") {
14 |             metas[i].content = "width=device-width, minimum-scale=0.25, maximum-scale=1.6";
15 |         }
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/examples/bootstrap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // find the next autoload..
 4 | $dir = __DIR__;
 5 | while ($dir !== '/') {
 6 |     if (file_exists($dir . '/vendor/autoload.php')) {
 7 |         $loader = require_once $dir . '/vendor/autoload.php';
 8 |         break;
 9 |     }
10 |     $dir = dirname($dir);
11 | }
12 | if (!isset($loader)) {
13 |     require_once __DIR__ . '/vendor/autoload.php'; // we fail here
14 | }
15 | 
16 | // create an entitymanager
17 | $em = new ORM\EntityManager([
18 |     ORM\EntityManager::OPT_CONNECTION => new ORM\DbConfig('sqlite', '/tmp/example.sqlite')
19 | ]);
20 | 
21 | // reset the database
22 | $em->getConnection()->query("DROP TABLE IF EXISTS user");
23 | 
24 | $em->getConnection()->query("CREATE TABLE user (
25 |   id INTEGER NOT NULL PRIMARY KEY,
26 |   username VARCHAR (20) NOT NULL,
27 |   password VARCHAR (32) NOT NULL
28 | )");
29 | 
30 | $em->getConnection()->query("CREATE UNIQUE INDEX user_username ON user (username)");
31 | 
32 | $em->getConnection()->query("INSERT INTO user (username, password) VALUES
33 |   ('user_a', '" . md5('password_a') . "'),
34 |   ('user_b', '" . md5('password_b') . "'),
35 |   ('user_c', '" . md5('password_c') . "')
36 | ");
37 | 
38 | $em->getConnection()->query("DROP TABLE IF EXISTS comment");
39 | $em->getConnection()->query("CREATE TABLE comment (
40 |     id INTEGER PRIMARY KEY AUTOINCREMENT,
41 |     parent_type VARCHAR(50) NOT NULL,
42 |     parent_id INTEGER NOT NULL,
43 |     author VARCHAR(50) DEFAULT 'Anonymous' NOT NULL,
44 |     text TEXT
45 | )");
46 | 
47 | $em->getConnection()->query("DROP TABLE IF EXISTS article");
48 | $em->getConnection()->query("CREATE TABLE article (
49 |     id INTEGER PRIMARY KEY AUTOINCREMENT,
50 |     author VARCHAR(50) DEFAULT 'Anonymous' NOT NULL,
51 |     title VARCHAR(255) NOT NULL,
52 |     text TEXT
53 | )");
54 | 
55 | $em->getConnection()->query("DROP TABLE IF EXISTS image");
56 | $em->getConnection()->query("CREATE TABLE image (
57 |     id INTEGER PRIMARY KEY AUTOINCREMENT,
58 |     author VARCHAR(50) DEFAULT 'Anonymous' NOT NULL,
59 |     url VARCHAR(255) NOT NULL,
60 |     caption VARCHAR(255)
61 | )");
62 | 


--------------------------------------------------------------------------------
/examples/entities.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Class User
 5 |  *
 6 |  * The following annotations are optional
 7 |  * @property int id
 8 |  * @property string username
 9 |  * @property string password
10 |  */
11 | class User extends ORM\Entity
12 | {
13 |     protected static $excludedAttributes = ['password'];
14 |     protected static $includedAttributes = ['name'];
15 | 
16 |     public function getName()
17 |     {
18 |         return ucwords(preg_replace('/[^A-Za-z0-9\-]+/', ' ', $this->username));
19 |     }
20 | }
21 | 
22 | class Comment extends ORM\Entity
23 | {
24 |     protected static $relations = [
25 |         'parent' => [['parentType' => [
26 |             'article' => Article::class,
27 |             'image' => Image::class,
28 |         ]], ['parentId' => 'id']],
29 |     ];
30 | }
31 | 
32 | class Article extends ORM\Entity
33 | {
34 |     protected static $relations = [
35 |         'comments' => [Comment::class, 'parent'],
36 |     ];
37 | }
38 | 
39 | class Image extends ORM\Entity
40 | {
41 |     protected static $relations = [
42 |         'comments' => [Comment::class, 'parent'],
43 |     ];
44 | }
45 | 


--------------------------------------------------------------------------------
/examples/fetch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use ORM\EntityManager;
 4 | 
 5 | require_once __DIR__ . '/bootstrap.php';
 6 | require_once __DIR__ . '/entities.php';
 7 | 
 8 | /** @var EntityManager $em */
 9 | 
10 | $username = 'user_a'; // $_POST['username']
11 | $password = 'password_a'; // $_POST['password']
12 | 
13 | /*******************************
14 |  * Fetch entity with own query *
15 |  *******************************/
16 | $user = $em->fetch(User::class)
17 |     ->setQuery("SELECT * FROM user WHERE username = ? AND password = ?", [$username, md5($password)])
18 |     ->one();
19 | 
20 | var_dump($user);
21 | 
22 | 
23 | /*******************************
24 |  * Fetch with where conditions *
25 |  *******************************/
26 | $user = $em->fetch(User::class)
27 |     ->where('username', 'LIKE', $username)
28 |     ->andWhere('password', '=', md5($password))
29 |     ->one();
30 | 
31 | var_dump($user);
32 | 
33 | /*******************************************
34 |  * Fetch with parenthesis, group and order *
35 |  *******************************************/
36 | try {
37 |     $fetcher = $em->fetch(User::class)
38 |         ->where(User::class . '::username LIKE ?', 'USER_A')
39 |         ->andWhere('password', '=', md5('password_a'))
40 |         ->orParenthesis()
41 |         ->where(User::class . '::username = ' . $em->getConnection()->quote('user_b'))
42 |         ->andWhere('t0.password = \'' . md5('password_b') . '\'')
43 |         ->close()
44 |         ->groupBy('id')
45 |         ->orderBy(
46 |             'CASE WHEN username = ? THEN 1 WHEN username = ? THEN 2 ELSE 3 END',
47 |             'ASC',
48 |             ['user_a', 'user_b']
49 |         );
50 |     $users = $fetcher->all();
51 | 
52 |     var_dump($users);
53 | } catch (\PDOException $exception) {
54 |     file_put_contents('php://stderr', $exception->getMessage() . "\nSQL:" . $fetcher->getQuery());
55 | }
56 | 
57 | /*******************
58 |  * Cache an entity *
59 |  *******************/
60 | $cachedUser = serialize($user);
61 | var_dump($cachedUser);
62 | 
63 | /******************************
64 |  * Get previously cached User *
65 |  ******************************/
66 | // lets say we cached user3 with password from user1 - so modify the $cachedUser
67 | $cachedUser = str_replace([
68 |     's:1:"1"',
69 |     's:6:"user_a"'
70 | ], [
71 |     's:1:"3"',
72 |     's:6:"user_c"'
73 | ], $cachedUser);
74 | /** @var User $user */
75 | $user = $em->map(unserialize($cachedUser));
76 | $user = $em->fetch(User::class, 3);
77 | var_dump($user, $user->isDirty(), $user->isDirty('username'));
78 | 
79 | /*********************************
80 |  * Get a previously fetched user *
81 |  *********************************/
82 | // sqlite returns strings and currently we do not convert to int
83 | $user1 = $em->fetch(User::class, 1); // queries the database again
84 | $user2 = $em->map(new User(['id' => 1]));
85 | $user3 = $em->fetch(User::class, 1); // returns $user2
86 | $user4 = $em->map(new User(['id' => '1']));
87 | var_dump($user1->username, $user2->username, $user3 === $user2, $user1 === $user4);
88 | 
89 | /********************************
90 |  * Validate data for a new user *
91 |  ********************************/
92 | $data = [
93 |     'username' => 'This username is way to long for a username',
94 |     'password' => null // null is not allowed
95 | ];
96 | $result = User::validateArray($data);
97 | echo $result['username']->getMessage() . "\n" . $result['password']->getMessage() . "\n";
98 | 


--------------------------------------------------------------------------------
/examples/filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use ORM\EntityFetcher;
 4 | use ORM\EntityFetcher\FilterInterface;
 5 | use ORM\EntityManager;
 6 | 
 7 | require_once __DIR__ . '/bootstrap.php';
 8 | require_once __DIR__ . '/entities.php';
 9 | 
10 | /** @var EntityManager $em */
11 | 
12 | abstract class SearchColumn
13 | {
14 |     /** @var string */
15 |     protected $column;
16 | 
17 |     public function __construct($column)
18 |     {
19 |         $this->column = $column;
20 |     }
21 | 
22 |     public function getColumn()
23 |     {
24 |         return $this->column;
25 |     }
26 | 
27 |     public function prepareSearchTerm($searchTerm)
28 |     {
29 |         return '%' . $searchTerm . '%';
30 |     }
31 | 
32 |     public function getOperator()
33 |     {
34 |         return 'LIKE';
35 |     }
36 | }
37 | 
38 | class Text extends SearchColumn
39 | {
40 | }
41 | 
42 | class FilterBySearchTerm implements FilterInterface
43 | {
44 |     /** @var string[]|SearchColumn[] */
45 |     protected $searchColumns;
46 | 
47 |     /** @var string */
48 |     private $searchTerm;
49 | 
50 |     /**
51 |      * FilterBySearchTerm constructor.
52 |      * @param string[]|SearchColumn[] $searchColumns
53 |      * @param string $searchTerm
54 |      */
55 |     public function __construct(array $searchColumns, $searchTerm)
56 |     {
57 |         $this->searchColumns = $searchColumns;
58 |         $this->searchTerm = $searchTerm;
59 |     }
60 | 
61 |     public function apply(EntityFetcher $fetcher)
62 |     {
63 |         $searchTerms = preg_split('/\s+/', $this->searchTerm);
64 |         foreach ($searchTerms as $searchTerm) {
65 |             $parenthesis = $fetcher->parenthesis();
66 |             foreach ($this->searchColumns as $key => $column) {
67 |                 if (is_string($column)) {
68 |                     $column = $this->searchColumns[$key] = new Text($column);
69 |                 }
70 |                 $parenthesis->orWhere(
71 |                     $column->getColumn(),
72 |                     $column->getOperator(),
73 |                     $column->prepareSearchTerm($searchTerm)
74 |                 );
75 |             }
76 |             $parenthesis->close();
77 |         }
78 |     }
79 | }
80 | 
81 | // maybe a stpuid example and you probably want to get the query from the request
82 | $query = 'john doe';
83 | $fetcher = $em->fetch(User::class)->filter(new FilterBySearchTerm(['username', 'password'], $query));
84 | // creates a query similar to this:
85 | // SELECT * FROM table
86 | // WHERE (username LIKE '%john%' OR password LIKE '%john%') AND (username LIKE '%doe%' OR password LIKE '%doe%')
87 | 


--------------------------------------------------------------------------------
/examples/morphed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use ORM\EntityManager;
 4 | 
 5 | require_once __DIR__ . '/bootstrap.php';
 6 | require_once __DIR__ . '/entities.php';
 7 | 
 8 | /** @var EntityManager $em */
 9 | 
10 | // create an article and an image
11 | $article = new Article([
12 |     'author' => 'iRaS',
13 |     'title' => 'The advantages of tflori/orm',
14 |     'text' => 'it is pretty obvious why this orm is better than others',
15 | ]);
16 | $article->save();
17 | $image = new Image([
18 |     'author' => 'iRaS',
19 |     'url' => 'https://cdn.business2community.com/wp-content/uploads/2013/09/best-press-release-example.jpg',
20 |     'caption' => 'This is just an example',
21 | ]);
22 | $image->save();
23 | 
24 | // create some comments
25 | $texts = [
26 |     'Quod erat demonstrandum.',
27 |     'Lorem ipsum dolor sit amet, consectetuer adipiscing elit.',
28 |     'Aenean commodo ligula eget dolor. Aenean massa.',
29 |     'Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.',
30 |     'Er hörte leise Schritte hinter sich. Das bedeutete nichts Gutes.',
31 |     'Weit hinten, hinter den Wortbergen, fern der Länder Vokalien und Konsonantien leben die Blindtexte.',
32 |     'Abgeschieden wohnen sie in Buchstabhausen an der Küste des Semantik, eines großen Sprachozeans.',
33 |     '204 § ab dem Jahr 2034 Zahlen in 86 der Texte zur Pflicht werden.',
34 |     'Dies ist ein Typoblindtext.',
35 |     'Vogel Quax zwickt Johnys Pferd Bim.',
36 | ];
37 | $authors = [
38 |     'iRaS',
39 |     'cat',
40 |     's1mple',
41 | ];
42 | foreach ([$article, $image] as $parent) {
43 |     $count = mt_rand(2, 5);
44 |     $em->useBulkInserts(Comment::class);
45 |     for ($i = 0; $i < $count; $i++) {
46 |         $comment = new Comment();
47 |         $comment->text = $texts[array_rand($texts)];
48 |         $comment->author = $authors[array_rand($authors)];
49 |         $comment->setRelated('parent', $parent);
50 |         $comment->save();
51 |     }
52 |     $em->finishBulkInserts(Comment::class);
53 | }
54 | 
55 | printf('Article "%s" has %d comments:' . PHP_EOL, $article->title, count($article->comments));
56 | foreach ($article->comments as $comment) {
57 |     printf('  %s: %s' . PHP_EOL, $comment->author, $comment->text);
58 | }
59 | 
60 | printf('Image "%s" has %d comments:'.  PHP_EOL, $image->caption, count($image->comments));
61 | foreach ($image->comments as $comment) {
62 |     printf('  %s: %s'. PHP_EOL, $comment->author, $comment->text);
63 | }
64 | 


--------------------------------------------------------------------------------
/phpdoc.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" ?>
 2 | <phpdocumentor>
 3 |     <parser>
 4 |         <target>/tmp/phpdoc/orm</target>
 5 |     </parser>
 6 |     <transformer>
 7 |         <target>docs</target>
 8 |     </transformer>
 9 |     <transformations>
10 |         <template name="docs/_reference"/>
11 |     </transformations>
12 |     <files>
13 |         <directory>src</directory>
14 |     </files>
15 | </phpdocumentor>
16 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit bootstrap="vendor/autoload.php"
 3 |          backupGlobals="false"
 4 |          backupStaticAttributes="false"
 5 |          verbose="true"
 6 |          colors="true"
 7 |          convertErrorsToExceptions="true"
 8 |          convertNoticesToExceptions="true"
 9 |          convertWarningsToExceptions="true"
10 |          processIsolation="false"
11 |          stopOnFailure="false"
12 |          printerClass="PhpUnitPrinter\TextPrinter">
13 |     <testsuite name="tests">
14 |         <directory>./tests/</directory>
15 |     </testsuite>
16 |     <filter>
17 |         <whitelist processUncoveredFilesFromWhitelist="true">
18 |             <directory suffix=".php">./src/</directory>
19 |         </whitelist>
20 |     </filter>
21 | </phpunit>
22 | 


--------------------------------------------------------------------------------
/src/Dbal/Error.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal;
 4 | 
 5 | use ORM\EntityManager;
 6 | use ORM\Exception;
 7 | 
 8 | /**
 9 |  * Validation Error
10 |  *
11 |  * @package ORM\Dbal
12 |  * @author  Thomas Flori <thflori@gmail.com>
13 |  */
14 | class Error extends Exception
15 | {
16 |     const ERROR_CODE = 'UNKNOWN';
17 | 
18 |     /** @var string */
19 |     protected $message = 'ERROR(%code%) occurred';
20 | 
21 |     /** @var string */
22 |     protected $errorCode;
23 | 
24 |     /**
25 |      * Error constructor
26 |      *
27 |      * @param array $params
28 |      * @param null  $code
29 |      * @param null  $message
30 |      * @param Error $previous
31 |      */
32 |     public function __construct(array $params = [], $code = null, $message = null, Error $previous = null)
33 |     {
34 |         $this->message = $message ?: $this->message;
35 |         $this->code    = $code ?: static::ERROR_CODE;
36 | 
37 |         $params['code'] = $this->code;
38 | 
39 |         $namer = EntityManager::getInstance()->getNamer();
40 | 
41 |         parent::__construct($namer->substitute($this->message, $params), 0, $previous);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Dbal/Error/InvalidJson.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Error;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | 
 7 | /**
 8 |  * InvalidJson Validation Error
 9 |  *
10 |  * @package ORM\Dbal\Error
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class InvalidJson extends Error
14 | {
15 |     const ERROR_CODE = 'INVALID_JSON';
16 | 
17 |     /** @var string */
18 |     protected $message = '\'%value%\' is not a valid JSON string';
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Dbal/Error/NoBoolean.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Error;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | 
 7 | /**
 8 |  * NoBoolean Validation Error
 9 |  *
10 |  * @package ORM\Dbal\Error
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class NoBoolean extends Error
14 | {
15 |     const ERROR_CODE = 'NO_BOOLEAN';
16 | 
17 |     /** @var string */
18 |     protected $message = '%value% can not be converted to boolean';
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Dbal/Error/NoDateTime.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Error;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | 
 7 | /**
 8 |  * NoDateTime Validation Error
 9 |  *
10 |  * @package ORM\Dbal\Error
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class NoDateTime extends Error
14 | {
15 |     const ERROR_CODE = 'NO_DATETIME';
16 | 
17 |     /** @var string */
18 |     protected $message = '%value% is not a valid date or date time expression';
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Dbal/Error/NoNumber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Error;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | 
 7 | /**
 8 |  * NoNumber Validation Error
 9 |  *
10 |  * @package ORM\Dbal\Error
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class NoNumber extends Error
14 | {
15 |     const ERROR_CODE = 'NO_NUMBER';
16 | 
17 |     /** @var string */
18 |     protected $message = '%value% is not numeric';
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Dbal/Error/NoString.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Error;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | 
 7 | /**
 8 |  * NoString Validation Error
 9 |  *
10 |  * @package ORM\Dbal\Error
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class NoString extends Error
14 | {
15 |     const ERROR_CODE = 'NO_STRING';
16 | 
17 |     /** @var string */
18 |     protected $message = 'Only string values are allowed for %type%';
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Dbal/Error/NoTime.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Error;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | 
 7 | /**
 8 |  * NoTime Validation Error
 9 |  *
10 |  * @package ORM\Dbal\Error
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class NoTime extends Error
14 | {
15 |     const ERROR_CODE = 'NO_TIME';
16 | 
17 |     /** @var string */
18 |     protected $message = '%value% is not a valid time expression';
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Dbal/Error/NotAllowed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Error;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | 
 7 | /**
 8 |  * NotAllowed Validation Error
 9 |  *
10 |  * @package ORM\Dbal\Error
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class NotAllowed extends Error
14 | {
15 |     const ERROR_CODE = 'NOT_ALLOWED';
16 | 
17 |     /** @var string */
18 |     protected $message = '\'%value%\' is not allowed by this %type%';
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Dbal/Error/NotNullable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Error;
 4 | 
 5 | use ORM\Dbal\Column;
 6 | use ORM\Dbal\Error;
 7 | 
 8 | /**
 9 |  * NotNullable Validation Error
10 |  *
11 |  * @package ORM\Dbal\Error
12 |  * @author  Thomas Flori <thflori@gmail.com>
13 |  */
14 | class NotNullable extends Error
15 | {
16 |     const ERROR_CODE = 'NOT_NULLABLE';
17 | 
18 |     protected $message = '%column% does not allow null values';
19 | 
20 |     public function __construct(Column $column)
21 |     {
22 |         parent::__construct([ 'column' => $column->name ]);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Dbal/Error/NotValid.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Error;
 4 | 
 5 | use ORM\Dbal\Column;
 6 | use ORM\Dbal\Error;
 7 | 
 8 | /**
 9 |  * NotValid Validation Error
10 |  *
11 |  * @package ORM\Dbal\Error
12 |  * @author  Thomas Flori <thflori@gmail.com>
13 |  */
14 | class NotValid extends Error
15 | {
16 |     const ERROR_CODE = 'NOT_VALID';
17 | 
18 |     /** @var string */
19 |     protected $message = 'Value not valid for %column% (Caused by: %previous%)';
20 | 
21 |     /**
22 |      * NotValid constructor
23 |      *
24 |      * @param Column $column   The column that got a not valid error
25 |      * @param Error  $previous The error from validate
26 |      */
27 |     public function __construct(Column $column, Error $previous)
28 |     {
29 |         parent::__construct([
30 |             'column' => $column->name,
31 |             'previous' => $previous->getMessage()
32 |         ], null, null, $previous);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Dbal/Error/TooLong.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Error;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | 
 7 | /**
 8 |  * TooLong Validation Error
 9 |  *
10 |  * @package ORM\Dbal\Error
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class TooLong extends Error
14 | {
15 |     const ERROR_CODE = 'TOO_LONG';
16 | 
17 |     /** @var string */
18 |     protected $message = '\'%value%\' is too long (max: %max%)';
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Dbal/Escaping.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ORM\Dbal;
  4 | 
  5 | use DateTime;
  6 | use DateTimeZone;
  7 | use ORM\Exception\NotScalar;
  8 | 
  9 | trait Escaping
 10 | {
 11 |     /** @var string */
 12 |     protected $quotingCharacter = '"';
 13 |     /** @var string */
 14 |     protected $identifierDivider = '.';
 15 |     /** @var string */
 16 |     protected $booleanTrue = '1';
 17 |     /** @var string */
 18 |     protected $booleanFalse = '0';
 19 | 
 20 |     /**
 21 |      * Returns $identifier quoted for use in a sql statement
 22 |      *
 23 |      * @param string $identifier Identifier to quote
 24 |      * @return string
 25 |      */
 26 |     public function escapeIdentifier($identifier)
 27 |     {
 28 |         if ($identifier instanceof Expression) {
 29 |             return (string)$identifier;
 30 |         }
 31 | 
 32 |         $quote = $this->quotingCharacter;
 33 |         $divider = $this->identifierDivider;
 34 |         return $quote . str_replace($divider, $quote . $divider . $quote, $identifier) . $quote;
 35 |     }
 36 | 
 37 |     /**
 38 |      * Returns $value formatted to use in a sql statement.
 39 |      *
 40 |      * @param  mixed $value The variable that should be returned in SQL syntax
 41 |      * @return string
 42 |      * @throws NotScalar
 43 |      */
 44 |     public function escapeValue($value)
 45 |     {
 46 |         if ($value instanceof DateTime) {
 47 |             return $this->escapeDateTime($value);
 48 |         }
 49 | 
 50 |         if ($value instanceof Expression) {
 51 |             return (string)$value;
 52 |         }
 53 | 
 54 |         $type = is_object($value) ? get_class($value) : gettype($value);
 55 |         $method = [ $this, 'escape' . ucfirst($type) ];
 56 | 
 57 |         if (is_callable($method)) {
 58 |             return call_user_func($method, $value);
 59 |         } else {
 60 |             throw new NotScalar('$value has to be scalar data type. ' . gettype($value) . ' given');
 61 |         }
 62 |     }
 63 | 
 64 |     /**
 65 |      * Escape a string for query
 66 |      *
 67 |      * @param string $value
 68 |      * @return string
 69 |      */
 70 |     protected function escapeString($value)
 71 |     {
 72 |         return $this->entityManager->getConnection()->quote($value);
 73 |     }
 74 | 
 75 |     /**
 76 |      * Escape an integer for query
 77 |      *
 78 |      * @param int $value
 79 |      * @return string
 80 |      */
 81 |     protected function escapeInteger($value)
 82 |     {
 83 |         return (string) $value;
 84 |     }
 85 | 
 86 |     /**
 87 |      * Escape a double for Query
 88 |      *
 89 |      * @param double $value
 90 |      * @return string
 91 |      */
 92 |     protected function escapeDouble($value)
 93 |     {
 94 |         return (string) $value;
 95 |     }
 96 | 
 97 |     /**
 98 |      * Escape NULL for query
 99 |      *
100 |      * @return string
101 |      */
102 |     protected function escapeNULL()
103 |     {
104 |         return 'NULL';
105 |     }
106 | 
107 |     /**
108 |      * Escape a boolean for query
109 |      *
110 |      * @param bool $value
111 |      * @return string
112 |      */
113 |     protected function escapeBoolean($value)
114 |     {
115 |         return ($value) ? $this->booleanTrue : $this->booleanFalse;
116 |     }
117 | 
118 |     /**
119 |      * Escape a date time object for query
120 |      *
121 |      * @param DateTime $value
122 |      * @return mixed
123 |      */
124 |     protected function escapeDateTime(DateTime $value)
125 |     {
126 |         $value->setTimezone(new DateTimeZone('UTC'));
127 |         return $this->escapeString($value->format('Y-m-d\TH:i:s.u\Z'));
128 |     }
129 | }
130 | 


--------------------------------------------------------------------------------
/src/Dbal/Expression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal;
 4 | 
 5 | class Expression
 6 | {
 7 |     protected $expression = '';
 8 | 
 9 |     /**
10 |      * Expression constructor.
11 |      *
12 |      * @param string $expression
13 |      */
14 |     public function __construct($expression)
15 |     {
16 |         $this->expression = $expression;
17 |     }
18 | 
19 |     public function __toString()
20 |     {
21 |         return $this->expression;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Dbal/Other.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal;
 4 | 
 5 | use ORM\Exception\UnsupportedDriver;
 6 | 
 7 | /**
 8 |  * Database abstraction for other databases
 9 |  *
10 |  * @package ORM\Dbal
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class Other extends Dbal
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Dbal/QueryLanguage/CompositeInExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\QueryLanguage;
 4 | 
 5 | trait CompositeInExpression
 6 | {
 7 |     /**
 8 |      * Build a where in expression for composite values
 9 |      *
10 |      * @param array $cols
11 |      * @param array $values
12 |      * @param bool $inverse Whether it should be a IN or NOT IN operator
13 |      * @return string
14 |      */
15 |     public function buildCompositeInExpression(array $cols, array $values, $inverse = false)
16 |     {
17 |         return '(' . implode(',', $cols) . ') ' . ($inverse ? 'NOT IN' : 'IN')  .
18 |             ' (' . implode(',', $this->buildTuples($values)) . ')';
19 |     }
20 | 
21 |     protected function buildTuples(array $values)
22 |     {
23 |         return array_map(function ($value) {
24 |             return '(' . implode(',', array_map([$this, 'escapeValue'], $value)) . ')';
25 |         }, $values);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Dbal/QueryLanguage/CompositeInValuesExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\QueryLanguage;
 4 | 
 5 | trait CompositeInValuesExpression
 6 | {
 7 |     use CompositeInExpression;
 8 | 
 9 |     /**
10 |      * Build a where in statement for composite keys
11 |      *
12 |      * @param array $cols Columns from which to build the composite key
13 |      * @param array[] $values Array of composite keys (array)
14 |      * @param bool $inverse Whether it should be a IN or NOT IN operator
15 |      * @return string
16 |      * @internal
17 |      */
18 |     public function buildCompositeInExpression(array $cols, array $values, $inverse = false)
19 |     {
20 |         return '(' . implode(',', $cols) . ') ' . ($inverse ? 'NOT IN' : 'IN')  .
21 |             ' (VALUES ' . implode(',', $this->buildTuples($values)) . ')';
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Dbal/QueryLanguage/DeleteStatement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\QueryLanguage;
 4 | 
 5 | trait DeleteStatement
 6 | {
 7 |     use WhereClause;
 8 | 
 9 |     protected function buildDeleteStatement($table, array $where)
10 |     {
11 |         return 'DELETE FROM ' . $this->escapeIdentifier($table) .
12 |             $this->buildWhereClause($where);
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Dbal/QueryLanguage/InsertStatement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\QueryLanguage;
 4 | 
 5 | trait InsertStatement
 6 | {
 7 |     /**
 8 |      * Build an insert statement for $rows
 9 |      *
10 |      * @param string $table
11 |      * @param array $rows
12 |      * @return string
13 |      */
14 |     protected function buildInsert($table, array $rows)
15 |     {
16 |         // get all columns from rows
17 |         $columns = [];
18 |         foreach ($rows as $row) {
19 |             $columns = array_unique(array_merge($columns, array_keys($row)));
20 |         }
21 | 
22 |         $statement = 'INSERT INTO ' . $this->escapeIdentifier($table) . ' ' .
23 |             '(' . implode(',', array_map([$this, 'escapeIdentifier'], $columns)) . ') VALUES ';
24 | 
25 |         $statement .= implode(',', array_map(function ($values) use ($columns) {
26 |             return '(' . implode(',', array_map(function ($column) use ($values) {
27 |                 return isset($values[$column]) ? $this->escapeValue($values[$column]) : $this->escapeNULL();
28 |             }, $columns)) . ')';
29 |         }, $rows));
30 | 
31 |         return $statement;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Dbal/QueryLanguage/UpdateFromStatement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\QueryLanguage;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | trait UpdateFromStatement
 8 | {
 9 |     use UpdateStatement;
10 | 
11 |     protected function buildUpdateFromStatement($table, array $where, array $updates, array $joins)
12 |     {
13 |         $fromClause = '';
14 |         if (!empty($joins)) {
15 |             list($fromTable, $condition) = $this->convertJoin(array_shift($joins));
16 |             $fromClause = ' FROM ' . $fromTable .
17 |                 (!empty($joins) ? ' ' . implode(' ', $joins) : '');
18 |             array_unshift($where, $condition);
19 |         }
20 | 
21 |         return 'UPDATE ' . $this->escapeIdentifier($table) .
22 |             $this->buildSetClause($updates) .
23 |             $fromClause .
24 |             $this->buildWhereClause($where);
25 |     }
26 | 
27 |     protected function convertJoin($join)
28 |     {
29 |         if (!preg_match('/^JOIN\s+([^\s]+)\s+ON\s+(.*)/ism', $join, $match)) {
30 |             throw new Exception\InvalidArgument(
31 |                 'Only inner joins with on clause are allowed in update from statements'
32 |             );
33 |         }
34 |         $table = $match[1];
35 |         $condition = $match[2];
36 | 
37 |         return [$table, $condition];
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Dbal/QueryLanguage/UpdateJoinStatement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\QueryLanguage;
 4 | 
 5 | trait UpdateJoinStatement
 6 | {
 7 |     use UpdateStatement;
 8 | 
 9 |     protected function buildUpdateJoinStatement($table, array $where, array $updates, array $joins)
10 |     {
11 |         return 'UPDATE ' . $this->escapeIdentifier($table) .
12 |             (!empty($joins) ? ' ' . implode(' ', $joins) : '') .
13 |             $this->buildSetClause($updates) .
14 |             $this->buildWhereClause($where);
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Dbal/QueryLanguage/UpdateStatement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\QueryLanguage;
 4 | 
 5 | trait UpdateStatement
 6 | {
 7 |     use WhereClause;
 8 | 
 9 |     protected function buildUpdateStatement($table, array $where, array $updates)
10 |     {
11 |         return 'UPDATE ' . $this->escapeIdentifier($table) .
12 |             $this->buildSetClause($updates) .
13 |             $this->buildWhereClause($where);
14 |     }
15 | 
16 |     protected function buildSetClause(array $updates)
17 |     {
18 |         return ' SET ' . implode(',', array_map(function ($column, $value) {
19 |             return $this->escapeIdentifier($column) . ' = ' . $this->escapeValue($value);
20 |         }, array_keys($updates), $updates));
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Dbal/QueryLanguage/WhereClause.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\QueryLanguage;
 4 | 
 5 | trait WhereClause
 6 | {
 7 |     protected function buildWhereClause(array $whereConditions)
 8 |     {
 9 |         if (empty($whereConditions)) {
10 |             return '';
11 |         }
12 | 
13 |         $normalized = [];
14 |         foreach ($whereConditions as $column => $condition) {
15 |             if (!is_numeric($column)) {
16 |                 $condition = $this->escapeIdentifier($column) . ' = ' . $this->escapeValue($condition);
17 |             }
18 | 
19 |             if (!empty($normalized) && !preg_match('/^\s*(AND|OR)/i', $condition)) {
20 |                 $condition = 'AND ' . $condition;
21 |             }
22 | 
23 |             $normalized[] = trim($condition);
24 |         }
25 | 
26 |         return ' WHERE ' . implode(' ', $normalized);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Dbal/Table.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal;
 4 | 
 5 | use ArrayObject;
 6 | use ORM\Exception\UnknownColumn;
 7 | 
 8 | /**
 9 |  * Table is basically an array of Columns
10 |  *
11 |  * @package ORM\Dbal
12 |  * @author  Thomas Flori <thflori@gmail.com>
13 |  * @method Column offsetGet($offset)
14 |  */
15 | class Table extends ArrayObject
16 | {
17 |     /** The columns from this table
18 |      * @var Column[] */
19 |     protected $columns;
20 | 
21 |     /**
22 |      * Table constructor.
23 |      *
24 |      * @param Column[] $columns
25 |      */
26 |     public function __construct(array $columns)
27 |     {
28 |         foreach ($columns as $column) {
29 |             $this->columns[$column->name] = $column;
30 |         }
31 | 
32 |         parent::__construct($columns);
33 |     }
34 | 
35 |     /**
36 |      * Validate $value for column $col.
37 |      *
38 |      * Returns an array with at least
39 |      *
40 |      * @param string $col
41 |      * @param mixed $value
42 |      * @return bool|Error
43 |      * @throws UnknownColumn
44 |      */
45 |     public function validate($col, $value)
46 |     {
47 |         if (!($column = $this->getColumn($col))) {
48 |             throw new UnknownColumn('Unknown column ' . $col);
49 |         }
50 | 
51 |         return $column->validate($value);
52 |     }
53 | 
54 |     /**
55 |      * Get the Column object for $col
56 |      *
57 |      * @param string $col
58 |      * @return Column
59 |      */
60 |     public function getColumn($col)
61 |     {
62 |         return isset($this->columns[$col]) ? $this->columns[$col] : null;
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/Dbal/Type.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal;
 4 | 
 5 | /**
 6 |  * Base class for data types
 7 |  *
 8 |  * @package ORM\Dbal
 9 |  * @author  Thomas Flori <thflori@gmail.com>
10 |  */
11 | abstract class Type implements TypeInterface
12 | {
13 |     /**
14 |      * {@inheritdoc}
15 |      * @codeCoverageIgnore void method for types covered by mapping
16 |      */
17 |     public static function fits(array $columnDefinition)
18 |     {
19 |         return false;
20 |     }
21 | 
22 |     /**
23 |      * Returns a new Type object
24 |      *
25 |      * This method is only for types covered by mapping. Use fromDefinition instead for custom types.
26 |      *
27 |      * @param Dbal  $dbal
28 |      * @param array $columnDefinition
29 |      * @return static
30 |      */
31 |     public static function factory(Dbal $dbal, array $columnDefinition)
32 |     {
33 |         return new static();
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Dbal/Type/Boolean.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Dbal;
 6 | use ORM\Dbal\Error;
 7 | use ORM\Dbal\Error\NoBoolean;
 8 | use ORM\Dbal\Type;
 9 | 
10 | /**
11 |  * Boolean data type
12 |  *
13 |  * @package ORM\Dbal\Type
14 |  * @author  Thomas Flori <thflori@gmail.com>
15 |  */
16 | class Boolean extends Type
17 | {
18 |     /** @var Dbal */
19 |     protected $dbal;
20 | 
21 |     /**
22 |      * Boolean constructor
23 |      *
24 |      * @param Dbal $dbal
25 |      */
26 |     public function __construct(Dbal $dbal)
27 |     {
28 |         $this->dbal = $dbal;
29 |     }
30 | 
31 |     public static function factory(Dbal $dbal, array $columnDefinition)
32 |     {
33 |         return new static($dbal);
34 |     }
35 | 
36 |     /**
37 |      * Check if $value is valid for this type
38 |      *
39 |      * @param mixed $value
40 |      * @return boolean|Error
41 |      */
42 |     public function validate($value)
43 |     {
44 |         if (!is_bool($value)) {
45 |             // convert int to string
46 |             if (is_int($value)) {
47 |                 $value = (string) $value;
48 |             }
49 | 
50 |             if (!is_string($value) ||
51 |                 ($value !== $this->getBoolean(true) && $value !== $this->getBoolean(false))
52 |             ) {
53 |                 // value is not boolean, not int and (not string OR string value for boolean)
54 |                 return new NoBoolean([ 'value' => (string) $value ]);
55 |             }
56 |         }
57 | 
58 |         return true;
59 |     }
60 | 
61 |     /**
62 |      * Get the string representation for boolean
63 |      *
64 |      * @param bool $bool
65 |      * @return string
66 |      */
67 |     protected function getBoolean($bool)
68 |     {
69 |         $quoted = $this->dbal->escapeValue($bool);
70 |         return $quoted[0] === '\'' ? substr($quoted, 1, -1) : $quoted;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Dbal/Type/DateTime.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Dbal;
 6 | use ORM\Dbal\Error;
 7 | use ORM\Dbal\Error\NoDateTime;
 8 | use ORM\Dbal\Type;
 9 | 
10 | /**
11 |  * Date and datetime data type
12 |  *
13 |  * @package ORM\Dbal\Type
14 |  * @author  Thomas Flori <thflori@gmail.com>
15 |  */
16 | class DateTime extends Type
17 | {
18 |     const DATE_REGEX = '(\+|-)?\d{4,}-\d{2}-\d{2}';
19 |     const TIME_REGEX = '\d{2}:\d{2}:\d{2}(\.\d{1,6})?';
20 |     const ZONE_REGEX = '((\+|-)\d{1,2}(:?\d{2})?|Z)?';
21 | 
22 |     /** @var int */
23 |     protected $precision;
24 | 
25 |     /** @var string */
26 |     protected $regex;
27 | 
28 |     /**
29 |      * DateTime constructor
30 |      *
31 |      * @param int  $precision
32 |      * @param bool $dateOnly
33 |      */
34 |     public function __construct($precision = null, $dateOnly = false)
35 |     {
36 |         $this->precision = (int) $precision;
37 |         $this->regex     = $dateOnly ?
38 |             '/^' . self::DATE_REGEX . '([ T]' . self::TIME_REGEX . self::ZONE_REGEX . ')?$/' :
39 |             '/^' . self::DATE_REGEX . '[ T]' . self::TIME_REGEX . self::ZONE_REGEX . '$/';
40 |     }
41 | 
42 |     public static function factory(Dbal $dbal, array $columnDefinition)
43 |     {
44 |         return new static(
45 |             $columnDefinition['datetime_precision'],
46 |             strpos($columnDefinition['data_type'], 'time') === false
47 |         );
48 |     }
49 | 
50 |     /**
51 |      * Check if $value is valid for this type
52 |      *
53 |      * @param mixed $value
54 |      * @return boolean|Error
55 |      */
56 |     public function validate($value)
57 |     {
58 |         if (!$value instanceof \DateTime && (!is_string($value) || !preg_match($this->regex, $value))) {
59 |             return new NoDateTime([ 'value' => (string) $value ]);
60 |         }
61 | 
62 |         return true;
63 |     }
64 | 
65 |     /**
66 |      * @return int
67 |      */
68 |     public function getPrecision()
69 |     {
70 |         return $this->precision;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/Dbal/Type/Enum.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Dbal;
 6 | use ORM\Dbal\Error;
 7 | use ORM\Dbal\Error\NoString;
 8 | use ORM\Dbal\Error\NotAllowed;
 9 | use ORM\Dbal\Type;
10 | 
11 | /**
12 |  * Enum data type
13 |  *
14 |  * @package ORM\Dbal\Type
15 |  * @author  Thomas Flori <thflori@gmail.com>
16 |  */
17 | class Enum extends Type
18 | {
19 |     /** @var string[] */
20 |     protected $allowedValues = null;
21 | 
22 |     /**
23 |      * Set constructor
24 |      *
25 |      * @param string[] $allowedValues
26 |      */
27 |     public function __construct(array $allowedValues)
28 |     {
29 |         $this->allowedValues = $allowedValues;
30 |     }
31 | 
32 |     public static function factory(Dbal $dbal, array $columnDefinition)
33 |     {
34 |         $allowedValues = [];
35 |         if (!empty($columnDefinition['enumeration_values'])) {
36 |             $allowedValues = explode('\',\'', substr($columnDefinition['enumeration_values'], 1, -1));
37 |         }
38 | 
39 |         return new static($allowedValues);
40 |     }
41 | 
42 |     /**
43 |      * Check if $value is valid for this type
44 |      *
45 |      * @param mixed $value
46 |      * @return boolean|Error
47 |      */
48 |     public function validate($value)
49 |     {
50 |         if (!is_string($value)) {
51 |             return new NoString([ 'type' => 'enum' ]);
52 |         } elseif (!in_array($value, $this->allowedValues)) {
53 |             return new NotAllowed([ 'value' => $value, 'type' => 'enum' ]);
54 |         }
55 | 
56 |         return true;
57 |     }
58 | 
59 |     /**
60 |      * @return string[]
61 |      */
62 |     public function getAllowedValues()
63 |     {
64 |         return $this->allowedValues;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Dbal/Type/Json.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | use ORM\Dbal\Error\InvalidJson;
 7 | use ORM\Dbal\Error\NoString;
 8 | use ORM\Dbal\Type;
 9 | 
10 | /**
11 |  * Json data type
12 |  *
13 |  * @package ORM\Dbal\Type
14 |  * @author  Thomas Flori <thflori@gmail.com>
15 |  */
16 | class Json extends Type
17 | {
18 |     /**
19 |      * Check if $value is valid for this type
20 |      *
21 |      * @param mixed $value
22 |      * @return boolean|Error
23 |      */
24 |     public function validate($value)
25 |     {
26 |         if (!is_string($value)) {
27 |             return new NoString([ 'type' => 'json' ]);
28 |         } elseif ($value !== 'null' && json_decode($value) === null) {
29 |             return new InvalidJson([ 'value' => (string) $value ]);
30 |         }
31 | 
32 |         return true;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Dbal/Type/Number.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | use ORM\Dbal\Error\NoNumber;
 7 | use ORM\Dbal\Type;
 8 | 
 9 | /**
10 |  * Float, double and decimal data type
11 |  *
12 |  * @package ORM\Dbal\Type
13 |  * @author  Thomas Flori <thflori@gmail.com>
14 |  */
15 | class Number extends Type
16 | {
17 |     /**
18 |      * Check if $value is valid for this type
19 |      *
20 |      * @param mixed $value
21 |      * @return boolean|Error
22 |      */
23 |     public function validate($value)
24 |     {
25 |         if (!is_int($value) && !is_double($value) && (!is_string($value) || !is_numeric($value))) {
26 |             return new NoNumber([ 'value' => (string) $value ]);
27 |         }
28 | 
29 |         return true;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Dbal/Type/Set.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | use ORM\Dbal\Error\NoString;
 7 | use ORM\Dbal\Error\NotAllowed;
 8 | 
 9 | /**
10 |  * Set data type
11 |  *
12 |  * @package ORM\Dbal\Type
13 |  * @author  Thomas Flori <thflori@gmail.com>
14 |  */
15 | class Set extends Enum
16 | {
17 |     protected $type = 'set';
18 | 
19 |     /**
20 |      * Check if $value is valid for this type
21 |      *
22 |      * @param mixed $value
23 |      * @return boolean|Error
24 |      */
25 |     public function validate($value)
26 |     {
27 |         if (!is_string($value)) {
28 |             return new NoString([ 'type' => 'set' ]);
29 |         } else {
30 |             $values = explode(',', $value);
31 |             foreach ($values as $value) {
32 |                 if (!in_array($value, $this->allowedValues)) {
33 |                     return new NotAllowed([ 'value' => $value, 'type' => 'set' ]);
34 |                 }
35 |             }
36 |         }
37 | 
38 |         return true;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Dbal/Type/Text.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Type;
 4 | 
 5 | /**
 6 |  * Text data type
 7 |  *
 8 |  * This is also the base type for any other data type
 9 |  *
10 |  * @package ORM\Dbal\Type
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class Text extends VarChar
14 | {
15 |     protected $type = 'text';
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Dbal/Type/Time.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | use ORM\Dbal\Error\NoTime;
 7 | 
 8 | /**
 9 |  * Time data type
10 |  *
11 |  * @package ORM\Dbal\Type
12 |  * @author  Thomas Flori <thflori@gmail.com>
13 |  */
14 | class Time extends DateTime
15 | {
16 |     public function __construct($precision = null)
17 |     {
18 |         parent::__construct($precision);
19 |         $this->regex = '/^' . self::TIME_REGEX . self::ZONE_REGEX . '$/';
20 |     }
21 | 
22 |     /**
23 |      * Check if $value is valid for this type
24 |      *
25 |      * @param mixed $value
26 |      * @return boolean|Error
27 |      */
28 |     public function validate($value)
29 |     {
30 |         if (!is_string($value) || !preg_match($this->regex, $value)) {
31 |             if ($value instanceof \DateTime) {
32 |                 return new Error([], 'DATETIME', 'DateTime is not allowed for time');
33 |             }
34 | 
35 |             return new NoTime([ 'value' => (string) $value ]);
36 |         }
37 | 
38 |         return true;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Dbal/Type/VarChar.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Dbal;
 6 | use ORM\Dbal\Error;
 7 | use ORM\Dbal\Error\NoString;
 8 | use ORM\Dbal\Error\TooLong;
 9 | use ORM\Dbal\Type;
10 | 
11 | /**
12 |  * String data type
13 |  *
14 |  * With and without max / fixed length
15 |  *
16 |  * @package ORM\Dbal\Type
17 |  * @author  Thomas Flori <thflori@gmail.com>
18 |  */
19 | class VarChar extends Type
20 | {
21 |     /** @var int */
22 |     protected $maxLength;
23 | 
24 |     /** @var string */
25 |     protected $type = 'varchar';
26 | 
27 |     /**
28 |      * VarChar constructor
29 |      *
30 |      * @param int $maxLength
31 |      */
32 |     public function __construct($maxLength = null)
33 |     {
34 |         $this->maxLength = (int) $maxLength;
35 |     }
36 | 
37 |     public static function factory(Dbal $dbal, array $columnDefinition)
38 |     {
39 |         return new static($columnDefinition['character_maximum_length']);
40 |     }
41 | 
42 |     /**
43 |      * Check if $value is valid for this type
44 |      *
45 |      * @param mixed $value
46 |      * @return boolean|Error
47 |      */
48 |     public function validate($value)
49 |     {
50 |         if (!is_string($value)) {
51 |             return new NoString([ 'type' => $this->type ]);
52 |         } elseif ($this->maxLength !== 0 && mb_strlen($value) > $this->maxLength) {
53 |             return new TooLong([ 'value' => $value, 'max' => $this->maxLength ]);
54 |         }
55 | 
56 |         return true;
57 |     }
58 | 
59 |     /**
60 |      * @return int
61 |      */
62 |     public function getMaxLength()
63 |     {
64 |         return $this->maxLength;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Dbal/TypeInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Dbal;
 4 | 
 5 | /**
 6 |  * Interface TypeInterface
 7 |  *
 8 |  * @package ORM\Dbal
 9 |  * @author  Thomas Flori <thflori@gmail.com>
10 |  */
11 | interface TypeInterface
12 | {
13 |     /**
14 |      * Create Type class for given $dbal and $columnDefinition
15 |      *
16 |      * @param Dbal  $dbal
17 |      * @param array $columnDefinition
18 |      * @return Type
19 |      */
20 |     public static function factory(Dbal $dbal, array $columnDefinition);
21 | 
22 |     /**
23 |      * Check if this type fits to $columnDefinition
24 |      *
25 |      * @param array $columnDefinition
26 |      * @return boolean
27 |      */
28 |     public static function fits(array $columnDefinition);
29 | 
30 |     /**
31 |      * Check if $value is valid for this type
32 |      *
33 |      * @param mixed $value
34 |      * @return boolean|Error
35 |      */
36 |     public function validate($value);
37 | }
38 | 


--------------------------------------------------------------------------------
/src/EM.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ORM;
4 | 
5 | // @codeCoverageIgnoreStart
6 | class_alias(EntityManager::class, EM::class);
7 | 


--------------------------------------------------------------------------------
/src/Entity/Booting.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Entity;
 4 | 
 5 | use ORM\EntityManager as EM;
 6 | use ORM\Helper;
 7 | 
 8 | trait Booting
 9 | {
10 |     /** @var bool[] */
11 |     protected static $booted = [];
12 | 
13 |     /**
14 |      * Boot the class if it not already booted
15 |      */
16 |     public static function bootIfNotBooted()
17 |     {
18 |         if (isset(static::$booted[static::class])) {
19 |             return;
20 |         }
21 | 
22 |         static::$booted[static::class] = true;
23 |         static::boot();
24 |     }
25 | 
26 |     /**
27 |      * Boot the class
28 |      */
29 |     protected static function boot()
30 |     {
31 |         static::bootTraits();
32 |     }
33 | 
34 |     /**
35 |      * Boot the traits of the class
36 |      */
37 |     protected static function bootTraits()
38 |     {
39 |         foreach (Helper::traitUsesRecursive(static::class) as $trait) {
40 |             $method = EM::getInstance(static::class)->getNamer()
41 |                 ->getMethodName('boot' . ucfirst(Helper::shortName($trait)));
42 |             if (method_exists(static::class, $method)) {
43 |                 forward_static_call([static::class, $method]);
44 |             }
45 |         }
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Entity/EventHandlers.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Entity;
 4 | 
 5 | trait EventHandlers
 6 | {
 7 |     /**
 8 |      * Empty event handler
 9 |      *
10 |      * Get called when the entity get initialized.
11 |      *
12 |      * @param bool $new Whether or not the entity is new or from database
13 |      * @codeCoverageIgnore dummy event handler
14 |      */
15 |     public function onInit($new)
16 |     {
17 |     }
18 | 
19 |     /**
20 |      * Empty event handler
21 |      *
22 |      * Get called when something is changed with magic setter.
23 |      *
24 |      * @param string $attribute The variable that got changed.merge(node.inheritedProperties)
25 |      * @param mixed  $oldValue  The old value of the variable
26 |      * @param mixed  $value     The new value of the variable
27 |      * @codeCoverageIgnore dummy event handler
28 |      */
29 |     public function onChange($attribute, $oldValue, $value)
30 |     {
31 |     }
32 | 
33 |     /**
34 |      * Empty event handler
35 |      *
36 |      * Get called before the entity get inserted in database.
37 |      *
38 |      * @codeCoverageIgnore dummy event handler
39 |      */
40 |     public function prePersist()
41 |     {
42 |     }
43 | 
44 |     /**
45 |      * Empty event handler
46 |      *
47 |      * Get called before the entity get updated in database.
48 |      *
49 |      * @codeCoverageIgnore dummy event handler
50 |      */
51 |     public function preUpdate()
52 |     {
53 |     }
54 | 
55 |     /**
56 |      * Empty event handler
57 |      *
58 |      * Get called after the entity got inserted in database.
59 |      *
60 |      * @codeCoverageIgnore dummy event handler
61 |      */
62 |     public function postPersist()
63 |     {
64 |     }
65 | 
66 |     /**
67 |      * Empty event handler
68 |      *
69 |      * Get called after the entity got updated in database.
70 |      *
71 |      * @codeCoverageIgnore dummy event handler
72 |      */
73 |     public function postUpdate()
74 |     {
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/Entity/GeneratesPrimaryKeys.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Entity;
 4 | 
 5 | /**
 6 |  * Interface GeneratesPrimaryKeys
 7 |  *
 8 |  * Describes a class that generates primary keys in the protected method generatePrimaryKey()
 9 |  *
10 |  * @package ORM\Entity
11 |  */
12 | interface GeneratesPrimaryKeys
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Entity/Validation.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ORM\Entity;
  4 | 
  5 | use ORM\Dbal\Column;
  6 | use ORM\Dbal\Error;
  7 | use ORM\Dbal\Table;
  8 | use ORM\EntityManager as EM;
  9 | 
 10 | trait Validation
 11 | {
 12 | 
 13 |     /** The current data of a row.
 14 |      * @var mixed[] */
 15 |     protected $data = [];
 16 | 
 17 |     /** Whether or not the validator for this class is enabled.
 18 |      * @var bool */
 19 |     protected static $enableValidator = false;
 20 | 
 21 |     /** Whether or not the validator for a class got enabled during runtime.
 22 |      * @var bool[] */
 23 |     protected static $enabledValidators = [];
 24 | 
 25 |     /**
 26 |      * Check if the validator is enabled
 27 |      *
 28 |      * @return bool
 29 |      */
 30 |     public static function isValidatorEnabled()
 31 |     {
 32 |         return isset(self::$enabledValidators[static::class]) ?
 33 |             self::$enabledValidators[static::class] : static::$enableValidator;
 34 |     }
 35 | 
 36 |     /**
 37 |      * Enable validator
 38 |      *
 39 |      * @param bool $enable
 40 |      */
 41 |     public static function enableValidator($enable = true)
 42 |     {
 43 |         self::$enabledValidators[static::class] = $enable;
 44 |     }
 45 | 
 46 |     /**
 47 |      * Disable validator
 48 |      *
 49 |      * @param bool $disable
 50 |      */
 51 |     public static function disableValidator($disable = true)
 52 |     {
 53 |         self::$enabledValidators[static::class] = !$disable;
 54 |     }
 55 | 
 56 |     /**
 57 |      * Get a description for this table.
 58 |      *
 59 |      * @return Table|Column[]
 60 |      * @codeCoverageIgnore This is just a proxy
 61 |      */
 62 |     public static function describe()
 63 |     {
 64 |         return EM::getInstance(static::class)->describe(static::getTableName());
 65 |     }
 66 | 
 67 |     /**
 68 |      * Validate $value for $attribute
 69 |      *
 70 |      * @param string $attribute
 71 |      * @param mixed $value
 72 |      * @return bool|Error
 73 |      */
 74 |     public static function validate($attribute, $value)
 75 |     {
 76 |         return static::describe()->validate(static::getColumnName($attribute), $value);
 77 |     }
 78 | 
 79 |     /**
 80 |      * Validate $data
 81 |      *
 82 |      * $data has to be an array of $attribute => $value
 83 |      *
 84 |      * @param array $data
 85 |      * @return array
 86 |      */
 87 |     public static function validateArray(array $data)
 88 |     {
 89 |         $result = $data;
 90 |         foreach ($result as $attribute => &$value) {
 91 |             $value = static::validate($attribute, $value);
 92 |         }
 93 |         return $result;
 94 |     }
 95 | 
 96 |     /**
 97 |      * Check if the current data is valid
 98 |      *
 99 |      * Returns boolean true when valid otherwise an array of Errors.
100 |      *
101 |      * @return bool|Error[]
102 |      */
103 |     public function isValid()
104 |     {
105 |         $result = [];
106 | 
107 |         $presentColumns = [];
108 |         foreach ($this->data as $column => $value) {
109 |             $presentColumns[] = $column;
110 |             $result[]         = static::validate($column, $value);
111 |         }
112 | 
113 |         foreach (static::describe() as $column) {
114 |             if (!in_array($column->name, $presentColumns)) {
115 |                 $result[] = static::validate($column->name, null);
116 |             }
117 |         }
118 | 
119 |         $result = array_values(array_filter($result, function ($error) {
120 |             return $error instanceof Error;
121 |         }));
122 | 
123 |         return count($result) === 0 ? true : $result;
124 |     }
125 | }
126 | 


--------------------------------------------------------------------------------
/src/EntityFetcher/CallableFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\EntityFetcher;
 4 | 
 5 | use ORM\EntityFetcher;
 6 | 
 7 | class CallableFilter implements FilterInterface
 8 | {
 9 |     protected $filter;
10 | 
11 |     /**
12 |      * @param callable $filter
13 |      */
14 |     public function __construct(callable $filter)
15 |     {
16 |         $this->filter = $filter;
17 |     }
18 | 
19 |     /** {@inheritDoc} */
20 |     public function apply(EntityFetcher $fetcher)
21 |     {
22 |         call_user_func($this->filter, $fetcher);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/EntityFetcher/ExecutesQueries.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\EntityFetcher;
 4 | 
 5 | trait ExecutesQueries
 6 | {
 7 |     /**
 8 |      * Execute an update statement for the current query
 9 |      *
10 |      * **NOTE:** not all drivers support UPDATE with JOIN (or FROM). Has to be implemented in the database abstraction
11 |      * layer.
12 |      *
13 |      * $updates should be an array which columns to update with what value. Use expressions to bypass escaping.
14 |      *
15 |      * @param array $updates An array of columns to update
16 |      * @return int The number of affected rows
17 |      */
18 |     public function update(array $updates)
19 |     {
20 |         $updates = array_combine(
21 |             array_map([$this->class, 'getColumnName'], array_keys($updates)),
22 |             array_values($updates)
23 |         );
24 |         return parent::update($updates);
25 |     }
26 | 
27 |     /**
28 |      * Execute an insert statement on the current table
29 |      *
30 |      * @param array ...$rows
31 |      * @return int The number of inserted rows
32 |      */
33 |     public function insert(array ...$rows)
34 |     {
35 |         $rows = array_map(function ($row) {
36 |             return array_combine(
37 |                 array_map([$this->class, 'getColumnName'], array_keys($row)),
38 |                 array_values($row)
39 |             );
40 |         }, $rows);
41 |         return parent::insert(...$rows);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/EntityFetcher/FilterInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\EntityFetcher;
 4 | 
 5 | use ORM\EntityFetcher;
 6 | 
 7 | interface FilterInterface
 8 | {
 9 |     /**
10 |      * Apply this filter to $fetcher
11 |      *
12 |      * @param EntityFetcher $fetcher
13 |      * @return void
14 |      */
15 |     public function apply(EntityFetcher $fetcher);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/EntityFetcher/MakesJoins.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\EntityFetcher;
 4 | 
 5 | use ORM\Relation;
 6 | 
 7 | trait MakesJoins
 8 | {
 9 |     public function join($class, $expression = '', $alias = '', $args = [])
10 |     {
11 |         list($table, $alias) = $this->getTableAndAlias($class, $alias);
12 |         return parent::join($table, $expression, $alias, $args);
13 |     }
14 | 
15 |     public function leftJoin($class, $expression = '', $alias = '', $args = [])
16 |     {
17 |         list($table, $alias) = $this->getTableAndAlias($class, $alias);
18 |         return parent::leftJoin($table, $expression, $alias, $args);
19 |     }
20 | 
21 |     public function rightJoin($class, $expression = '', $alias = '', $args = [])
22 |     {
23 |         list($table, $alias) = $this->getTableAndAlias($class, $alias);
24 |         return parent::rightJoin($table, $expression, $alias, $args);
25 |     }
26 | 
27 |     public function fullJoin($class, $expression = '', $alias = '', $args = [])
28 |     {
29 |         list($table, $alias) = $this->getTableAndAlias($class, $alias);
30 |         return parent::fullJoin($table, $expression, $alias, $args);
31 |     }
32 | 
33 |     /**
34 |      * Create the join with $join type
35 |      *
36 |      * @param $join
37 |      * @param $relation
38 |      * @return $this
39 |      */
40 |     public function createRelatedJoin($join, $relation)
41 |     {
42 |         if (strpos($relation, '.') !== false) {
43 |             list($alias, $relation) = explode('.', $relation);
44 |             $class = $this->classMapping['byAlias'][$alias];
45 |         } else {
46 |             $class = $this->class;
47 |             $alias = $this->alias;
48 |         }
49 | 
50 |         /** @var Relation $relation */
51 |         $relation = call_user_func([$class, 'getRelation'], $relation);
52 |         $relation->addJoin($this, $join, $alias);
53 |         return $this;
54 |     }
55 | 
56 |     /**
57 |      * Join $relation
58 |      *
59 |      * @param $relation
60 |      * @return $this
61 |      */
62 |     public function joinRelated($relation)
63 |     {
64 |         return $this->createRelatedJoin('join', $relation);
65 |     }
66 | 
67 |     /**
68 |      * Left outer join $relation
69 |      *
70 |      * @param $relation
71 |      * @return $this
72 |      */
73 |     public function leftJoinRelated($relation)
74 |     {
75 |         return $this->createRelatedJoin('leftJoin', $relation);
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/EntityFetcher/TranslatesClasses.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\EntityFetcher;
 4 | 
 5 | use ORM\Entity;
 6 | use ORM\Exception\NotJoined;
 7 | 
 8 | trait TranslatesClasses
 9 | {
10 |     /** The class to alias mapping and vise versa
11 |      * @var string[][] */
12 |     protected $classMapping = [
13 |         'byClass' => [],
14 |         'byAlias' => [],
15 |     ];
16 | 
17 |     /**
18 |      * Translate attribute names in an expression to their column names
19 |      *
20 |      * @param string $expression
21 |      * @return string
22 |      * @throws NotJoined
23 |      */
24 |     protected function translateColumn($expression)
25 |     {
26 |         return preg_replace_callback(
27 |             '/(?<b>^| |\()' .
28 |             '((?<class>[A-Za-z_][A-Za-z0-9_\\\\]*)::|(?<alias>[A-Za-z_][A-Za-z0-9_]+)\.)?' .
29 |             '(?<column>[A-Za-z_][A-Za-z0-9_]*)' .
30 |             '(?<a>$| |,|\))/',
31 |             function ($match) {
32 |                 if ($match['alias'] && !isset($this->classMapping['byAlias'][$match['alias']])) {
33 |                     return $match[0];
34 |                 } elseif ($match['column'] === strtoupper($match['column'])) {
35 |                     return $match['b'] . $match['column'] . $match['a'];
36 |                 }
37 | 
38 |                 list($class, $alias) = $this->toClassAndAlias($match);
39 | 
40 |                 /** @var Entity|string $class */
41 |                 return $match['b'] . $this->entityManager->escapeIdentifier(
42 |                     $alias . '.' . $class::getColumnName($match['column'])
43 |                 ) . $match['a'];
44 |             },
45 |             $expression
46 |         );
47 |     }
48 | 
49 |     /**
50 |      * Get class and alias by the match from translateColumn
51 |      *
52 |      * @param array $match
53 |      * @return array [$class, $alias]
54 |      * @throws NotJoined
55 |      */
56 |     private function toClassAndAlias(array $match)
57 |     {
58 |         if ($match['class']) {
59 |             if (!isset($this->classMapping['byClass'][$match['class']])) {
60 |                 throw new NotJoined("Class " . $match['class'] . " not joined");
61 |             }
62 |             $class = $match['class'];
63 |             $alias = $this->classMapping['byClass'][$match['class']];
64 |         } elseif ($match['alias']) {
65 |             $alias = $match['alias'];
66 |             $class = $this->classMapping['byAlias'][$match['alias']];
67 |         } else {
68 |             $class = $this->class;
69 |             $alias = $this->alias;
70 |         }
71 | 
72 |         return [$class, $alias];
73 |     }
74 | 
75 |     /**
76 |      * Get the table name and alias for a class
77 |      *
78 |      * @param string $class
79 |      * @param string $alias
80 |      * @return array [$table, $alias]
81 |      */
82 |     protected function getTableAndAlias($class, $alias = '')
83 |     {
84 |         if (class_exists($class)) {
85 |             /** @var Entity|string $class */
86 |             $table = $this->entityManager->escapeIdentifier($class::getTableName());
87 |             $alias = $alias ?: 't' . count($this->classMapping['byAlias']);
88 | 
89 |             $this->classMapping['byClass'][$class] = $alias;
90 |             $this->classMapping['byAlias'][$alias] = $class;
91 |         } else {
92 |             $table = $class;
93 |         }
94 | 
95 |         return [$table, $alias];
96 |     }
97 | }
98 | 


--------------------------------------------------------------------------------
/src/Event.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM;
 4 | 
 5 | /**
 6 |  * @property-read Entity $entity
 7 |  * @property-read array $data
 8 |  * @property-read bool $stopped
 9 |  */
10 | abstract class Event
11 | {
12 |     const NAME = 'event';
13 | 
14 |     /** @var Entity */
15 |     protected $entity;
16 | 
17 |     /** @var array */
18 |     protected $data;
19 | 
20 |     /** @var bool */
21 |     protected $stopped = false;
22 | 
23 |     /**
24 |      * @param Entity $entity
25 |      */
26 |     public function __construct(Entity $entity)
27 |     {
28 |         $this->entity = $entity;
29 |         $this->data = $entity->getData();
30 |     }
31 | 
32 |     public function __get($name)
33 |     {
34 |         return isset($this->$name) ? $this->$name : null;
35 |     }
36 | 
37 |     public function stop()
38 |     {
39 |         $this->stopped = true;
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Event/Changed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Event;
 4 | 
 5 | use ORM\Entity;
 6 | use ORM\Event;
 7 | 
 8 | /**
 9 |  * @property-read string $attribute
10 |  * @property-read mixed $oldValue
11 |  * @property-read mixed $newValue
12 |  */
13 | class Changed extends Event
14 | {
15 |     const NAME = 'changed';
16 | 
17 |     /** @var string */
18 |     protected $attribute;
19 | 
20 |     /** @var mixed */
21 |     protected $oldValue;
22 | 
23 |     /** @var mixed */
24 |     protected $newValue;
25 | 
26 |     public function __construct(Entity $entity, $attribute, $oldValue, $newValue)
27 |     {
28 |         parent::__construct($entity);
29 | 
30 |         $this->attribute = $attribute;
31 |         $this->oldValue = $oldValue;
32 |         $this->newValue = $newValue;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Event/Deleted.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Event;
 4 | 
 5 | use ORM\Event;
 6 | 
 7 | class Deleted extends Event
 8 | {
 9 |     const NAME = 'deleted';
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Event/Deleting.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Event;
 4 | 
 5 | use ORM\Event;
 6 | 
 7 | class Deleting extends Event
 8 | {
 9 |     const NAME = 'deleting';
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Event/Fetched.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Event;
 4 | 
 5 | use ORM\Entity;
 6 | use ORM\Event;
 7 | 
 8 | class Fetched extends Event
 9 | {
10 |     const NAME = 'fetched';
11 | 
12 |     /** @var array */
13 |     protected $rawData;
14 | 
15 |     public function __construct(Entity $entity, array $rawData)
16 |     {
17 |         parent::__construct($entity);
18 |         $this->rawData = $rawData;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Event/Inserted.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Event;
 4 | 
 5 | use ORM\Event;
 6 | 
 7 | class Inserted extends Event
 8 | {
 9 |     const NAME = 'inserted';
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Event/Inserting.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Event;
 4 | 
 5 | use ORM\Event;
 6 | 
 7 | class Inserting extends Event
 8 | {
 9 |     const NAME = 'inserting';
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Event/Saved.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Event;
 4 | 
 5 | use ORM\Event;
 6 | 
 7 | /**
 8 |  * @property-read array|null $dirty
 9 |  */
10 | class Saved extends Event
11 | {
12 |     const NAME = 'saved';
13 | 
14 |     /** @var Event */
15 |     protected $originalEvent;
16 | 
17 |     public function __construct(Event $originalEvent)
18 |     {
19 |         parent::__construct($originalEvent->entity);
20 | 
21 |         $this->originalEvent = $originalEvent;
22 |     }
23 | 
24 |     public function __get($name)
25 |     {
26 |         return isset($this->$name) ? $this->$name : $this->originalEvent->$name;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Event/Saving.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Event;
 4 | 
 5 | use ORM\Event;
 6 | 
 7 | class Saving extends Event
 8 | {
 9 |     const NAME = 'saving';
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Event/UpdateEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Event;
 4 | 
 5 | use ORM\Entity;
 6 | use ORM\Event;
 7 | 
 8 | /**
 9 |  * @property-read array $dirty
10 |  */
11 | abstract class UpdateEvent extends Event
12 | {
13 |     /** @var array */
14 |     protected $dirty;
15 | 
16 |     public function __construct(Entity $entity, array $dirty)
17 |     {
18 |         parent::__construct($entity);
19 | 
20 |         $this->dirty = $dirty;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Event/Updated.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ORM\Event;
4 | 
5 | class Updated extends UpdateEvent
6 | {
7 |     const NAME = 'updated';
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Event/Updating.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ORM\Event;
4 | 
5 | class Updating extends UpdateEvent
6 | {
7 |     const NAME = 'updating';
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM;
 4 | 
 5 | /**
 6 |  * Base exception for ORM
 7 |  *
 8 |  * Every ORM exception extends this class. So you can easily catch all exceptions from ORM.
 9 |  *
10 |  * @package ORM
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class Exception extends \Exception
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/IncompletePrimaryKey.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | /**
 8 |  * Class IncompletePrimaryKey
 9 |  *
10 |  * @package ORM
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class IncompletePrimaryKey extends Exception
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidArgument.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | /**
 8 |  * Class InvalidArgument
 9 |  *
10 |  * @package ORM\Exception
11 |  * @author Thomas Flori <thflori@gmail.com>
12 |  */
13 | class InvalidArgument extends Exception
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | /**
 8 |  * Class InvalidConfiguration
 9 |  *
10 |  * @package ORM
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class InvalidConfiguration extends Exception
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | /**
 8 |  * Class InvalidName
 9 |  *
10 |  * @package ORM
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class InvalidName extends Exception
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidRelation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | /**
 8 |  * Class InvalidRelation
 9 |  *
10 |  * @package ORM\Exception
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class InvalidRelation extends Exception
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | class InvalidType extends Exception
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/NoConnection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | /**
 8 |  * Class NoConnection
 9 |  *
10 |  * @package ORM
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class NoConnection extends Exception
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/NoEntity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | /**
 8 |  * Class NoEntity
 9 |  *
10 |  * @package ORM
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class NoEntity extends Exception
14 | {
15 | 
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Exception/NoEntityManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | /**
 8 |  * Class NoEntityManager
 9 |  *
10 |  * @package ORM\Exception
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class NoEntityManager extends Exception
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/NoOperator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | /**
 8 |  * Class NoOperator
 9 |  *
10 |  * @package ORM\Exception
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class NoOperator extends Exception
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/NotJoined.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | /**
 8 |  * Class NotJoined
 9 |  *
10 |  * @package ORM
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class NotJoined extends Exception
14 | {
15 | 
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Exception/NotScalar.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | /**
 8 |  * Class NotScalar
 9 |  *
10 |  * @package ORM
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class NotScalar extends Exception
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/UndefinedRelation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | /**
 8 |  * Class UndefinedRelation
 9 |  *
10 |  * @package ORM\Exception
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class UndefinedRelation extends Exception
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/UnknownColumn.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | class UnknownColumn extends Exception
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/UnsupportedDriver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Exception;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | /**
 8 |  * Class UnsupportedDriver
 9 |  *
10 |  * @package ORM\Exception
11 |  * @author  Thomas Flori <thflori@gmail.com>
12 |  */
13 | class UnsupportedDriver extends Exception
14 | {
15 | 
16 | }
17 | 


--------------------------------------------------------------------------------
/src/MockTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM;
 4 | 
 5 | use ORM\Testing\MocksEntityManager;
 6 | 
 7 | /**
 8 |  * Alias for new namespace
 9 |  *
10 |  * @package ORM
11 |  */
12 | trait MockTrait
13 | {
14 |     use MocksEntityManager;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Observer/AbstractObserver.php:
--------------------------------------------------------------------------------
 1 | <?php /** @noinspection PhpUnusedParameterInspection */
 2 | 
 3 | namespace ORM\Observer;
 4 | 
 5 | use ORM\Event;
 6 | use ORM\ObserverInterface;
 7 | 
 8 | /**
 9 |  * AbstractObserver for entity events
10 |  *
11 |  * When a handler returns false it will cancel other event handlers and if
12 |  * applicable stops the execution (saving, inserting, updating and deleting
13 |  * can be canceled).
14 |  */
15 | abstract class AbstractObserver implements ObserverInterface
16 | {
17 |     /** @inheritDoc */
18 |     public function handle(Event $event)
19 |     {
20 |         if (is_callable([$this, $event::NAME])) {
21 |             return call_user_func([$this, $event::NAME], $event);
22 |         }
23 | 
24 |         return true;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Observer/CallbackObserver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Observer;
 4 | 
 5 | use ORM\Event;
 6 | 
 7 | class CallbackObserver extends AbstractObserver
 8 | {
 9 |     protected $handlers = [];
10 | 
11 |     /**
12 |      * Register a new $listener for $event
13 |      *
14 |      * @param $event
15 |      * @param callable $listener
16 |      * @return $this
17 |      */
18 |     public function on($event, callable $listener)
19 |     {
20 |         if (!isset($this->handlers[$event])) {
21 |             $this->handlers[$event] = [];
22 |         }
23 |         $this->handlers[$event][] = $listener;
24 |         return $this;
25 |     }
26 | 
27 |     /**
28 |      * Remove all listeners for $event
29 |      *
30 |      * @param $event
31 |      * @return $this
32 |      */
33 |     public function off($event)
34 |     {
35 |         $this->handlers[$event] = [];
36 |         return $this;
37 |     }
38 | 
39 |     public function handle(Event $event)
40 |     {
41 |         $handlers = isset($this->handlers[$event::NAME]) ? $this->handlers[$event::NAME] : [];
42 |         foreach ($handlers as $handler) {
43 |             if (call_user_func($handler, $event) === false || $event->stopped) {
44 |                 return $event->stopped;
45 |             }
46 |         }
47 | 
48 |         return true;
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/ObserverInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM;
 4 | 
 5 | /**
 6 |  * AbstractObserver for entity events
 7 |  *
 8 |  * When a handler returns false it will cancel other event handlers and if
 9 |  * applicable stops the execution (saving, inserting, updating and deleting
10 |  * can be canceled).
11 |  */
12 | interface ObserverInterface
13 | {
14 |     /**
15 |      * Handles the $event.
16 |      *
17 |      * Return false to stop event execution.
18 |      *
19 |      * @param Event $event
20 |      * @return bool
21 |      */
22 |     public function handle(Event $event);
23 | }
24 | 


--------------------------------------------------------------------------------
/src/QueryBuilder/Parenthesis.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ORM\QueryBuilder;
  4 | 
  5 | /**
  6 |  * Class Parenthesis
  7 |  *
  8 |  * @package ORM
  9 |  * @author  Thomas Flori <thflori@gmail.com>
 10 |  */
 11 | class Parenthesis implements ParenthesisInterface
 12 | {
 13 |     use HasWhereConditions;
 14 | 
 15 |     /** Callback to close the parenthesis
 16 |      * @var callable */
 17 |     protected $onClose;
 18 | 
 19 |     /** Parent parenthesis or query
 20 |      * @var ParenthesisInterface */
 21 |     protected $parent;
 22 | 
 23 |     /**
 24 |      * Constructor
 25 |      *
 26 |      * Create a parenthesis inside another parenthesis or a query.
 27 |      *
 28 |      * @param callable             $onClose Callable that gets executed when the parenthesis get closed
 29 |      * @param ParenthesisInterface $parent  Parent where createWhereCondition get executed
 30 |      */
 31 |     public function __construct(
 32 |         callable $onClose,
 33 |         ParenthesisInterface $parent
 34 |     ) {
 35 |         $this->onClose = $onClose;
 36 |         $this->parent  = $parent;
 37 |     }
 38 | 
 39 |     /** {@inheritdoc} */
 40 |     public function parenthesis()
 41 |     {
 42 |         return $this->andParenthesis();
 43 |     }
 44 | 
 45 |     /**
 46 |      * {@inheritdoc}
 47 |      * @internal
 48 |      */
 49 |     public function createWhereCondition($column, $operator = null, $value = null)
 50 |     {
 51 |         return $this->parent->createWhereCondition($column, $operator, $value);
 52 |     }
 53 | 
 54 |     /**
 55 |      * Build a where in expression
 56 |      *
 57 |      * Calls buildWhereInExpression() from parent if there is a parent.
 58 |      *
 59 |      * @param string|array $column Column or expression with placeholders
 60 |      * @param array $values Value (required when used with operator)
 61 |      * @param bool $inverse
 62 |      * @return string
 63 |      * @internal
 64 |      */
 65 |     public function buildWhereInExpression($column, array $values, $inverse = false)
 66 |     {
 67 |         return $this->parent->buildWhereInExpression($column, $values, $inverse);
 68 |     }
 69 | 
 70 |     /** {@inheritdoc} */
 71 |     public function andParenthesis()
 72 |     {
 73 |         return new Parenthesis(
 74 |             function (ParenthesisInterface $parenthesis) {
 75 |                 $this->where[] = $this->wherePrefix('AND') . $parenthesis->getExpression();
 76 | 
 77 |                 return $this;
 78 |             },
 79 |             $this
 80 |         );
 81 |     }
 82 | 
 83 |     /** {@inheritdoc} */
 84 |     public function orParenthesis()
 85 |     {
 86 |         return new Parenthesis(
 87 |             function (ParenthesisInterface $parenthesis) {
 88 |                 $this->where[] = $this->wherePrefix('OR') . $parenthesis->getExpression();
 89 | 
 90 |                 return $this;
 91 |             },
 92 |             $this
 93 |         );
 94 |     }
 95 | 
 96 |     /** {@inheritdoc} */
 97 |     public function close()
 98 |     {
 99 |         return call_user_func($this->onClose, $this);
100 |     }
101 | 
102 |     /** {@inheritdoc} */
103 |     public function getExpression()
104 |     {
105 |         return '(' . implode(' ', $this->where) . ')';
106 |     }
107 | }
108 | 


--------------------------------------------------------------------------------
/src/Relation/HasOpponent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Relation;
 4 | 
 5 | use ORM\Exception\InvalidConfiguration;
 6 | use ORM\Helper;
 7 | 
 8 | trait HasOpponent
 9 | {
10 |     /** The name of the relation in the related class
11 |      * @var string */
12 |     protected $opponent;
13 | 
14 |     /**
15 |      * @param string $requiredType
16 |      * @return Owner|ManyToMany
17 |      * @throws InvalidConfiguration
18 |      */
19 |     protected function getOpponent($requiredType = null)
20 |     {
21 |         $opponent = call_user_func([ $this->class, 'getRelation' ], $this->opponent);
22 | 
23 |         if ($requiredType && !$opponent instanceof $requiredType) {
24 |             throw new InvalidConfiguration(sprintf(
25 |                 "The opponent of a %s relation has to be a %s relation. Relation of type %s returned for relation %s" .
26 |                 " of entity %s",
27 |                 Helper::shortName(get_class($this)),
28 |                 Helper::shortName($requiredType),
29 |                 get_class($opponent),
30 |                 $this->name,
31 |                 $this->parent
32 |             ));
33 |         }
34 | 
35 |         return $opponent;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Relation/HasReference.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Relation;
 4 | 
 5 | trait HasReference
 6 | {
 7 |     /** Reference definition as key value pairs
 8 |      * @var array */
 9 |     protected $reference;
10 | 
11 |     public function getReference()
12 |     {
13 |         return $this->reference;
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Relation/OneToOne.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Relation;
 4 | 
 5 | use ORM\Entity;
 6 | use ORM\EntityManager;
 7 | use ORM\Helper;
 8 | 
 9 | /**
10 |  * OneToOne Relation
11 |  *
12 |  * @package ORM\Relation
13 |  * @author  Thomas Flori <thflori@gmail.com>
14 |  */
15 | class OneToOne extends OneToMany
16 | {
17 |     /** {@inheritdoc} */
18 |     public function fetch(Entity $self, EntityManager $entityManager)
19 |     {
20 |         return parent::fetch($self, $entityManager)->one();
21 |     }
22 | 
23 |     /** {@inheritDoc} */
24 |     public static function fromShort($parent, array $short)
25 |     {
26 |         // the cardinality is mandatory for one to one
27 |         if ($short[0] !== self::CARDINALITY_ONE) {
28 |             return null;
29 |         }
30 |         array_shift($short);
31 | 
32 |         return static::createStaticFromShort($short);
33 |     }
34 | 
35 |     /** {@inheritDoc} */
36 |     protected static function fromAssoc($parent, array $relDef)
37 |     {
38 |         if (!isset($relDef[self::OPT_CARDINALITY]) || $relDef[self::OPT_CARDINALITY] === self::CARDINALITY_MANY) {
39 |             return null;
40 |         }
41 | 
42 |         return self::createStaticFromAssoc($relDef);
43 |     }
44 | 
45 |     /** {@inheritDoc} */
46 |     public function eagerLoad(EntityManager $em, Entity ...$entities)
47 |     {
48 |         $foreignObjects = $this->getOpponent(Owner::class)->eagerLoadSelf($em, ...$entities);
49 |         foreach ($entities as $entity) {
50 |             $key = spl_object_hash($entity);
51 |             $entity->setCurrentRelated(
52 |                 $this->name,
53 |                 isset($foreignObjects[$key]) ? Helper::first($foreignObjects[$key]) : null
54 |             );
55 |         }
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Relation/ParentChildren.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Relation;
 4 | 
 5 | use ORM\Entity;
 6 | use ORM\Helper;
 7 | 
 8 | /**
 9 |  * A parent to children (many)
10 |  */
11 | class ParentChildren extends OneToMany
12 | {
13 |     /** {@inheritDoc} */
14 |     public static function fromShort($parent, array $short)
15 |     {
16 |         if ($short[0] === self::CARDINALITY_ONE) {
17 |             return null;
18 |         } elseif ($short[0] === self::CARDINALITY_MANY) {
19 |             array_shift($short);
20 |         }
21 | 
22 |         if ($parent !== $short[0]) {
23 |             return null;
24 |         }
25 | 
26 |         return static::createStaticFromShort($short);
27 |     }
28 | 
29 |     /** {@inheritDoc} */
30 |     protected static function fromAssoc($parent, array $relDef)
31 |     {
32 |         if (!isset($relDef[self::OPT_CLASS]) || $parent !== $relDef[self::OPT_CLASS]) {
33 |             return null;
34 |         }
35 | 
36 |         return parent::fromAssoc($parent, $relDef);
37 |     }
38 | 
39 |     /**
40 |      * Set all children and return an array containing the root elements
41 |      *
42 |      * This method expects you to pass all elements of a branch. Keep in mind that that the array you
43 |      * are getting is not necessarily from the same parent if you are not passing all elements of a branch.
44 |      *
45 |      * Example of this issue:
46 |      * Elements passed `['1.', '1.2.', '1.3.', '3.5.', '4.']` (each element is represented by its materialized path).
47 |      * As '3.' is not passed, '3.5.' seems to be the root element resulting in the following tree:
48 |      * ```php
49 |      * [
50 |      *   [path => '1.', children => [['path' => '1.2.'],['path' => '1.3.']]],
51 |      *   [path => '3.5.'],
52 |      *   [path => '4.'],
53 |      * ]
54 |      * ```
55 |      *
56 |      * Example usage when you are using materialized paths:
57 |      * ```php
58 |      * $children = $em->fetch('Category::class')->where('path', 'LIKE', '3.5._%')->all();
59 |      * $treeOf35 = Category::getRelation('children')->buildTree(...$children);
60 |      * ```
61 |      *
62 |      * @param Entity ...$entities
63 |      * @return Entity[]
64 |      */
65 |     public function buildTree(Entity ...$entities)
66 |     {
67 |         $reference = $this->getOpponent(Owner::class)->getReference();
68 |         /** @var Entity[] $entities */
69 |         $entities = Helper::keyBy($entities, array_values($reference));
70 |         $tree = [];
71 |         foreach (Helper::groupBy($entities, array_keys($reference)) as $key => $children) {
72 |             if (!isset($entities[$key])) {
73 |                 $tree = array_merge($tree, $children);
74 |                 continue;
75 |             }
76 |             $entities[$key]->setCurrentRelated($this->name, $children);
77 |         }
78 |         return $tree;
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/src/Testing/EntityFetcherMock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Testing;
 4 | 
 5 | use ORM\EntityFetcher;
 6 | 
 7 | class EntityFetcherMock extends EntityFetcher
 8 | {
 9 |     /** @var array */
10 |     protected $currentResult;
11 | 
12 |     /** @var EntityManagerMock */
13 |     public $entityManager;
14 | 
15 |     /** {@inheritDoc} */
16 |     public function one()
17 |     {
18 |         if ($this->currentResult === null) {
19 |             $this->currentResult = $this->entityManager->getResults($this->class, $this);
20 |         }
21 | 
22 |         return array_shift($this->currentResult);
23 |     }
24 | 
25 |     /** {@inheritDoc} */
26 |     public function count()
27 |     {
28 |         return count($this->entityManager->getResults($this->class, $this));
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Testing/EntityManagerMock.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ORM\Testing;
  4 | 
  5 | use Mockery as m;
  6 | use ORM\Entity;
  7 | use ORM\EntityFetcher;
  8 | use ORM\EntityManager;
  9 | use ORM\Exception\NoEntity;
 10 | use ORM\Testing\EntityFetcherMock\Result;
 11 | use ORM\Testing\EntityFetcherMock\ResultRepository;
 12 | use ReflectionClass;
 13 | 
 14 | class EntityManagerMock extends EntityManager
 15 | {
 16 |     protected $resultRepository;
 17 | 
 18 |     public function __construct($options = [])
 19 |     {
 20 |         static::$emMapping['byClass'] = [];
 21 |         parent::__construct($options);
 22 |         $this->resultRepository = new ResultRepository($this);
 23 |     }
 24 | 
 25 |     /**
 26 |      * Add an entity to be fetched by primary key
 27 |      *
 28 |      * The entity needs to have a primary key if not it will be filled with random values between RANDOM_KEY_MIN and
 29 |      * RANDOM_KEY_MAX (at the time writing this it is 1000000000 and 1000999999).
 30 |      *
 31 |      * You can pass mocks from Entity too but we need to call `Entity::getPrimaryKey()`.
 32 |      *
 33 |      * @param Entity $entity
 34 |      * @codeCoverageIgnore proxy method
 35 |      */
 36 |     public function addEntity(Entity $entity)
 37 |     {
 38 |         $this->resultRepository->addEntity($entity);
 39 |     }
 40 | 
 41 |     /**
 42 |      * Retrieve an entity by $primaryKey
 43 |      *
 44 |      * @param string $class
 45 |      * @param array $primaryKey
 46 |      * @return Entity|null
 47 |      * @codeCoverageIgnore proxy method
 48 |      */
 49 |     public function retrieve($class, array $primaryKey)
 50 |     {
 51 |         return $this->resultRepository->retrieve($class, $primaryKey);
 52 |     }
 53 | 
 54 |     /**
 55 |      * Create and add a EntityFetcherMock\Result for $class
 56 |      *
 57 |      * As the results are mocked to come from the database they will also get a primary key if they don't have already.
 58 |      *
 59 |      * @param $class
 60 |      * @param Entity ...$entities
 61 |      * @return Result|m\MockInterface
 62 |      * @codeCoverageIgnore proxy method
 63 |      */
 64 |     public function addResult($class, Entity ...$entities)
 65 |     {
 66 |         return $this->resultRepository->addResult($class, ...$entities);
 67 |     }
 68 | 
 69 |     /**
 70 |      * Get the results for $class and $query
 71 |      *
 72 |      * The EntityFetcherMock\Result gets a quality for matching this query. Only the highest quality will be used.
 73 |      *
 74 |      * @param string $class
 75 |      * @param EntityFetcher $fetcher
 76 |      * @return array
 77 |      * @codeCoverageIgnore proxy method
 78 |      */
 79 |     public function getResults($class, EntityFetcher $fetcher)
 80 |     {
 81 |         return $this->resultRepository->getResults($class, $fetcher);
 82 |     }
 83 | 
 84 |     /** {@inheritDoc} */
 85 |     public function fetch($class, $primaryKey = null)
 86 |     {
 87 |         $reflection = new ReflectionClass($class);
 88 |         if (!$reflection->isSubclassOf(Entity::class)) {
 89 |             throw new NoEntity($class . ' is not a subclass of Entity');
 90 |         }
 91 |         /** @var string|Entity $class */
 92 | 
 93 |         if ($primaryKey === null) {
 94 |             return new EntityFetcherMock($this, $class);
 95 |         }
 96 | 
 97 |         $primaryKey = $this->buildPrimaryKey($class, (array)$primaryKey);
 98 |         $checksum = $this->buildChecksum($primaryKey);
 99 | 
100 |         if (isset($this->map[$class][$checksum])) {
101 |             return $this->map[$class][$checksum];
102 |         }
103 | 
104 |         return $this->retrieve($class, $primaryKey);
105 |     }
106 | }
107 | 


--------------------------------------------------------------------------------
/tests/ClosureWrapper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test;
 4 | 
 5 | class ClosureWrapper
 6 | {
 7 |     private $closure;
 8 |     public function __construct(\Closure $closure)
 9 |     {
10 |         $this->closure = $closure;
11 |     }
12 |     public function __invoke()
13 |     {
14 |         return call_user_func_array($this->closure, func_get_args());
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/tests/Constraint/ArraySubset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Constraint;
 4 | 
 5 | use PHPUnit\Framework\Constraint\Constraint;
 6 | 
 7 | class ArraySubset extends Constraint
 8 | {
 9 |     /** @var array */
10 |     protected $subset;
11 | 
12 |     /** @var bool */
13 |     protected $strict;
14 | 
15 |     protected $delta = null;
16 | 
17 |     public function __construct($subset, bool $strict = false, float $delta = null)
18 |     {
19 |         $this->strict = $strict;
20 |         $this->subset = $subset;
21 |         $this->delta = $delta;
22 |     }
23 | 
24 |     protected function matches($other): bool
25 |     {
26 |         return count($this->arrayDiffRecursive($this->subset, $other)) === 0;
27 |     }
28 | 
29 |     public function toString(): string
30 |     {
31 |         return 'has the subset ' . $this->exporter()->export($this->subset);
32 |     }
33 | 
34 |     protected function failureDescription($other): string
35 |     {
36 |         return 'Failed asserting that an array has the expected subset. Differences:' . PHP_EOL .
37 |             json_encode($this->arrayDiffRecursive($this->subset, $other), JSON_PRETTY_PRINT);
38 |     }
39 | 
40 |     public function arrayDiffRecursive(
41 |         array $expected,
42 |         array $actual,
43 |         array &$difference = [],
44 |         string $parentPath = ''
45 |     ): array {
46 |         $oldKey = 'expected';
47 |         $newKey = 'actual';
48 |         foreach ($expected as $k => $v) {
49 |             $path = ($parentPath ? $parentPath . '.' : '') . $k;
50 |             if (is_array($v)) {
51 |                 if (!array_key_exists($k, $actual) || !is_array($actual[$k])) {
52 |                     $difference[$path][$oldKey] = $v;
53 |                     $difference[$path][$newKey] = null;
54 |                 } else {
55 |                     $this->arrayDiffRecursive($v, $actual[$k], $difference, $path);
56 |                     if (!empty($recursion)) {
57 |                         $difference[$oldKey][$k] = $recursion[$oldKey];
58 |                         $difference[$newKey][$k] = $recursion[$newKey];
59 |                     }
60 |                 }
61 |             } else {
62 |                 if (!empty($v) && !array_key_exists($k, $actual)) {
63 |                     $difference[$path][$oldKey] = $v;
64 |                     $difference[$path][$newKey] = null;
65 |                 } else {
66 |                     $a = $actual[$k] ?? null;
67 |                     if ($this->delta && is_float($v)) {
68 |                         $diff = abs($a - $v);
69 |                         if ($diff > $this->delta) {
70 |                             $difference[$path][$oldKey] = $v;
71 |                             $difference[$path][$newKey] = $a;
72 |                         }
73 |                     } elseif ($this->strict && $a !== $v || $a != $v) {
74 |                         $difference[$path][$oldKey] = $v;
75 |                         $difference[$path][$newKey] = $a;
76 |                     }
77 |                 }
78 |             }
79 |         }
80 |         return $difference;
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/tests/DbConfigTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test;
 4 | 
 5 | use ORM\DbConfig;
 6 | 
 7 | class DbConfigTest extends TestCase
 8 | {
 9 |     public function provideAttributes()
10 |     {
11 |         return [
12 |             [
13 |                 ['mysql', 'db'],
14 |                 'mysql:host=localhost;port=3306;dbname=db'
15 |             ],
16 |             [
17 |                 ['mysql', 'db', null, null, '/run/mysqld/mysqld.sock'],
18 |                 'mysql:unix_socket=/run/mysqld/mysqld.sock;dbname=db'
19 |             ],
20 |             [
21 |                 ['pgsql', 'db'],
22 |                 'pgsql:host=localhost;port=5432;dbname=db'
23 |             ],
24 |             [
25 |                 ['sqlite', '/tmp/test.sqlite'],
26 |                 'sqlite:/tmp/test.sqlite'
27 |             ]
28 |         ];
29 |     }
30 | 
31 |     /** @dataProvider provideAttributes
32 |      * @test */
33 |     public function constructorSetsDsn($args, $expectedDsn)
34 |     {
35 |         if ($args[0] === 'mysql' && !extension_loaded('pdo_mysql')) {
36 |             self::markTestSkipped('pdo_mysql extension required');
37 |         } elseif ($args[0] === 'pgsql' && !extension_loaded('pdo_pgsql')) {
38 |             self::markTestSkipped('pdo_pgsql extension required');
39 |         } elseif ($args[0] === 'sqlite' && !extension_loaded('pdo_sqlite')) {
40 |             self::markTestSkipped('pdo_sqlite extension required');
41 |         }
42 | 
43 |         $dbConfigReflection = new \ReflectionClass(DbConfig::class);
44 | 
45 |         /** @var DbConfig $dbConfig */
46 |         $dbConfig = $dbConfigReflection->newInstanceArgs($args);
47 | 
48 |         self::assertSame($expectedDsn, $dbConfig->getDsn());
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/tests/Dbal/BasicTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal;
 4 | 
 5 | use ORM\Dbal;
 6 | use ORM\EM;
 7 | use ORM\Exception;
 8 | use ORM\Test\TestCase;
 9 | 
10 | class BasicTest extends TestCase
11 | {
12 |     /** @var Dbal\Dbal */
13 |     protected $dbal;
14 | 
15 |     protected function setUp(): void
16 |     {
17 |         parent::setUp();
18 | 
19 |         $this->dbal = new Dbal\Other($this->em);
20 |     }
21 | 
22 |     /** @test */
23 |     public function escapesIdentifiersWithDoubleQuote()
24 |     {
25 |         $escaped = $this->dbal->escapeIdentifier('user');
26 | 
27 |         self::assertSame('"user"', $escaped);
28 |     }
29 | 
30 |     /** @test */
31 |     public function escapesSchemasInIdentifiers()
32 |     {
33 |         $escaped = $this->dbal->escapeIdentifier('user.id');
34 | 
35 |         self::assertSame('"user"."id"', $escaped);
36 |     }
37 | 
38 |     /** @test */
39 |     public function doesNotEscapeExpressions()
40 |     {
41 |         $escaped = $this->dbal->escapeIdentifier(EM::raw('DATE("column")'));
42 | 
43 |         self::assertSame('DATE("column")', $escaped);
44 |     }
45 | 
46 |     /** @test */
47 |     public function doesNotSupportDescribe()
48 |     {
49 |         self::expectException(Exception::class);
50 |         self::expectExceptionMessage('Describe is not supported by this driver');
51 | 
52 |         $this->dbal->describe('any');
53 |     }
54 | 
55 | 
56 | 
57 |     /** @test */
58 |     public function doesNotSupportUpdateWithJoins()
59 |     {
60 |         self::expectException(Exception::class);
61 |         self::expectExceptionMessage('Updates with joins are not supported by this driver');
62 | 
63 |         $this->em->query('examples')
64 |             ->join('names', 'exampleId = examples.id')
65 |             ->where('examples.id', 42)
66 |             ->update(['foo' => EM::raw('names.foo')]);
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/tests/Dbal/ColumnTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal;
 4 | 
 5 | use ORM\Dbal\Column;
 6 | use ORM\Dbal\Type\Number;
 7 | use ORM\Test\TestCase;
 8 | 
 9 | class ColumnTest extends TestCase
10 | {
11 |     public function provideColumnDefinitions()
12 |     {
13 |         $colDef = [
14 |             'column_name' => 'test_col',
15 |             'type' => Number::class,
16 |             'data_type' => 'tinyint',
17 |             'column_default' => '1',
18 |             'is_nullable' => 'YES',
19 |         ];
20 | 
21 |         return [
22 |             [$colDef, 'data_type', 'tinyint'],
23 |             [$colDef, 'name', 'test_col'],
24 |             [$colDef, 'default', '1'],
25 |             [$colDef, 'nullable', true],
26 |         ];
27 |     }
28 | 
29 |     /** @dataProvider provideColumnDefinitions
30 |      * @test */
31 |     public function magicGetter($columnDefinition, $var, $expected)
32 |     {
33 |         $column = new Column($this->dbal, $columnDefinition);
34 | 
35 |         $result = $column->$var;
36 | 
37 |         self::assertSame($expected, $result);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/Dbal/DataModificationTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\EM;
 7 | use ORM\Test\TestCase;
 8 | use PDOStatement;
 9 | 
10 | class DataModificationTest extends TestCase
11 | {
12 |     /** @test */
13 |     public function executesAnInsertStatement()
14 |     {
15 |         $this->pdo->shouldReceive('query')->with(
16 |             "INSERT INTO \"examples\" (\"col1\",\"col2\") VALUES ('foo','bar')"
17 |         )->once()->andReturn($statement = m::mock(PDOStatement::class));
18 |         $statement->shouldReceive('rowCount')->andReturn(1);
19 | 
20 |         $this->dbal->insert('examples', ['col1' => 'foo', 'col2' => 'bar']);
21 |     }
22 | 
23 |     /** @test */
24 |     public function insertsEscapedValues()
25 |     {
26 |         $this->pdo->shouldReceive('query')->with(
27 |             "INSERT INTO \"examples\" (\"col1\",\"col2\") VALUES ('hempel\\'s sofa','2020-11-12T08:42:00.000000Z')"
28 |         )->once()->andReturn($statement = m::mock(PDOStatement::class));
29 |         $statement->shouldReceive('rowCount')->andReturn(1);
30 | 
31 |         $this->dbal->insert('examples', ['col1' => 'hempel\'s sofa', 'col2' => new \DateTime('2020-11-12 08:42:00')]);
32 |     }
33 | 
34 |     /** @test */
35 |     public function insertsAllColumnsFromAllRows()
36 |     {
37 |         $this->pdo->shouldReceive('query')->with(
38 |             "INSERT INTO \"examples\" (\"col1\",\"col2\") VALUES ('foo',NULL),(NULL,'bar')"
39 |         )->once()->andReturn($statement = m::mock(PDOStatement::class));
40 |         $statement->shouldReceive('rowCount')->andReturn(2);
41 | 
42 |         $this->dbal->insert('examples', ['col1' => 'foo'], ['col2' => 'bar']);
43 |     }
44 | 
45 |     /** @test */
46 |     public function insertReturns0IfNoRowsAreGiven()
47 |     {
48 |         $result = $this->dbal->insert('examples');
49 | 
50 |         self::assertSame(0, $result);
51 |     }
52 | 
53 |     /** @test */
54 |     public function insertReturnsTheNumberOfAffectedRows()
55 |     {
56 |         $this->pdo->shouldReceive('query')->with(
57 |             "INSERT INTO \"examples\" (\"col1\",\"col2\") VALUES ('foo',NULL),(NULL,'bar')"
58 |         )->once()->andReturn($statement = m::mock(PDOStatement::class));
59 |         $statement->shouldReceive('rowCount')->andReturn(2);
60 | 
61 |         $result = $this->dbal->insert('examples', ['col1' => 'foo'], ['col2' => 'bar']);
62 | 
63 |         self::assertSame(2, $result);
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/tests/Dbal/EscapeValueTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ORM\Test\Dbal;
  4 | 
  5 | use ORM\Dbal;
  6 | use ORM\EM;
  7 | use ORM\Exception\NotScalar;
  8 | use ORM\Test\Examples\DateTimeDerivate;
  9 | use ORM\Test\TestCase;
 10 | 
 11 | class EscapeValueTest extends TestCase
 12 | {
 13 |     /** @var Dbal\Dbal */
 14 |     protected $dbal;
 15 | 
 16 |     protected function setUp(): void
 17 |     {
 18 |         parent::setUp();
 19 | 
 20 |         $this->dbal = new Dbal\Other($this->em);
 21 |     }
 22 | 
 23 |     /** @test */
 24 |     public function onlyConvertsScalarData()
 25 |     {
 26 |         $array = ['this','is','not','scalar'];
 27 | 
 28 |         self::expectException(NotScalar::class);
 29 |         self::expectExceptionMessage('$value has to be scalar data type. array given');
 30 | 
 31 |         $this->dbal->escapeValue($array);
 32 |     }
 33 | 
 34 |     public function provideScalars()
 35 |     {
 36 |         return [
 37 |             [42, '42'],
 38 |             [3E3, '3000'],
 39 |             [-5E-8, '-5.0E-8'],
 40 |             [0.002, '0.002'],
 41 |             [42.1, '42.1'],
 42 |             [null, 'NULL'],
 43 |         ];
 44 |     }
 45 | 
 46 |     /** @dataProvider provideScalars
 47 |      * @test */
 48 |     public function convertsScalar($value, $expected)
 49 |     {
 50 |         $result = $this->dbal->escapeValue($value);
 51 | 
 52 |         self::assertSame($expected, $result);
 53 |     }
 54 | 
 55 |     public function provideBooleanDefaults()
 56 |     {
 57 |         return [
 58 |             [true, '1'],
 59 |             [false, '0'],
 60 |         ];
 61 |     }
 62 | 
 63 |     /** @dataProvider provideBooleanDefaults
 64 |      * @test */
 65 |     public function booleanUseDefaults($value, $expected)
 66 |     {
 67 |         $result = $this->dbal->escapeValue($value);
 68 | 
 69 |         self::assertSame($expected, $result);
 70 |     }
 71 | 
 72 |     /** @test */
 73 |     public function doesNotConvertExpressions()
 74 |     {
 75 |         $result = $this->dbal->escapeValue(EM::raw('DATE(NOW())'));
 76 | 
 77 |         self::assertSame('DATE(NOW())', $result);
 78 |     }
 79 | 
 80 |     /** @test */
 81 |     public function dateTime()
 82 |     {
 83 |         $dateTime = \DateTime::createFromFormat('U.u', '1496163695.123456');
 84 | 
 85 |         $result = $this->dbal->escapeValue($dateTime);
 86 | 
 87 |         self::assertSame('\'2017-05-30T17:01:35.123456Z\'', $result);
 88 |     }
 89 | 
 90 |     /** @test */
 91 |     public function stringsUseQuote()
 92 |     {
 93 |         $this->pdo->shouldReceive('quote')->once()->with('foobar')->andReturn('\'buzzword\'');
 94 | 
 95 |         $result = $this->dbal->escapeValue('foobar');
 96 | 
 97 |         self::assertSame('\'buzzword\'', $result);
 98 |     }
 99 | 
100 |     /** @test */
101 |     public function numericString()
102 |     {
103 |         $result = $this->dbal->escapeValue('1.1234567890123456');
104 | 
105 |         self::assertSame('\'1.1234567890123456\'', $result);
106 |     }
107 | 
108 |     /** @test */
109 |     public function dateTimeDerivate()
110 |     {
111 |         $dateTime = DateTimeDerivate::createFromFormat('U.u', '1496163695.123456');
112 | 
113 |         $result = $this->dbal->escapeValue($dateTime);
114 | 
115 |         self::assertSame('\'2017-05-30T17:01:35.123456Z\'', $result);
116 |     }
117 | }
118 | 


--------------------------------------------------------------------------------
/tests/Dbal/Mysql/UpdateJoinTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Mysql;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\Dbal\Mysql;
 7 | use ORM\EM;
 8 | use ORM\Test\TestCase;
 9 | 
10 | class UpdateJoinTest extends TestCase
11 | {
12 |     /** @var Pgsql */
13 |     protected $dbal;
14 | 
15 |     protected function setUp(): void
16 |     {
17 |         parent::setUp();
18 |         $this->dbal = new Mysql($this->em);
19 |     }
20 | 
21 |     /** @test */
22 |     public function executesAnUpdateJoinStatement()
23 |     {
24 |         $this->pdo->shouldReceive('query')->with(
25 |             "UPDATE examples JOIN names ON exampleId = examples.id SET \"foo\" = names.foo WHERE examples.id = 42"
26 |         )->once()->andReturn($statement = m::mock(\PDOStatement::class));
27 |         $statement->shouldReceive('rowCount')->andReturn(1);
28 | 
29 |         $this->em->query('examples')
30 |             ->join('names', 'exampleId = examples.id')
31 |             ->where('examples.id', 42)
32 |             ->update(['foo' => EM::raw('names.foo')]);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/tests/Dbal/Other/UpdateTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Other;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\Dbal\Other;
 7 | use ORM\QueryBuilder\QueryBuilder;
 8 | use ORM\Test\TestCase;
 9 | 
10 | class UpdateTest extends TestCase
11 | {
12 |     protected function setUp(): void
13 |     {
14 |         parent::setUp();
15 |         $this->dbal = new Other($this->em);
16 |     }
17 | 
18 |     /** @test */
19 |     public function executesAnUpdateStatement()
20 |     {
21 |         $this->pdo->shouldReceive('query')->with(
22 |             "UPDATE \"examples\" SET \"foo\" = 'bar' WHERE \"id\" = 42"
23 |         )->once()->andReturn($statement = m::mock(\PDOStatement::class));
24 |         $statement->shouldReceive('rowCount')->andReturn(1);
25 | 
26 |         $this->dbal->update('examples', ['id' => 42], ['foo' => 'bar']);
27 |     }
28 | 
29 |     /** @test */
30 |     public function updatesEscapedValues()
31 |     {
32 |         $this->pdo->shouldReceive('query')->with(
33 |             "UPDATE \"examples\" SET \"col1\" = 'hempel\\'s sofa',\"col2\" = 23 WHERE \"id\" = 42"
34 |         )->once()->andReturn($statement = m::mock(\PDOStatement::class));
35 |         $statement->shouldReceive('rowCount')->andReturn(1);
36 | 
37 |         $this->dbal->update('examples', ['id' => 42], ['col1' => 'hempel\'s sofa', 'col2' => 23]);
38 |     }
39 | 
40 |     /** @test */
41 |     public function doesNotNeedWhereConditions()
42 |     {
43 |         $this->pdo->shouldReceive('query')->with('UPDATE "questions" SET "answer" = 42')
44 |             ->once()->andReturn($statement = m::mock(\PDOStatement::class));
45 |         $statement->shouldReceive('rowCount')->andReturn(1);
46 | 
47 |         $this->dbal->update('questions', [], ['answer' => 42]);
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/tests/Dbal/Pgsql/UpdateFromTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Pgsql;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\Dbal\Pgsql;
 7 | use ORM\EM;
 8 | use ORM\Exception;
 9 | use ORM\Test\TestCase;
10 | 
11 | class UpdateFromTest extends TestCase
12 | {
13 |     /** @var Pgsql */
14 |     protected $dbal;
15 | 
16 |     protected function setUp(): void
17 |     {
18 |         parent::setUp();
19 |         $this->dbal = new Pgsql($this->em);
20 |     }
21 | 
22 |     /** @test */
23 |     public function executesAnUpdateFromStatement()
24 |     {
25 |         $this->pdo->shouldReceive('query')->with(
26 |             "UPDATE examples SET \"foo\" = names.foo FROM names WHERE exampleId = examples.id AND examples.id = 42"
27 |         )->once()->andReturn($statement = m::mock(\PDOStatement::class));
28 |         $statement->shouldReceive('rowCount')->andReturn(1);
29 | 
30 |         $this->em->query('examples')
31 |             ->join('names', 'exampleId = examples.id')
32 |             ->where('examples.id', 42)
33 |             ->update(['foo' => EM::raw('names.foo')]);
34 |     }
35 | 
36 |     /** @test */
37 |     public function updateFromOnlyWorksWithInnerJoins()
38 |     {
39 |         self::expectException(Exception::class);
40 |         self::expectExceptionMessage('Only inner joins with on clause are allowed in update from statements');
41 | 
42 |         $this->em->query('examples')
43 |             ->leftJoin('names', 'exampleId = examples.id')
44 |             ->where('examples.id', 42)
45 |             ->update(['foo' => EM::raw('names.foo')]);
46 |     }
47 | 
48 |     /** @test */
49 |     public function updateFromWorksAlsoWithoutJoins()
50 |     {
51 |         $this->pdo->shouldReceive('query')->with(
52 |             "UPDATE examples SET \"foo\" = 'bar' WHERE id = 23"
53 |         )->once()->andReturn($statement = m::mock(\PDOStatement::class));
54 |         $statement->shouldReceive('rowCount')->andReturn(1);
55 | 
56 |         $this->em->query('examples')
57 |             ->where('id', 23)
58 |             ->update(['foo' => 'bar']);
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/tests/Dbal/Sqlite/InsertTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Sqlite;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\Dbal\Sqlite;
 7 | use ORM\Test\Entity\Examples\ContactPhone;
 8 | use ORM\Test\TestCase;
 9 | 
10 | class InsertTest extends TestCase
11 | {
12 |     /** @var Sqlite */
13 |     protected $dbal;
14 | 
15 |     protected function setUp(): void
16 |     {
17 |         parent::setUp();
18 | 
19 |         $this->dbal = new Sqlite($this->em);
20 |     }
21 | 
22 |     /** @test */
23 |     public function buildsValidQueryForCompositeKeys()
24 |     {
25 |         $entity = new ContactPhone(['id' => 1, 'name' => 'mobile', 'number' => '+1 555 123']);
26 | 
27 |         $this->pdo->shouldReceive('query')->with(m::pattern(
28 |             '/INSERT INTO .* \("id","name","number"\) VALUES \(.*\)/'
29 |         ))->once()->andReturn($statement = m::mock(\PDOStatement::class));
30 |         $statement->shouldReceive('rowCount')->andReturn(1);
31 |         $this->pdo->shouldReceive('query')->with(m::pattern(
32 |             '/SELECT \* FROM .* WHERE \("id","name"\) IN \(VALUES (\(.*\))(,\(.*\))*\)/'
33 |         ))->once()->andReturn($statement = m::mock(\PDOStatement::class));
34 |         $statement->shouldReceive('setFetchMode')->once()->with(\PDO::FETCH_ASSOC)->andReturnTrue();
35 |         $statement->shouldReceive('fetch')->with()
36 |             ->times(2)->andReturn(
37 |                 ['id' => 1, 'name' => 'mobile', 'number' => '+1 555 123', 'created' => date('c')],
38 |                 false
39 |             );
40 | 
41 |         $this->dbal->insertAndSync($entity);
42 | 
43 |         self::assertSame('+1 555 123', $entity->number);
44 |         self::assertNotNull($entity->created);
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/tests/Dbal/Sqlite/UpdateFromTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Sqlite;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\Dbal\Sqlite;
 7 | use ORM\EM;
 8 | use ORM\Test\TestCase;
 9 | 
10 | class UpdateFromTest extends TestCase
11 | {
12 |     /** @var Sqlite */
13 |     protected $dbal;
14 | 
15 |     protected function setUp(): void
16 |     {
17 |         parent::setUp();
18 |         $this->dbal = new Sqlite($this->em);
19 |     }
20 | 
21 |     /** @test */
22 |     public function executesAnUpdateFromStatement()
23 |     {
24 |         $this->pdo->shouldReceive('query')->with(
25 |             "UPDATE examples SET \"foo\" = names.foo FROM names WHERE exampleId = examples.id AND examples.id = 42"
26 |         )->once()->andReturn($statement = m::mock(\PDOStatement::class));
27 |         $statement->shouldReceive('rowCount')->andReturn(1);
28 | 
29 |         $this->em->query('examples')
30 |             ->join('names', 'exampleId = examples.id')
31 |             ->where('examples.id', 42)
32 |             ->update(['foo' => EM::raw('names.foo')]);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/tests/Dbal/Type/BooleanTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Column;
 6 | use ORM\Dbal\Error;
 7 | use ORM\Dbal\Error\NotValid;
 8 | use ORM\Dbal\Mysql;
 9 | use ORM\Dbal\Type\Boolean;
10 | use ORM\EntityManager;
11 | use ORM\Test\TestCase;
12 | 
13 | class BooleanTest extends TestCase
14 | {
15 |     /** @test */
16 |     public function exists()
17 |     {
18 |         self::assertTrue(class_exists(Boolean::class));
19 |     }
20 | 
21 |     public function provideValues()
22 |     {
23 |         return [
24 |             ['1', '0', true, true],
25 |             ['1', '0', false, true],
26 | 
27 |             ['1', '0', '1', true],
28 |             ['1', '0', '0', true],
29 |             ['1', '0', 0, true],
30 |             ['1', '0', 1, true],
31 |             ['true', 'false', 'true', true],
32 |             ['true', 'false', 'false', true],
33 |             ['\'y\'', '\'n\'', 'y', true],
34 |             ['\'y\'', '\'n\'', 'n', true],
35 | 
36 |             ['1', '0', 't', 't can not be converted to boolean'],
37 |             ['1', '0', 'f', 'f can not be converted to boolean'],
38 |             ['true', 'false', '1', '1 can not be converted to boolean'],
39 |             ['true', 'false', '0', '0 can not be converted to boolean'],
40 |             ['true', 'false', 1, '1 can not be converted to boolean'],
41 |             ['true', 'false', 0, '0 can not be converted to boolean'],
42 |             ['\'y\'', '\'n\'', 'true', 'true can not be converted to boolean'],
43 |             ['\'y\'', '\'n\'', 'false', 'false can not be converted to boolean'],
44 |         ];
45 |     }
46 | 
47 |     /** @dataProvider provideValues
48 |      * @test */
49 |     public function validate($true, $false, $value, $expected)
50 |     {
51 |         $this->dbal->setOption(EntityManager::OPT_BOOLEAN_TRUE, $true);
52 |         $this->dbal->setOption(EntityManager::OPT_BOOLEAN_FALSE, $false);
53 |         $column = new Column($this->dbal, [
54 |             'column_name' => 'abool',
55 |             'type' => Boolean::class,
56 |             'data_type' => 'tinyint',
57 |         ]);
58 |         $type = $column->getType();
59 | 
60 |         $result = $type->validate($value);
61 | 
62 |         if ($expected !== true) {
63 |             self::assertInstanceOf(Error::class, $result);
64 |             self::assertSame($expected, $result->getMessage());
65 |         } else {
66 |             self::assertTrue($result);
67 |         }
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/tests/Dbal/Type/Custom/CustomColumn.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Type\Custom;
 4 | 
 5 | use ORM\Dbal\Column;
 6 | 
 7 | class CustomColumn extends Column
 8 | {
 9 |     public static function getRegisteredTypes()
10 |     {
11 |         return self::$registeredTypes;
12 |     }
13 | 
14 |     public static function resetRegisteredTypes()
15 |     {
16 |         self::$registeredTypes = [];
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/tests/Dbal/Type/Custom/Point.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Type\Custom;
 4 | 
 5 | use ORM\Dbal\Type;
 6 | 
 7 | class Point extends Type
 8 | {
 9 |     public function validate($value)
10 |     {
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/tests/Dbal/Type/DateTimeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | use ORM\Dbal\Type\DateTime;
 7 | use ORM\Test\TestCase;
 8 | 
 9 | class DateTimeTest extends TestCase
10 | {
11 |     /** @test */
12 |     public function exists()
13 |     {
14 |         self::assertTrue(class_exists(DateTime::class));
15 |     }
16 | 
17 |     public function provideValuesWithTime()
18 |     {
19 |         $dt = \DateTime::createFromFormat('U.u', microtime(true))
20 |             ->setTimezone(new \DateTimeZone('UTC'));
21 | 
22 |         return [
23 |             [$dt, true],
24 |             [$dt->format('Y-m-d H:i:s'), true],
25 |             [$dt->format('c'), true],
26 |             [$dt->format('Y-m-d\TH:i:s.u\Z'), true],
27 | 
28 |             // valid but no time
29 |             ['+01234-01-01', '+01234-01-01 is not a valid date or date time expression'],
30 |             ['-01234-01-01', '-01234-01-01 is not a valid date or date time expression'],
31 | 
32 |             ['NOW()', 'NOW() is not a valid date or date time expression'],
33 |             ['23rd of June \'84 5pm', '23rd of June \'84 5pm is not a valid date or date time expression'],
34 |             [$dt->format('r'), $dt->format('r') . ' is not a valid date or date time expression'],
35 |         ];
36 |     }
37 | 
38 |     /** @dataProvider provideValuesWithTime
39 |      * @test */
40 |     public function validateWithTime($value, $expected)
41 |     {
42 |         $type = new DateTime(3, false);
43 | 
44 |         $result = $type->validate($value);
45 | 
46 |         if ($expected !== true) {
47 |             self::assertInstanceOf(Error::class, $result);
48 |             self::assertSame($expected, $result->getMessage());
49 |         } else {
50 |             self::assertTrue($result);
51 |         }
52 |     }
53 | 
54 |     public function provideValuesWithoutTime()
55 |     {
56 |         $dt = \DateTime::createFromFormat('U.u', microtime(true))
57 |             ->setTimezone(new \DateTimeZone('UTC'));
58 | 
59 |         return [
60 |             [$dt, true],
61 |             ['+01234-01-01', true],
62 |             ['-01234-01-01', true],
63 |             ['1984-01-21', true],
64 | 
65 |             // valid but with time
66 |             [$dt->format('Y-m-d H:i:s'), true],
67 |             [$dt->format('c'), true],
68 |             [$dt->format('Y-m-d\TH:i:s.u\Z'), true],
69 | 
70 |             ['NOW()', 'NOW() is not a valid date or date time expression'],
71 |             ['23rd of June \'84 5pm', '23rd of June \'84 5pm is not a valid date or date time expression'],
72 |             [$dt->format('r'), $dt->format('r') . ' is not a valid date or date time expression'],
73 |         ];
74 |     }
75 | 
76 |     /** @dataProvider provideValuesWithoutTime
77 |      * @test */
78 |     public function validateWithoutTime($value, $expected)
79 |     {
80 |         $type = new DateTime(3, true);
81 | 
82 |         $result = $type->validate($value);
83 | 
84 |         if ($expected !== true) {
85 |             self::assertInstanceOf(Error::class, $result);
86 |             self::assertSame($expected, $result->getMessage());
87 |         } else {
88 |             self::assertTrue($result);
89 |         }
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/tests/Dbal/Type/EnumTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | use ORM\Dbal\Type\Enum;
 7 | use ORM\Test\TestCase;
 8 | 
 9 | class EnumTest extends TestCase
10 | {
11 |     /** @test */
12 |     public function exists()
13 |     {
14 |         self::assertTrue(class_exists(Enum::class));
15 |     }
16 | 
17 |     public function provideValues()
18 |     {
19 |         return [
20 |             ['a', ['a', 'b'], true],
21 |             ['b', ['a', 'b'], true],
22 | 
23 |             ['c', ['a', 'b'], '\'c\' is not allowed by this enum'],
24 |             [1, ['1', '2'], 'Only string values are allowed for enum'],
25 |         ];
26 |     }
27 | 
28 |     /** @dataProvider provideValues
29 |      * @test */
30 |     public function validate($value, $allowedValues, $expected)
31 |     {
32 |         $type = new Enum($allowedValues);
33 | 
34 |         $result = $type->validate($value);
35 | 
36 |         if ($expected !== true) {
37 |             self::assertInstanceOf(Error::class, $result);
38 |             self::assertSame($expected, $result->getMessage());
39 |         } else {
40 |             self::assertTrue($result);
41 |         }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/Dbal/Type/JsonTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | use ORM\Dbal\Type\Json;
 7 | use ORM\Test\TestCase;
 8 | 
 9 | class JsonTest extends TestCase
10 | {
11 |     /** @test */
12 |     public function exists()
13 |     {
14 |         self::assertTrue(class_exists(Json::class));
15 |     }
16 | 
17 |     public function provideValues()
18 |     {
19 |         return [
20 |             [json_encode(['key' => 'value']), true],
21 |             [json_encode(null), true],
22 |             [json_encode(0), true],
23 |             [json_encode(42), true],
24 |             [json_encode(true), true],
25 |             [json_encode(false), true],
26 |             [json_encode(['a','b','c']), true],
27 | 
28 |             [42, 'Only string values are allowed for json'],
29 |             // json allows only double quotes
30 |             ['{\'key\':\'value\'}', '\'{\'key\':\'value\'}\' is not a valid JSON string'],
31 |             // no valid json
32 |             ['undefined', '\'undefined\' is not a valid JSON string'],
33 |         ];
34 |     }
35 | 
36 |     /** @dataProvider provideValues
37 |      * @test */
38 |     public function validate($value, $expected)
39 |     {
40 |         $type = new Json();
41 | 
42 |         $result = $type->validate($value);
43 | 
44 |         if ($expected !== true) {
45 |             self::assertInstanceOf(Error::class, $result);
46 |             self::assertSame($expected, $result->getMessage());
47 |         } else {
48 |             self::assertTrue($result);
49 |         }
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/tests/Dbal/Type/NumberTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | use ORM\Dbal\Type\Number;
 7 | use ORM\Test\TestCase;
 8 | 
 9 | class NumberTest extends TestCase
10 | {
11 |     /** @test */
12 |     public function exists()
13 |     {
14 |         self::assertTrue(class_exists(Number::class));
15 |     }
16 | 
17 |     public function provideValues()
18 |     {
19 |         return [
20 |             [42, true], // integer
21 |             [6*7.0, true], // double
22 |             ['42', true],
23 |             ['12.01', true],
24 |             ['-12E2', true],
25 |             ['+12.002E2', true],
26 |             ['-2E-5', true],
27 | 
28 |             ['E23', 'E23 is not numeric'],
29 |             ['zweiundvierzig', 'zweiundvierzig is not numeric'],
30 |             ['1,235.01', '1,235.01 is not numeric'],
31 |         ];
32 |     }
33 | 
34 |     /** @dataProvider provideValues
35 |      * @test */
36 |     public function validate($value, $expected)
37 |     {
38 |         $type = new Number();
39 | 
40 |         $result = $type->validate($value);
41 | 
42 |         if ($expected !== true) {
43 |             self::assertInstanceOf(Error::class, $result);
44 |             self::assertSame($expected, $result->getMessage());
45 |         } else {
46 |             self::assertTrue($result);
47 |         }
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/tests/Dbal/Type/SetTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | use ORM\Dbal\Type\Set;
 7 | use ORM\Test\TestCase;
 8 | 
 9 | class SetTest extends TestCase
10 | {
11 |     /** @test */
12 |     public function exists()
13 |     {
14 |         self::assertTrue(class_exists(Set::class));
15 |     }
16 | 
17 |     public function provideValues()
18 |     {
19 |         return [
20 |             ['a', ['a', 'b'], true],
21 |             ['b', ['a', 'b'], true],
22 |             ['a,b', ['a', 'b'], true],
23 |             ['b,a', ['a', 'b'], true],
24 | 
25 |             ['c', ['a', 'b'], '\'c\' is not allowed by this set'],
26 |             ['a,c', ['a', 'b'], '\'c\' is not allowed by this set'],
27 |             [1, ['1', '2'], 'Only string values are allowed for set'],
28 |         ];
29 |     }
30 | 
31 |     /** @dataProvider provideValues
32 |      * @test */
33 |     public function validate($value, $allowedValues, $expected)
34 |     {
35 |         $type = new Set($allowedValues);
36 | 
37 |         $result = $type->validate($value);
38 | 
39 |         if ($expected !== true) {
40 |             self::assertInstanceOf(Error::class, $result);
41 |             self::assertSame($expected, $result->getMessage());
42 |         } else {
43 |             self::assertTrue($result);
44 |         }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/tests/Dbal/Type/TextTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | use ORM\Dbal\Type\Text;
 7 | use ORM\Test\TestCase;
 8 | 
 9 | class TextTest extends TestCase
10 | {
11 |     /** @test */
12 |     public function exists()
13 |     {
14 |         self::assertTrue(class_exists(Text::class));
15 |     }
16 | 
17 |     public function provideValues()
18 |     {
19 |         return [
20 |             ['unlimited string length', true],
21 |             [(string)42, true],
22 | 
23 |             [42, 'Only string values are allowed for text'], // only string accepted
24 |         ];
25 |     }
26 | 
27 |     /** @dataProvider provideValues
28 |      * @test */
29 |     public function validate($value, $expected)
30 |     {
31 |         $type = new Text();
32 | 
33 |         $result = $type->validate($value);
34 | 
35 |         if ($expected !== true) {
36 |             self::assertInstanceOf(Error::class, $result);
37 |             self::assertSame($expected, $result->getMessage());
38 |         } else {
39 |             self::assertTrue($result);
40 |         }
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/tests/Dbal/Type/TimeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | use ORM\Dbal\Type\Time;
 7 | use ORM\Test\TestCase;
 8 | 
 9 | class TimeTest extends TestCase
10 | {
11 |     /** @test */
12 |     public function exists()
13 |     {
14 |         self::assertTrue(class_exists(Time::class));
15 |     }
16 | 
17 |     public function provideValues()
18 |     {
19 |         $dt = \DateTime::createFromFormat('U.u', microtime(true))
20 |             ->setTimezone(new \DateTimeZone('UTC'));
21 | 
22 |         return [
23 |             [$dt->format('H:i:s'), true],
24 |             [$dt->format('H:i:s.u\Z'), true],
25 | 
26 |             ['NOW()', 'NOW() is not a valid time expression'],
27 |             ['5pm', '5pm is not a valid time expression'],
28 |             [$dt, 'DateTime is not allowed for time'],
29 |             [$dt->format('c'), $dt->format('c') . ' is not a valid time expression'],
30 |             [$dt->format('r'), $dt->format('r') . ' is not a valid time expression'],
31 |         ];
32 |     }
33 | 
34 |     /** @dataProvider provideValues
35 |      * @test */
36 |     public function validate($value, $expected)
37 |     {
38 |         $type = new Time(3);
39 | 
40 |         $result = $type->validate($value);
41 | 
42 |         if ($expected !== true) {
43 |             self::assertInstanceOf(Error::class, $result);
44 |             self::assertSame($expected, $result->getMessage());
45 |         } else {
46 |             self::assertTrue($result);
47 |         }
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/tests/Dbal/Type/VarCharTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Dbal\Type;
 4 | 
 5 | use ORM\Dbal\Error;
 6 | use ORM\Dbal\Type\VarChar;
 7 | use ORM\Test\TestCase;
 8 | 
 9 | class VarCharTest extends TestCase
10 | {
11 |     /** @test */
12 |     public function exists()
13 |     {
14 |         self::assertTrue(class_exists(VarChar::class));
15 |     }
16 | 
17 |     public function provideValues()
18 |     {
19 |         return [
20 |             ['The answer is 42', 16, true],
21 |             ['Short value', 16, true],
22 |             ['unlimited string length', 0, true],
23 |             ['utf8 chars like äöü', 19, true],
24 |             [(string)42, 0, true],
25 | 
26 |             ['This value is too long', 21, '\'This value is too long\' is too long (max: 21)'],
27 |             [42, 0, 'Only string values are allowed for varchar'], // only string accepted
28 |         ];
29 |     }
30 | 
31 |     /** @dataProvider provideValues
32 |      * @test */
33 |     public function validate($value, $maxLen, $expected)
34 |     {
35 |         $type = new VarChar($maxLen);
36 | 
37 |         $result = $type->validate($value);
38 | 
39 |         if ($expected !== true) {
40 |             self::assertInstanceOf(Error::class, $result);
41 |             self::assertSame($expected, $result->getMessage());
42 |         } else {
43 |             self::assertTrue($result);
44 |         }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/tests/Entity/BasicTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity;
 4 | 
 5 | use ORM\Exception;
 6 | use ORM\Test\Entity\Examples\Article;
 7 | use ORM\Test\TestCase;
 8 | use ORM\Test\TestEntityManager;
 9 | 
10 | class BasicTest extends TestCase
11 | {
12 |     /** @test */
13 |     public function creatingEntitiesThrowsWhenNoEntityManagerIsDefined()
14 |     {
15 |         // reset the em for this test
16 |         TestEntityManager::resetStaticsForTest();
17 | 
18 |         self::expectException(Exception::class);
19 |         self::expectExceptionMessage('No entity manager initialized');
20 | 
21 |         $article = new Article();
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/Entity/BootTestEntity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity;
 4 | 
 5 | use ORM\Entity;
 6 | 
 7 | class BootTestEntity extends Entity
 8 | {
 9 |     use BootTestTrait;
10 | 
11 |     /** @var callable */
12 |     public static $bootSpy;
13 | 
14 |     public static function resetBooting()
15 |     {
16 |         static::$booted = [];
17 |         self::$bootSpy = null;
18 |         self::$bootTestTraitSpy = null;
19 |     }
20 | 
21 |     protected static function boot()
22 |     {
23 |         if (is_callable(static::$bootSpy)) {
24 |             call_user_func_array(static::$bootSpy, func_get_args());
25 |         }
26 | 
27 |         parent::boot();
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/Entity/BootTestTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity;
 4 | 
 5 | trait BootTestTrait
 6 | {
 7 |     /** @var callable */
 8 |     public static $bootTestTraitSpy;
 9 | 
10 |     protected static function bootBootTestTrait()
11 |     {
12 |         if (is_callable(static::$bootTestTraitSpy)) {
13 |             call_user_func_array(static::$bootTestTraitSpy, func_get_args());
14 |         }
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/tests/Entity/BootingTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity;
 4 | 
 5 | use ORM\Test\TestCase;
 6 | 
 7 | class BootingTest extends TestCase
 8 | {
 9 |     protected function tearDown(): void
10 |     {
11 |         parent::tearDown();
12 |         BootTestEntity::resetBooting();
13 |     }
14 | 
15 |     /** @test */
16 |     public function entityGetsBootedWhenEntityGetsCreated()
17 |     {
18 |         BootTestEntity::$bootSpy = $spy = \Mockery::spy(function () {
19 |         });
20 | 
21 |         $bte = new BootTestEntity();
22 | 
23 |         $spy->shouldHaveBeenCalled()->once();
24 |     }
25 | 
26 |     /** @test */
27 |     public function entityGetsBootedOnlyOnce()
28 |     {
29 |         BootTestEntity::$bootSpy = $spy = \Mockery::spy(function () {
30 |         });
31 | 
32 |         $bte = new BootTestEntity();
33 |         $bte = new BootTestEntity();
34 | 
35 |         $spy->shouldHaveBeenCalled()->once();
36 |     }
37 | 
38 |     /** @test */
39 |     public function entityGetsBootedOnUnserialize()
40 |     {
41 |         $bteCache = serialize(new BootTestEntity());
42 |         BootTestEntity::resetBooting();
43 | 
44 |         BootTestEntity::$bootSpy = $spy = \Mockery::spy(function () {
45 |         });
46 | 
47 |         $bte = unserialize($bteCache);
48 | 
49 |         $spy->shouldHaveBeenCalled()->once();
50 |     }
51 | 
52 |     /** @test */
53 |     public function entityGetsBootedOnCreatingEntityFetcher()
54 |     {
55 |         BootTestEntity::$bootSpy = $spy = \Mockery::spy(function () {
56 |         });
57 | 
58 |         $fetcher = BootTestEntity::query();
59 | 
60 |         $spy->shouldHaveBeenCalled()->once();
61 |     }
62 | 
63 |     /** @test */
64 |     public function traitGetsBooted()
65 |     {
66 |         BootTestEntity::$bootTestTraitSpy = $spy = \Mockery::spy(function () {
67 |         });
68 | 
69 |         new BootTestEntity();
70 | 
71 |         $spy->shouldHaveBeenCalled()->once();
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/Article.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | 
 5 | use ORM\Entity;
 6 | use ORM\Test\Entity\Examples\Concerns\WithTimestamps;
 7 | 
 8 | class Article extends Entity implements Taggable
 9 | {
10 |     use WithTimestamps;
11 | 
12 |     protected static $includedAttributes = [
13 |         'intro',
14 |     ];
15 | 
16 |     protected static $excludedAttributes = [
17 |         'userId',
18 |     ];
19 |     
20 |     protected static $relations = [
21 |         'categories' => [Category::class, ['id' => 'article_id'], 'articles', 'article_category'],
22 |         'writer' => [User::class, ['userId' => 'id']],
23 |         'tags' => [Tag::class, 'parent'],
24 |         'tagsByClass' => [Tag::class, 'parentNoMap'],
25 |         'tagsOverArticleId' => [Tag::class, 'parentDifferentPk'],
26 |         'tagsByArticleId' => [Tag::class, 'parentDifferentFk'],
27 |     ];
28 | 
29 |     public function getIntro()
30 |     {
31 |         return implode('', array_slice(preg_split(
32 |             '/([\s,\.;\?\!]+)/',
33 |             $this->text,
34 |             61,
35 |             PREG_SPLIT_DELIM_CAPTURE
36 |         ), 0, 59));
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/Category.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | 
 5 | use ORM\Entity;
 6 | use ORM\Relation;
 7 | 
 8 | class Category extends Entity
 9 | {
10 |     protected static $enableValidator = true;
11 | 
12 |     protected static $relations = [
13 |         'articles' => [Article::class, ['id' => 'category_id'], 'categories', 'article_category'],
14 |         'articlesAssoc' => [
15 |             Relation::OPT_CARDINALITY => Relation::CARDINALITY_MANY,
16 |             Relation::OPT_CLASS => Article::class,
17 |             Relation::OPT_REFERENCE => ['id' => 'category_id'],
18 |             Relation::OPT_OPPONENT => 'categories',
19 |             Relation::OPT_TABLE => 'article_category',
20 |         ],
21 |         'parent' => [self::class, ['parentId' => 'id']],
22 |         'children' => [self::class, 'parent'],
23 |     ];
24 | }
25 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/Concerns/WithCreated.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples\Concerns;
 4 | 
 5 | use DateTime;
 6 | use DateTimeZone;
 7 | use ORM\EM;
 8 | use ORM\Event;
 9 | 
10 | trait WithCreated
11 | {
12 |     protected static function bootWithCreated()
13 |     {
14 |         EM::getInstance(static::class)->observe(static::class)
15 |             ->on('inserting', function (Event $event) {
16 |                 $now = (new DateTime('now', new DateTimeZone('UTC')))->format('Y-m-d\TH:i:s.u\Z');
17 |                 $event->entity->setAttribute('updated', $now);
18 |             });
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/Concerns/WithTimestamps.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ORM\Test\Entity\Examples\Concerns;
4 | 
5 | trait WithTimestamps
6 | {
7 |     use WithCreated, WithUpdated;
8 | }
9 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/Concerns/WithUpdated.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples\Concerns;
 4 | 
 5 | use DateTime;
 6 | use DateTimeZone;
 7 | use ORM\EM;
 8 | use ORM\Event;
 9 | 
10 | trait WithUpdated
11 | {
12 |     protected static function bootWithUpdated()
13 |     {
14 |         EM::getInstance(static::class)->observe(static::class)
15 |             ->on('inserting', function (Event $event) {
16 |                 $now = (new DateTime('now', new DateTimeZone('UTC')))->format('Y-m-d\TH:i:s.u\Z');
17 |                 $event->entity->setAttribute('updated', $now);
18 |             })
19 |             ->on('updating', function (Event $event) {
20 |                 $now = (new DateTime('now', new DateTimeZone('UTC')))->format('Y-m-d\TH:i:s.u\Z');
21 |                 $event->entity->setAttribute('updated', $now);
22 |             });
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/ContactPhone.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | 
 5 | use ORM\Test\TestEntity;
 6 | 
 7 | class ContactPhone extends TestEntity
 8 | {
 9 |     protected static $primaryKey = ['id', 'name'];
10 | 
11 |     protected static $relations = [
12 |         'relation' => [RelationExample::class, ['relationId' => 'id']],
13 |     ];
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/DamagedABBRVCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | 
 5 | use ORM\Test\TestEntity;
 6 | 
 7 | class DamagedABBRVCase extends TestEntity
 8 | {
 9 |     protected static $relations = [
10 |         'relation' => ['one', RelationExample::class, 'dmgd'],
11 |         'undefined1t1' => ['one', StudlyCaps::class, 'dmgd'],
12 |         'undefined1tm' => [StudlyCaps::class, 'dmgd']
13 |     ];
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/GeneratesUuid.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | 
 5 | use ORM\Entity;
 6 | 
 7 | class GeneratesUuid extends Entity implements Entity\GeneratesPrimaryKeys
 8 | {
 9 |     protected static $autoIncrement = false;
10 | 
11 |     protected function generatePrimaryKey()
12 |     {
13 |         $this->id = uniqid();
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/Image.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | 
 5 | use ORM\Entity;
 6 | 
 7 | class Image extends Entity implements Taggable
 8 | {
 9 |     protected static $relations = [
10 |         'tags' => [Tag::class, 'parent'],
11 |     ];
12 | }
13 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/Psr0_StudlyCaps.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | 
 5 | use ORM\Test\TestEntity;
 6 | 
 7 | class Psr0_StudlyCaps extends TestEntity
 8 | {
 9 |     protected static $autoIncrement = false;
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/RelationExample.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | 
 5 | use ORM\Entity;
 6 | use ORM\Relation;
 7 | 
 8 | class RelationExample extends Entity
 9 | {
10 |     protected static $relations = [
11 |         'studlyCaps' => [
12 |             Relation::OPT_CARDINALITY => 'many',
13 |             Relation::OPT_CLASS => StudlyCaps::class,
14 |             Relation::OPT_REFERENCE => ['studlyCapsId' => 'id'],
15 |         ],
16 |         'psr0StudlyCaps' => [
17 |             Relation::OPT_CLASS => Psr0_StudlyCaps::class,
18 |             Relation::OPT_REFERENCE => ['psr0StudlyCaps' => 'id'],
19 |         ],
20 |         'contactPhones' => [
21 |             Relation::OPT_CLASS => ContactPhone::class,
22 |             Relation::OPT_OPPONENT => 'relation',
23 |         ],
24 |         'dmgd' => [DamagedABBRVCase::class, ['dmgdId' => 'id']],
25 |         'invalid' => [StudlyCaps::class, 'opponent', 'something'], // additional data is not allowed
26 |         'mySnake' => ['one', Snake_Ucfirst::class, 'relation'],
27 |         'mySnakeAssoc' => [
28 |             Relation::OPT_CARDINALITY => Relation::CARDINALITY_ONE,
29 |             Relation::OPT_CLASS => Snake_Ucfirst::class,
30 |             Relation::OPT_OPPONENT => 'relation',
31 |         ],
32 |         'snake' => [Snake_Ucfirst::class, ['snakeId' => 'id']]
33 |     ];
34 | 
35 |     protected static function anotherSnakeRelation()
36 |     {
37 |         return new Relation\OneToOne(Snake_Ucfirst::class, 'relation');
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/Snake_Ucfirst.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | 
 5 | use ORM\Test\TestEntity;
 6 | 
 7 | class Snake_Ucfirst extends TestEntity
 8 | {
 9 |     protected static $primaryKey = 'My_Key';
10 |     protected static $autoIncrementSequence = 'snake_ucfirst_seq';
11 | 
12 |     protected static $columnAliases = [
13 |         'anotherVar' => 'another_var'
14 |     ];
15 | 
16 |     protected static $relations = [
17 |         'relations' => [RelationExample::class, 'snake'],
18 |         'relation'  => ['one', RelationExample::class, 'mySnake'],
19 |         'invalid'   => [RelationExample::class, 'mySnake']
20 |     ];
21 | 
22 |     public function set_another_var($value)
23 |     {
24 |     }
25 | 
26 |     public function get_another_var()
27 |     {
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/StaticTableName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | 
 5 | use ORM\Test\TestEntity;
 6 | 
 7 | class StaticTableName extends TestEntity
 8 | {
 9 |     protected static $tableName = 'my_table';
10 |     protected static $primaryKey = ['table', 'name', 'foo'];
11 |     protected static $columnPrefix = 'stn_';
12 | 
13 |     protected static $columnAliases = [
14 |         'foo' => 'bar'
15 |     ];
16 | 
17 |     protected $data = [
18 |         'bar' => 'default'
19 |     ];
20 | }
21 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/StudlyCaps.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | use ORM\Test\TestEntity;
 5 | 
 6 | /**
 7 |  * @property string someVar
 8 |  * @property string newVar
 9 |  */
10 | class StudlyCaps extends TestEntity
11 | {
12 |     protected $anotherVar = 'foobaz';
13 | 
14 |     public function onChange($var, $oldValue, $value)
15 |     {
16 |     }
17 | 
18 |     public function setAnotherVar($value)
19 |     {
20 |         $this->anotherVar = $value;
21 |     }
22 | 
23 |     public function getAnotherVar()
24 |     {
25 |         return $this->anotherVar;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/Tag.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | 
 5 | use ORM\Entity;
 6 | 
 7 | class Tag extends Entity
 8 | {
 9 |     protected static $relations = [
10 |         'parent' => [['parentType' => [
11 |             'image' => Image::class,
12 |             'article' => Article::class,
13 |         ]], ['parentId']],
14 |         'parentNoMap' => [['parentType' => Taggable::class], ['parentId' => 'id']],
15 |         'parentDifferentPk' => [
16 |             ['parentType' => [
17 |                 'image' => Image::class,
18 |                 'article' => Article::class,
19 |             ]],
20 |             ['parentId' => [
21 |                 'image' => 'imageId',
22 |                 'article' => 'articleId',
23 |             ]],
24 |         ],
25 |         'parentDifferentFk' => [
26 |             ['parentType' => [
27 |                 'image' => Image::class,
28 |                 'article' => Article::class,
29 |             ]],
30 |             [
31 |                 'image' => ['imageId' => 'id'],
32 |                 'article' => ['articleId' => 'id'],
33 |             ],
34 |         ],
35 |     ];
36 | }
37 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/Taggable.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ORM\Test\Entity\Examples;
4 | 
5 | interface Taggable
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/User.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | 
 5 | use ORM\Entity;
 6 | 
 7 | class User extends Entity
 8 | {
 9 |     protected static $relations = [
10 |         'articles' => [Article::class, 'writer'],
11 |         'contact' => ['one', UserContact::class, 'user'],
12 |     ];
13 | }
14 | 


--------------------------------------------------------------------------------
/tests/Entity/Examples/UserContact.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity\Examples;
 4 | 
 5 | use ORM\Entity;
 6 | 
 7 | class UserContact extends Entity
 8 | {
 9 |     protected static $relations = [
10 |         'user' => [User::class, ['userId' => 'id']],
11 |     ];
12 | }
13 | 


--------------------------------------------------------------------------------
/tests/Entity/ExistsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\Test\Entity\Examples\Article;
 7 | use ORM\Test\TestCase;
 8 | 
 9 | class ExistsTest extends TestCase
10 | {
11 |     /** @test */
12 |     public function anEntityFromDatabaseExists()
13 |     {
14 |         $entity = new Article(['id' => 42, 'title' => 'Foobar'], $this->em, true);
15 | 
16 |         self::assertTrue($entity->exists());
17 |     }
18 | 
19 |     /** @test */
20 |     public function afterInsertAnEntityExists()
21 |     {
22 |         $entity = new Article();
23 | 
24 |         $this->em->shouldReceive('insert')->with($entity, true)
25 |             ->once()->andReturn(true);
26 | 
27 |         $entity->save();
28 | 
29 |         self::assertTrue($entity->exists());
30 |     }
31 | 
32 |     /** @test */
33 |     public function afterSyncAnEntityExists()
34 |     {
35 |         $entity = new Article(['id' => 42]);
36 | 
37 |         $this->pdo->shouldReceive('query')->with('SELECT DISTINCT t0.* FROM "article" AS t0 WHERE "t0"."id" = 42')
38 |             ->once()->andReturn($statement = m::mock(\PDOStatement::class));
39 |         $statement->shouldReceive('fetch')->with(\PDO::FETCH_ASSOC)
40 |             ->once()->andReturn(['id' => 42, 'title' => 'Foobar']);
41 | 
42 |         $this->em->sync($entity);
43 | 
44 |         self::assertTrue($entity->exists());
45 |     }
46 | 
47 |     /** @test */
48 |     public function afterRestoreAnEntityStillExists()
49 |     {
50 |         $serialized = serialize(new Article(['id' => 42], $this->em, true));
51 | 
52 |         $entity = unserialize($serialized);
53 | 
54 |         self::assertTrue($entity->exists());
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/tests/Entity/HelperTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity;
 4 | 
 5 | use ORM\EntityManager;
 6 | use ORM\Test\Entity\Examples\Article;
 7 | use ORM\Test\TestCase;
 8 | 
 9 | class HelperTest extends TestCase
10 | {
11 |     /** @test */
12 |     public function queryReturnsAnEntityFetcher()
13 |     {
14 |         $fetcher = Article::query();
15 | 
16 |         self::assertEquals(EntityManager::getInstance(Article::class)->fetch(Article::class), $fetcher);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/tests/Entity/IssetTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Entity;
 4 | 
 5 | use ORM\Test\Entity\Examples\Article;
 6 | use ORM\Test\TestCase;
 7 | 
 8 | class IssetTest extends TestCase
 9 | {
10 |     /** @test */
11 |     public function usesExistingGetters()
12 |     {
13 |         $entity = \Mockery::mock(Article::class)->makePartial();
14 | 
15 |         $entity->shouldReceive('getIntro')->once()->andReturn('Any text');
16 | 
17 |         $result = isset($entity->intro);
18 | 
19 |         self::assertTrue($result);
20 |     }
21 | 
22 |     /** @test */
23 |     public function loadsTheRelation()
24 |     {
25 |         $entity = \Mockery::mock(Article::class)->makePartial();
26 | 
27 |         $entity->shouldReceive('getRelated')->with('categories')->andReturn([]);
28 | 
29 |         $result = isset($entity->categories);
30 | 
31 |         self::assertFalse($result);
32 |     }
33 | 
34 |     /** @test */
35 |     public function checksIfValueExists()
36 |     {
37 |         $entity = new Article(['published' => false]);
38 | 
39 |         $result = isset($entity->published);
40 | 
41 |         self::assertTrue($result);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/Entity/ValidateTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ORM\Test\Entity;
  4 | 
  5 | use ORM\Dbal\Column;
  6 | use ORM\Dbal\Mysql;
  7 | use ORM\Dbal\Table;
  8 | use ORM\Dbal\Type\Integer;
  9 | use ORM\Dbal\Type\Number;
 10 | use ORM\Dbal\Type\VarChar;
 11 | use ORM\EntityManager;
 12 | use ORM\Exception;
 13 | use ORM\Test\Entity\Examples\Article;
 14 | use ORM\Test\Entity\Examples\Category;
 15 | use ORM\Test\TestCase;
 16 | 
 17 | class ValidateTest extends TestCase
 18 | {
 19 |     protected function setUp(): void
 20 |     {
 21 |         parent::setUp();
 22 | 
 23 |         $this->mocks['table'] = \Mockery::mock(Table::class);
 24 |         $this->mocks['em']->shouldReceive('describe')->with('article')->andReturn($this->mocks['table'])->byDefault();
 25 |     }
 26 | 
 27 |     /** @test */
 28 |     public function getsTableFromEmDescribe()
 29 |     {
 30 |         $this->mocks['em']->shouldReceive('describe')->with('article')->once()->andReturn($this->mocks['table']);
 31 | 
 32 |         Article::describe();
 33 |     }
 34 | 
 35 |     /** @test */
 36 |     public function validateUsesTableFromDescribe()
 37 |     {
 38 |         $this->mocks['table']->shouldReceive('validate')->with('title', 'Hello World!')->once()->andReturn(true);
 39 | 
 40 |         Article::validate('title', 'Hello World!');
 41 |     }
 42 | 
 43 |     /** @test */
 44 |     public function convertsFieldNamesToColumns()
 45 |     {
 46 |         $this->mocks['table']->shouldReceive('validate')->with('intro_text', 'This is just a test article.')
 47 |             ->once()->andReturn(true);
 48 | 
 49 |         Article::validate('introText', 'This is just a test article.');
 50 |     }
 51 | 
 52 |     /** @test */
 53 |     public function validateArray()
 54 |     {
 55 |         $this->mocks['table']->shouldReceive('validate')->with('title', 'Hello World!')->once()->andReturn(true);
 56 |         $this->mocks['table']->shouldReceive('validate')->with('intro_text', 'This is just a test article.')
 57 |             ->once()->andReturn(true);
 58 | 
 59 |         $result = Article::validateArray([
 60 |             'title' => 'Hello World!',
 61 |             'introText' => 'This is just a test article.',
 62 |         ]);
 63 | 
 64 |         self::assertSame(['title' => true, 'introText' => true], $result);
 65 |     }
 66 | 
 67 |     /** @test */
 68 |     public function byDefaultValidatorIsDisabled()
 69 |     {
 70 |         self::assertFalse(Article::isValidatorEnabled());
 71 |     }
 72 | 
 73 |     /**
 74 |      * @depends testByDefaultValidatorIsDisabled
 75 |      */
 76 |     /** @test */
 77 |     public function validatorCanBeEnabled()
 78 |     {
 79 |         Article::enableValidator();
 80 | 
 81 |         self::assertTrue(Article::isValidatorEnabled());
 82 |     }
 83 | 
 84 |     /**
 85 |      * @depends testValidatorCanBeEnabled
 86 |      */
 87 |     /** @test */
 88 |     public function validatorCanBeDisabled()
 89 |     {
 90 |         Article::disableValidator();
 91 | 
 92 |         self::assertFalse(Article::isValidatorEnabled());
 93 |     }
 94 | 
 95 |     /** @test */
 96 |     public function validatorCanBeActivatedByStatic()
 97 |     {
 98 |         self::assertTrue(Category::isValidatorEnabled());
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/tests/EntityFetcher/CountTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\EntityFetcher;
 4 | 
 5 | use Mockery\Mock;
 6 | use Mockery as m;
 7 | use ORM\EntityFetcher;
 8 | use ORM\Test\Entity\Examples\DamagedABBRVCase;
 9 | use ORM\Test\Entity\Examples\StudlyCaps;
10 | use ORM\Test\TestCase;
11 | 
12 | class CountTest extends TestCase
13 | {
14 |     /** @var Mock */
15 |     protected $statement;
16 | 
17 |     protected function setUp(): void
18 |     {
19 |         parent::setUp();
20 | 
21 |         $this->statement = m::mock(\PDOStatement::class);
22 | 
23 |         $this->pdo->shouldReceive('query')->with(m::pattern('/^SELECT COUNT\(\*\) FROM \(.*\) AS stmt/'))
24 |             ->andReturn($this->statement)->byDefault();
25 |         $this->statement->shouldReceive('fetchColumn')->with()
26 |             ->andReturn(42)->byDefault();
27 |     }
28 | 
29 |     /** @test */
30 |     public function countReturnsInteger()
31 |     {
32 |         $fetcher = $this->em->fetch(DamagedABBRVCase::class);
33 | 
34 |         $result = $fetcher->count();
35 | 
36 |         self::assertIsInt($result);
37 |     }
38 | 
39 |     /** @test */
40 |     public function countExecutesQuery()
41 |     {
42 |         /** @var EntityFetcher $fetcher */
43 |         $fetcher = $this->em->fetch(StudlyCaps::class);
44 | 
45 |         $this->pdo->shouldReceive('query')
46 |             ->with('SELECT COUNT(*) FROM (SELECT DISTINCT t0.* FROM "studly_caps" AS t0) AS stmt')
47 |             ->once()->andReturn($this->statement);
48 |         $this->statement->shouldReceive('fetchColumn')->with()
49 |             ->once()->andReturn(42);
50 | 
51 |         $fetcher->count();
52 |     }
53 | 
54 |     /** @test */
55 |     public function fetchesAfterCount()
56 |     {
57 |         /** @var EntityFetcher $fetcher */
58 |         $fetcher = $this->em->fetch(StudlyCaps::class);
59 |         // we change column and modifier here
60 |         $fetcher->count();
61 | 
62 |         // if we not reset it will execute a count query again and the count query will not fail
63 |         self::expectException(\PDOException::class);
64 |         self::expectExceptionMessage('Query failed by default');
65 | 
66 |         $fetcher->one();
67 |     }
68 | 
69 |     /** @test */
70 |     public function convertsResultToInt()
71 |     {
72 |         /** @var EntityFetcher $fetcher */
73 |         $fetcher = $this->em->fetch(StudlyCaps::class);
74 |         $this->statement->shouldReceive('fetchColumn')->with()
75 |             ->once()->andReturn('42');
76 | 
77 |         $result = $fetcher->count();
78 | 
79 |         self::assertSame(42, $result);
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/tests/EntityFetcher/EagerLoadTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\EntityFetcher;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\EntityFetcher;
 7 | use ORM\Test\Entity\Examples\User;
 8 | use ORM\Test\TestCase;
 9 | 
10 | class EagerLoadTest extends TestCase
11 | {
12 |     /** @test */
13 |     public function eagerLoadsRelationsAfterExecution()
14 |     {
15 |         /** @var EntityFetcher|m\MockInterface $fetcher */
16 |         $fetcher = m::mock(EntityFetcher::class, [$this->em, User::class])->makePartial();
17 |         $fetcher->shouldReceive('one')->times(3)->andReturn(
18 |             $user1 = new User(['id' => 1]),
19 |             $user2 = new User(['id' => 2]),
20 |             null
21 |         );
22 | 
23 |         $this->em->shouldReceive('eagerLoad')->with('articles.categories', $user1, $user2)->once();
24 | 
25 |         $fetcher->with('articles.categories');
26 |         $fetcher->all();
27 |     }
28 | 
29 |     /** @test */
30 |     public function eagerLoadsAllDefinedRelations()
31 |     {
32 |         /** @var EntityFetcher|m\MockInterface $fetcher */
33 |         $fetcher = m::mock(EntityFetcher::class, [$this->em, User::class])->makePartial();
34 |         $fetcher->shouldReceive('one')->times(3)->andReturn(
35 |             $user1 = new User(['id' => 1]),
36 |             $user2 = new User(['id' => 2]),
37 |             null
38 |         );
39 | 
40 |         $this->em->shouldReceive('eagerLoad')->with('articles', $user1, $user2)->once()->ordered();
41 |         $this->em->shouldReceive('eagerLoad')->with('articles.categories', $user1, $user2)->once()->ordered();
42 |         $this->em->shouldReceive('eagerLoad')->with('contact', $user1, $user2)->once()->ordered();
43 | 
44 |         $fetcher->with('articles', 'articles.categories');
45 |         $fetcher->with('contact')->all();
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/tests/EntityFetcher/Examples/NotDeletedFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\EntityFetcher\Examples;
 4 | 
 5 | use ORM\EntityFetcher;
 6 | use ORM\EntityFetcher\FilterInterface;
 7 | 
 8 | class NotDeletedFilter implements FilterInterface
 9 | {
10 |     public function apply(EntityFetcher $fetcher)
11 |     {
12 |         $fetcher->where('deleted IS NULL');
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/EntityFetcher/ExecutesQueriesTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\EntityFetcher;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\Test\Entity\Examples\Article;
 7 | use ORM\Test\TestCase;
 8 | 
 9 | class ExecutesQueriesTest extends TestCase
10 | {
11 |     /** @test */
12 |     public function updateTranslatesColumnNames()
13 |     {
14 |         $fetcher = $this->em->fetch(Article::class)->where('someColumn', 42);
15 | 
16 |         $this->pdo->shouldReceive('query')
17 |             ->with('UPDATE "article" AS t0 SET "any_column" = \'foo bar\' WHERE "t0"."some_column" = 42')
18 |             ->once()->andReturn($statement = m::mock(\PDOStatement::class));
19 |         $statement->shouldReceive('rowCount')->once()->andReturn(3);
20 | 
21 |         $fetcher->update(['anyColumn' => 'foo bar']);
22 |     }
23 | 
24 |     /** @test */
25 |     public function updateUsesAllWhereConditions()
26 |     {
27 |         $fetcher = $this->em->fetch(Article::class)->where('col1', 42)->where('col2', 23);
28 | 
29 |         $this->pdo->shouldReceive('query')
30 |             ->with('UPDATE "article" AS t0 SET "col3" = \'foo bar\' WHERE "t0"."col1" = 42 AND "t0"."col2" = 23')
31 |             ->once()->andReturn($statement = m::mock(\PDOStatement::class));
32 |         $statement->shouldReceive('rowCount')->once()->andReturn(3);
33 | 
34 |         $fetcher->update(['col3' => 'foo bar']);
35 |     }
36 | 
37 |     /** @test */
38 |     public function insertTranslatesColumnNames()
39 |     {
40 |         $fetcher = $this->em->fetch(Article::class);
41 | 
42 |         $this->pdo->shouldReceive('query')
43 |             ->with('INSERT INTO "article" ("first_column","second_column") VALUES (\'foo bar\',NULL),(NULL,42)')
44 |             ->once()->andReturn($statement = m::mock(\PDOStatement::class));
45 |         $statement->shouldReceive('rowCount')->once()->andReturn(1);
46 | 
47 |         $fetcher->insert(['firstColumn' => 'foo bar'], ['secondColumn' => 42]);
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/tests/EntityManager/BulkInsertTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\EntityManager;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\BulkInsert;
 7 | use ORM\Test\Entity\Examples\Article;
 8 | use ORM\Test\Entity\Examples\Category;
 9 | use ORM\Test\TestCase;
10 | 
11 | class BulkInsertTest extends TestCase
12 | {
13 |     /** @var BulkInsert|m\Mock */
14 |     protected $bulkInsert;
15 | 
16 |     protected function setUp(): void
17 |     {
18 |         parent::setUp();
19 | 
20 |         $this->mocks['bulkInsert'] = $this->bulkInsert = m::mock(BulkInsert::class, [$this->dbal, Article::class])
21 |             ->makePartial();
22 |         $this->em->setBulkInsert(Article::class, $this->bulkInsert);
23 |     }
24 | 
25 |     /** @test */
26 |     public function createsABulkInsert()
27 |     {
28 |         $onSync = function ($synced) {
29 |         };
30 | 
31 |         $bulkInsert = $this->em->useBulkInserts(Category::class, false, 30, $onSync);
32 | 
33 |         self::assertEquals(new BulkInsert($this->dbal, Category::class, false, 30, $onSync), $bulkInsert);
34 |     }
35 | 
36 |     /** @test */
37 |     public function returnsExistingBulkInsert()
38 |     {
39 |         $bulkInsert = new BulkInsert($this->dbal, Article::class);
40 |         $this->em->setBulkInsert(Article::class, $bulkInsert);
41 | 
42 |         $result = $this->em->useBulkInserts(Article::class, false, 30);
43 | 
44 |         self::assertSame($bulkInsert, $result);
45 |     }
46 | 
47 |     /** @test */
48 |     public function insertAddsToBulkInsert()
49 |     {
50 |         $entity = new Article;
51 |         $this->bulkInsert->shouldReceive('add')->with($entity)
52 |             ->once();
53 | 
54 |         $this->em->insert($entity);
55 |     }
56 | 
57 |     /** @test */
58 |     public function insertOtherEntitiesNot()
59 |     {
60 |         $entity = new Category;
61 |         $this->bulkInsert->shouldNotReceive('add');
62 |         $this->dbal->shouldReceive('insertAndSyncWithAutoInc')->with($entity)
63 |             ->once()->andReturn($entity);
64 | 
65 |         $this->em->insert($entity);
66 |     }
67 | 
68 |     /** @test */
69 |     public function finishesBulkImport()
70 |     {
71 |         $synced = [new Article];
72 |         $this->bulkInsert->shouldReceive('finish')->with()
73 |             ->once()->andReturn($synced);
74 | 
75 |         $result = $this->em->finishBulkInserts(Article::class);
76 | 
77 |         self::assertSame($synced, $result);
78 |     }
79 | 
80 |     /** @test */
81 |     public function removesTheBulkImport()
82 |     {
83 |         $this->bulkInsert->shouldReceive('finish')->with()
84 |             ->once()->andReturn([]);
85 | 
86 |         $this->em->finishBulkInserts(Article::class);
87 | 
88 |         $entity = new Article;
89 |         $this->bulkInsert->shouldNotReceive('add');
90 |         $this->dbal->shouldReceive('insertAndSyncWithAutoInc')->with($entity)
91 |             ->once()->andReturn($entity);
92 | 
93 |         $this->em->insert($entity);
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/tests/EntityManager/DescribeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\EntityManager;
 4 | 
 5 | use ORM\Dbal\Column;
 6 | use ORM\Dbal\Table;
 7 | use ORM\Test\TestCase;
 8 | 
 9 | class DescribeTest extends TestCase
10 | {
11 |     /** @var Table */
12 |     protected $table;
13 | 
14 |     protected function setUp(): void
15 |     {
16 |         parent::setUp();
17 | 
18 |         $this->table = new Table([new Column($this->dbal, [
19 |             'column_name' => 'id',
20 |             'data_type' => 'int',
21 |             'column_default' => 'sequence(AUTO_INCREMENT)',
22 |             'is_nullable' => false
23 |         ])]);
24 |     }
25 | 
26 |     /** @test */
27 |     public function callsDescribeFromDbal()
28 |     {
29 |         $this->dbal->shouldReceive('describe')->with('db.table')->once()->andReturn($this->table);
30 | 
31 |         $description = $this->em->describe('db.table');
32 | 
33 |         self::assertSame($this->table, $description);
34 |     }
35 | 
36 |     /** @test */
37 |     public function remembersPreviousCalls()
38 |     {
39 |         $this->dbal->shouldReceive('describe')->with('db.table')->once()->andReturn($this->table);
40 |         $this->em->describe('db.table');
41 | 
42 |         $description = $this->em->describe('db.table');
43 | 
44 |         self::assertSame($this->table, $description);
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/tests/EntityManager/Examples/Concrete.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ORM\Test\EntityManager\Examples;
4 | 
5 | class Concrete extends Entity
6 | {
7 | 
8 | }
9 | 


--------------------------------------------------------------------------------
/tests/EntityManager/Examples/Entity.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ORM\Test\EntityManager\Examples;
4 | 
5 | abstract class Entity extends \ORM\Entity
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/tests/EntityManager/Examples/SubNamespace/Entity.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ORM\Test\EntityManager\Examples\SubNamespace;
4 | 
5 | class Entity extends \ORM\Entity
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/tests/EntityManager/Examples/Unspecified.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ORM\Test\EntityManager\Examples;
4 | 
5 | class Unspecified extends \ORM\Entity
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/tests/EntityManager/Examples/functions.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | use ORM\EntityManager;
4 | 
5 | function getLastEmInstance()
6 | {
7 |     return EntityManager::getInstance();
8 | }
9 | 


--------------------------------------------------------------------------------
/tests/EntityManager/GetInstanceTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\EntityManager;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\EM;
 7 | use ORM\Test\EntityManager\Examples\Concrete;
 8 | use ORM\Test\EntityManager\Examples\Entity;
 9 | use ORM\Test\EntityManager\Examples\Unspecified;
10 | use ORM\Test\TestEntityManager;
11 | use PHPUnit\Framework\TestCase;
12 | 
13 | class GetInstanceTest extends TestCase
14 | {
15 |     protected function tearDown(): void
16 |     {
17 |         parent::tearDown();
18 |         TestEntityManager::resetStaticsForTest();
19 |     }
20 | 
21 |     /** @test */
22 |     public function returnsTheLastCreatedEM()
23 |     {
24 |         $em = new EM();
25 |         $last = new EM();
26 | 
27 |         self::assertSame($last, EM::getInstance());
28 |     }
29 | 
30 |     /** @test */
31 |     public function returnsLastCreatedFromOutsiteClass()
32 |     {
33 |         require_once __DIR__ . '/Examples/functions.php';
34 |         $last = new EM();
35 | 
36 |         $em = getLastEmInstance();
37 | 
38 |         self::assertSame($last, $em);
39 |     }
40 | 
41 |     /** @test */
42 |     public function defineForNamespace()
43 |     {
44 |         $em = new EM();
45 | 
46 |         $em->defineForNamespace(Examples\SubNamespace::class);
47 | 
48 |         self::assertSame($em, EM::getInstance(Examples\SubNamespace\Entity::class));
49 |     }
50 | 
51 |     /** @test */
52 |     public function defineForParent()
53 |     {
54 |         $em = new EM();
55 | 
56 |         $em->defineForParent(Entity::class);
57 | 
58 |         self::assertSame($em, EM::getInstance(Concrete::class));
59 |     }
60 | 
61 |     /** @test */
62 |     public function returnsLastIfNotSpecified()
63 |     {
64 |         $em = new EM();
65 |         $em->defineForNamespace(Examples\SubNamespace::class);
66 |         $em = new EM();
67 |         $em->defineForParent(Entity::class);
68 |         $last = new EM();
69 | 
70 |         self::assertSame($last, EM::getInstance(Unspecified::class));
71 |     }
72 | 
73 |     /** @test */
74 |     public function usesTheResolverProvided()
75 |     {
76 |         $em = new EM();
77 |         $spy = m::spy(function ($class = null) use ($em) {
78 |             return $em;
79 |         });
80 |         EM::setResolver($spy);
81 | 
82 |         $spy->shouldReceive('__invoke')->with(Concrete::class)->once()->andReturn($em);
83 | 
84 |         self::assertSame($em, EM::getInstance(Concrete::class));
85 |     }
86 | 
87 |     /** @test */
88 |     public function registeringNameSpaceHasNoEffectAfterReceivingInstance()
89 |     {
90 |         $em1 = new EM();
91 |         EM::getInstance(Examples\Concrete::class);
92 | 
93 |         $em2 = new EM();
94 |         $em2->defineForNamespace(Examples::class);
95 | 
96 |         self::assertSame($em1, EM::getInstance(Examples\Concrete::class));
97 |     }
98 | }
99 | 


--------------------------------------------------------------------------------
/tests/Examples/AuditObserver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Examples;
 4 | 
 5 | use ORM\Event;
 6 | use ORM\Observer\AbstractObserver;
 7 | 
 8 | class AuditObserver extends AbstractObserver
 9 | {
10 |     public $log = [];
11 | 
12 |     public function fetched(Event\Fetched $event)
13 |     {
14 |         $this->writeLog($event);
15 |     }
16 | 
17 |     public function inserted(Event\Inserted $event)
18 |     {
19 |         $this->writeLog($event, $event->entity->toArray());
20 |     }
21 | 
22 |     public function updated(Event\Updated $event)
23 |     {
24 |         $this->writeLog($event, $event->dirty);
25 |     }
26 | 
27 |     public function deleted(Event\Deleted $event)
28 |     {
29 |         $this->writeLog($event);
30 |     }
31 | 
32 |     protected function writeLog(Event $event, array $data = null)
33 |     {
34 |         $class = get_class($event->entity);
35 | 
36 |         if (!isset($this->log[$class])) {
37 |             $this->log[$class] = [];
38 |         }
39 | 
40 |         $this->log[$class][] = [
41 |             'action' => $event::NAME,
42 |             'key' => $event->entity->hasPrimaryKey() ? $event->entity->getPrimaryKey() : null,
43 |             'data' => $data,
44 |         ];
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/tests/Examples/CustomEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Examples;
 4 | 
 5 | use ORM\Event;
 6 | 
 7 | class CustomEvent extends Event
 8 | {
 9 |     const NAME = 'anything';
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/Examples/DateTimeDerivate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Examples;
 4 | 
 5 | use DateTimeZone;
 6 | 
 7 | class DateTimeDerivate extends \DateTime
 8 | {
 9 |     /**
10 |      * @param string $format
11 |      * @param string $time
12 |      * @param DateTimeZone|null $timezone
13 |      * @return static
14 |      */
15 |     public static function createFromFormat($format, $time, $timezone = null)
16 |     {
17 |         $dt = $timezone === null ? 
18 |           parent::createFromFormat($format, $time) :
19 |           parent::createFromFormat($format, $time, $timezone);
20 |         return new static($dt->format('Y-m-d H:i:s.u'), $dt->getTimezone());
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/tests/ExceptionsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test;
 4 | 
 5 | use ORM\Exception;
 6 | 
 7 | class ExceptionsTest extends TestCase
 8 | {
 9 |     public function provideExceptionClasses()
10 |     {
11 |         exec('find "' . __DIR__ . '/../src" -type f -wholename "*Exception/*.php"', $exceptionFiles);
12 |         $exceptionClasses = [];
13 |         foreach ($exceptionFiles as $exceptionFile) {
14 |             $class = 'ORM\\' . str_replace(
15 |                 ['/', '.php'],
16 |                 ['\\', ''],
17 |                 substr($exceptionFile, strlen(__DIR__ . '/../src/'))
18 |             );
19 | 
20 |             $exceptionClasses[] = $class;
21 |         }
22 |         return array_map(function ($exceptionClass) {
23 |             return [$exceptionClass];
24 |         }, $exceptionClasses);
25 |     }
26 | 
27 |     /**
28 |      * lets see if every exception is really a \Exception
29 |      *
30 |      * @dataProvider provideExceptionClasses
31 |      * @test */
32 |     public function exceptionsAreExceptions($exceptionClass)
33 |     {
34 |         $exception = new $exceptionClass('No exception');
35 | 
36 |         self::assertInstanceOf(\Exception::class, $exception);
37 |     }
38 | 
39 |     /**
40 |      * les see if every exception extends Exception for easier handling
41 |      *
42 |      * You can just catch every ORM\Exception\Exception if you need to.
43 |      *
44 |      * @dataProvider provideExceptionClasses
45 |      * @test */
46 |     public function exceptionsExtendBase($exceptionClass)
47 |     {
48 |         $exception = new $exceptionClass('No exception');
49 | 
50 |         self::assertInstanceOf(Exception::class, $exception);
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/tests/Observer/AbstractObserverTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Observer;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\Event\Fetched;
 7 | use ORM\Event\Saving;
 8 | use ORM\Test\Entity\Examples\Article;
 9 | use ORM\Test\Examples\AuditObserver;
10 | use ORM\Test\TestCase;
11 | 
12 | class AbstractObserverTest extends TestCase
13 | {
14 |     /** @test */
15 |     public function callsEventMethodIfAvailable()
16 |     {
17 |         $observer = m::mock(AuditObserver::class)->makePartial();
18 |         $event = new Fetched(new Article(), ['id' => 1, 'title' => 'Foo Bar']);
19 | 
20 |         $observer->shouldReceive('fetched')->once()->andReturnFalse();
21 | 
22 |         $result = $observer->handle($event);
23 | 
24 |         self::assertFalse($result);
25 |     }
26 | 
27 |     /** @test */
28 |     public function returnsTrueWhenNoMethodIsDefined()
29 |     {
30 |         $observer = new AuditObserver();
31 |         $event = new Saving(new Article());
32 | 
33 |         $result = $observer->handle($event);
34 | 
35 |         self::assertTrue($result);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/Observer/FireEventTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Observer;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\Event;
 7 | use ORM\Observer\AbstractObserver;
 8 | use ORM\Test\Entity\Examples\Article;
 9 | use ORM\Test\TestCase;
10 | 
11 | class FireEventTest extends TestCase
12 | {
13 |     /** @test */
14 |     public function returnsTrueWithoutObservers()
15 |     {
16 |         $event = new Event\Fetched(new Article(), ['title' => 'Foo']);
17 | 
18 |         $result = $this->em->fire($event);
19 | 
20 |         self::assertTrue($result);
21 |     }
22 | 
23 |     /** @test */
24 |     public function returnsTrueWhenTheObserverReturnsNull()
25 |     {
26 |         $event = new Event\Fetched(new Article(), ['title' => 'Foo']);
27 |         $observer = m::mock(AbstractObserver::class);
28 |         $this->em->observe(Article::class, $observer);
29 | 
30 |         $observer->shouldReceive('handle')->once()->andReturnNull();
31 | 
32 |         $result = $this->em->fire($event);
33 | 
34 |         self::assertTrue($result);
35 |     }
36 | 
37 |     /** @test */
38 |     public function returnsFalseWhenTheObserverReturnsFalse()
39 |     {
40 |         $event = new Event\Fetched(new Article(), ['title' => 'Foo']);
41 |         $observer = m::mock(AbstractObserver::class);
42 |         $this->em->observe(Article::class, $observer);
43 | 
44 |         $observer->shouldReceive('handle')->once()->andReturnFalse();
45 | 
46 |         $result = $this->em->fire($event);
47 | 
48 |         self::assertFalse($result);
49 |     }
50 | 
51 |     /** @test */
52 |     public function stopsWhenAnObserverReturnsFalse()
53 |     {
54 |         $event = new Event\Fetched(new Article(), ['title' => 'Foo']);
55 |         $observer = m::mock(AbstractObserver::class);
56 |         $this->em->observe(Article::class, $observer);
57 |         $observer2 = m::mock(AbstractObserver::class);
58 |         $this->em->observe(Article::class, $observer2);
59 | 
60 |         $observer->shouldReceive('handle')->once()->andReturnFalse();
61 |         $observer2->shouldNotReceive('handle');
62 | 
63 |         $this->em->fire($event);
64 |     }
65 | 
66 |     /** @test */
67 |     public function stopsWhenAnObserverStopsTheEvent()
68 |     {
69 |         $event = new Event\Fetched(new Article(), ['title' => 'Foo']);
70 |         $observer = m::mock(AbstractObserver::class);
71 |         $this->em->observe(Article::class, $observer);
72 |         $observer2 = m::mock(AbstractObserver::class);
73 |         $this->em->observe(Article::class, $observer2);
74 | 
75 |         $observer->shouldReceive('handle')->once()->andReturnUsing(function (Event\Fetched $event) {
76 |             $event->stop();
77 |         });
78 |         $observer2->shouldNotReceive('handle');
79 | 
80 |         $this->em->fire($event);
81 |     }
82 | 
83 |     /** @test */
84 |     public function doesNotCauseANoticeWhenNoObserverIsDefined()
85 |     {
86 |         $spy = m::spy(function ($error) {
87 |         });
88 |         set_error_handler($spy);
89 |         $spy->shouldNotReceive('__invoke');
90 | 
91 |         $event = new Event\Fetched(new Article(), ['title' => 'Foo']);
92 |         $this->em->fire($event);
93 |     }
94 | }
95 | 


--------------------------------------------------------------------------------
/tests/QueryBuilder/FetchTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\QueryBuilder;
 4 | 
 5 | use Mockery as m;
 6 | use ORM\Test\TestCase;
 7 | 
 8 | class FetchTest extends TestCase
 9 | {
10 |     /** @test */
11 |     public function returnsOneRow()
12 |     {
13 |         $query = $this->em->query('table');
14 |         $row = ['id' => 42, 'name' => 'foobar'];
15 | 
16 |         $this->pdo->shouldReceive('query')->with('SELECT * FROM table')
17 |             ->once()->andReturn($statement = m::mock(\PDOStatement::class));
18 |         $statement->shouldReceive('fetch')->with()->once()->andReturn($row);
19 | 
20 |         $result = $query->one();
21 | 
22 |         self::assertSame($row, $result);
23 |     }
24 | 
25 |     /** @test */
26 |     public function returnsAllRows()
27 |     {
28 |         $query = $this->em->query('table');
29 |         $row1 = ['id' => 42, 'name' => 'foobar'];
30 |         $row2 = ['id' => 23, 'name' => 'foo bar'];
31 | 
32 |         $this->pdo->shouldReceive('query')->with('SELECT * FROM table')
33 |             ->once()->andReturn($statement = m::mock(\PDOStatement::class));
34 |         $statement->shouldReceive('fetch')->with()->times(3)
35 |             ->andReturn($row1, $row2, false);
36 | 
37 |         $result = $query->all();
38 | 
39 |         self::assertSame([$row1, $row2], $result);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/tests/QueryBuilder/JoinTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ORM\Test\QueryBuilder;
  4 | 
  5 | use ORM\QueryBuilder\QueryBuilder;
  6 | use ORM\QueryBuilder\Parenthesis;
  7 | use ORM\Test\TestCase;
  8 | 
  9 | class JoinTest extends TestCase
 10 | {
 11 |     public function provideJoins()
 12 |     {
 13 |         return [
 14 |             ['join', 'JOIN'],
 15 |             ['leftJoin', 'LEFT JOIN'],
 16 |             ['rightJoin', 'RIGHT JOIN'],
 17 |             ['fullJoin', 'FULL JOIN']
 18 |         ];
 19 |     }
 20 | 
 21 |     /** @dataProvider provideJoins
 22 |      * @test */
 23 |     public function joinWithUsing($method, $sql)
 24 |     {
 25 |         $query = new QueryBuilder('foo');
 26 | 
 27 |         $result = call_user_func([$query, $method], 'bar', 'b_id', 'b');
 28 | 
 29 |         self::assertSame('SELECT * FROM foo ' . $sql . ' bar AS b USING (b_id)', $query->getQuery());
 30 |         self::assertSame($query, $result);
 31 |     }
 32 | 
 33 |     /** @dataProvider provideJoins
 34 |      * @test */
 35 |     public function joinWithExpression($method, $sql)
 36 |     {
 37 |         $query = new QueryBuilder('foo');
 38 | 
 39 |         $result = call_user_func([$query, $method], 'bar', 'bar_id = bar.id');
 40 | 
 41 |         self::assertSame('SELECT * FROM foo ' . $sql . ' bar ON bar_id = bar.id', $query->getQuery());
 42 |         self::assertSame($query, $result);
 43 |     }
 44 | 
 45 |     /** @dataProvider provideJoins
 46 |      * @test */
 47 |     public function joinWithExpressionAndArg($method, $sql)
 48 |     {
 49 |         $query = new QueryBuilder('foo');
 50 | 
 51 |         $result = call_user_func([$query, $method], 'bar', 'bar_id = bar.id AND bar.type = ?', '', 'pub');
 52 | 
 53 |         self::assertSame(
 54 |             'SELECT * FROM foo ' . $sql . ' bar ON bar_id = bar.id AND bar.type = \'pub\'',
 55 |             $query->getQuery()
 56 |         );
 57 |         self::assertSame($query, $result);
 58 |     }
 59 | 
 60 |     /** @dataProvider provideJoins
 61 |      * @test */
 62 |     public function joinWithExpressionAndArgs($method, $sql)
 63 |     {
 64 |         $query = new QueryBuilder('foo');
 65 | 
 66 |         $result = call_user_func([$query, $method], 'bar', 'bar.id = ? AND bar.type = ?', '', [42, 'pub']);
 67 | 
 68 |         self::assertSame(
 69 |             'SELECT * FROM foo ' . $sql . ' bar ON bar.id = 42 AND bar.type = \'pub\'',
 70 |             $query->getQuery()
 71 |         );
 72 |         self::assertSame($query, $result);
 73 |     }
 74 | 
 75 |     /** @dataProvider provideJoins
 76 |      * @test */
 77 |     public function joinWithParenthesis($method, $sql)
 78 |     {
 79 |         $query = new QueryBuilder('foo');
 80 | 
 81 |         /** @var Parenthesis $parenthesis */
 82 |         $parenthesis = call_user_func([$query, $method], 'bar', false);
 83 |         self::assertSame(Parenthesis::class, get_class($parenthesis));
 84 | 
 85 |         $parenthesis->where('bar_id = bar.id');
 86 |         $result = $parenthesis->close();
 87 | 
 88 |         self::assertSame('SELECT * FROM foo ' . $sql . ' bar ON (bar_id = bar.id)', $query->getQuery());
 89 |         self::assertSame($query, $result);
 90 |     }
 91 | 
 92 |     /** @dataProvider provideJoins
 93 |      * @test */
 94 |     public function emptyJoin($method, $sql)
 95 |     {
 96 |         $query = new QueryBuilder('foo');
 97 | 
 98 |         /** @var Parenthesis $parenthesis */
 99 |         $result = call_user_func([$query, $method], 'bar', true);
100 | 
101 | 
102 |         self::assertSame('SELECT * FROM foo ' . $sql . ' bar', $query->getQuery());
103 |         self::assertSame($query, $result);
104 |     }
105 | }
106 | 


--------------------------------------------------------------------------------
/tests/Relation/ParentChildrenTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Relation;
 4 | 
 5 | use ORM\Relation;
 6 | use ORM\Relation\ParentChildren;
 7 | use ORM\Test\Entity\Examples\Category;
 8 | use ORM\Test\TestCase;
 9 | 
10 | class ParentChildrenTest extends TestCase
11 | {
12 |     /** @test */
13 |     public function getsReturnedByGetRelation()
14 |     {
15 |         $result = Category::getRelation('children');
16 | 
17 |         self::assertInstanceOf(ParentChildren::class, $result);
18 |     }
19 | 
20 |     /** @test */
21 |     public function buildsATreeFromGivenEntities()
22 |     {
23 |         $entities = [
24 |             $category1 = new Category(['id' => 1, 'parent_id' => null, 'name' => 'Category 1']),
25 |             $category2 = new Category(['id' => 2, 'parent_id' => null, 'name' => 'Category 2']),
26 |             $category11 = new Category(['id' => 3, 'parent_id' => 1, 'name' => 'Category 1.1']),
27 |             $category12 = new Category(['id' => 4, 'parent_id' => 1, 'name' => 'Category 1.2']),
28 |             $category111 = new Category(['id' => 5, 'parent_id' => 3, 'name' => 'Category 1.1.1']),
29 |         ];
30 | 
31 |         $this->em->shouldNotReceive('fetch');
32 | 
33 |         $tree = Category::getRelation('children')->buildTree(...$entities);
34 | 
35 |         self::assertSame([$category1, $category2], $tree);
36 |         self::assertSame([$category11, $category12], $category1->children);
37 |         self::assertSame([$category111], $category11->children);
38 |     }
39 | 
40 |     /** @test */
41 |     public function canBeGeneratedFromAssocForm()
42 |     {
43 |         $relation = Relation::createRelation(Category::class, 'children', [
44 |             Relation::OPT_CLASS => Category::class,
45 |             Relation::OPT_OPPONENT => 'parent',
46 |         ]);
47 | 
48 |         self::assertInstanceOf(ParentChildren::class, $relation);
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/tests/TestEntity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test;
 4 | 
 5 | use ORM\Entity;
 6 | 
 7 | abstract class TestEntity extends Entity
 8 | {
 9 |     public static function resetStaticsForTest()
10 |     {
11 |         self::$namingSchemeTable = 'snake_lower';
12 |         self::$namingSchemeColumn = 'snake_lower';
13 |         self::$namingSchemeMethods = 'camelCase';
14 |         self::$tableNameTemplate = '%short%';
15 |         self::$reflections = [];
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/tests/TestEntityFetcher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test;
 4 | 
 5 | use ORM\EntityFetcher;
 6 | 
 7 | class TestEntityFetcher extends EntityFetcher
 8 | {
 9 |     public static function resetGlobalFiltersForTest($class = null)
10 |     {
11 |         if ($class) {
12 |             unset(static::$globalFilters[$class]);
13 |             return;
14 |         }
15 | 
16 |         static::$globalFilters = [];
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/tests/TestEntityManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test;
 4 | 
 5 | use ORM\BulkInsert;
 6 | use ORM\EntityManager;
 7 | 
 8 | class TestEntityManager extends EntityManager
 9 | {
10 |     public static function resetStaticsForTest()
11 |     {
12 |         static::$emMapping = [
13 |             'byClass' => [],
14 |             'byNameSpace' => [],
15 |             'byParent' => [],
16 |             'last' => null,
17 |         ];
18 | 
19 |         static::$resolver = null;
20 |     }
21 | 
22 |     public function setBulkInsert($class, BulkInsert $bulkInsert)
23 |     {
24 |         $this->bulkInserts[$class] = $bulkInsert;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/tests/Testing/CreateMockedEntityTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ORM\Test\Testing;
  4 | 
  5 | use Mockery as m;
  6 | use Mockery\Adapter\Phpunit\MockeryTestCase;
  7 | use Mockery\MockInterface;
  8 | use ORM\EntityManager;
  9 | use ORM\Exception;
 10 | use ORM\Test\Entity\Examples\Article;
 11 | use ORM\Test\Entity\Examples\Category;
 12 | use ORM\Test\TestEntityManager;
 13 | use ORM\Testing\MocksEntityManager;
 14 | 
 15 | class CreateMockedEntityTest extends MockeryTestCase
 16 | {
 17 |     use MocksEntityManager;
 18 | 
 19 |     /** @var EntityManager|MockInterface */
 20 |     protected $em;
 21 | 
 22 |     protected function setUp(): void
 23 |     {
 24 |         $this->em = $this->ormInitMock();
 25 |     }
 26 | 
 27 |     protected function tearDown(): void
 28 |     {
 29 |         m::close();
 30 |     }
 31 | 
 32 |     /** @test */
 33 |     public function throwsWithoutInitializing()
 34 |     {
 35 |         TestEntityManager::resetStaticsForTest();
 36 | 
 37 |         self::expectException(Exception::class);
 38 |         self::expectExceptionMessage('No entity manager initialized');
 39 | 
 40 |         $this->ormCreateMockedEntity(Article::class);
 41 |     }
 42 | 
 43 |     /** @test */
 44 |     public function throwsIfClassIsNotAnEntity()
 45 |     {
 46 |         self::expectException(Exception\NoEntity::class);
 47 |         self::expectExceptionMessage(' is not a subclass of Entity');
 48 | 
 49 |         $this->ormCreateMockedEntity(self::class);
 50 |     }
 51 | 
 52 |     /** @test */
 53 |     public function returnsTheEntity()
 54 |     {
 55 |         $article = $this->ormCreateMockedEntity(Article::class);
 56 | 
 57 |         self::assertInstanceOf(Article::class, $article);
 58 |     }
 59 | 
 60 |     /** @test */
 61 |     public function setsTheData()
 62 |     {
 63 |         $article = $this->ormCreateMockedEntity(Article::class, ['id' => 42, 'title' => 'Hello World!']);
 64 | 
 65 |         self::assertSame(42, $article->id);
 66 |         self::assertSame('Hello World!', $article->title);
 67 |     }
 68 | 
 69 |     /** @test */
 70 |     public function allowsUsingAttributeKeys()
 71 |     {
 72 |         $article = $this->ormCreateMockedEntity(Article::class, ['id' => 42, 'wordCount' => 3231]);
 73 | 
 74 |         self::assertSame(['id' => 42, 'word_count' => 3231], $article->getData());
 75 |         self::assertSame(3231, $article->wordCount);
 76 |     }
 77 | 
 78 |     /** @test */
 79 |     public function updateTheMock()
 80 |     {
 81 |         $article = $this->ormCreateMockedEntity(Article::class, ['id' => 42, 'title' => 'Hello World!']);
 82 |         $article->shouldReceive('save')->once();
 83 | 
 84 |         $this->updateEntity(Article::class, 42, ['title' => 'Don`t Panic!']);
 85 | 
 86 |         self::assertSame('Don`t Panic!', $article->title);
 87 |     }
 88 | 
 89 |     protected function updateEntity($class, $id, $data)
 90 |     {
 91 |         $entity = $this->em->fetch($class, $id);
 92 |         $entity->fill($data);
 93 |         $entity->save();
 94 |     }
 95 | 
 96 |     /** @test */
 97 |     public function allowsValidationInSetAttribute()
 98 |     {
 99 |         // Category has enabled validation
100 |         $entity = $this->ormCreateMockedEntity(Category::class, ['name' => 'Foo Bar']);
101 | 
102 |         $this->em->getConnection()->shouldNotReceive('query');
103 | 
104 |         // This would usually query the database to find the max length of name
105 |         $entity->name = 'This could be limited to 20 chars but here it is not...';
106 |     }
107 | }
108 | 


--------------------------------------------------------------------------------
/tests/Testing/ExpectDeleteTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Testing;
 4 | 
 5 | use Mockery as m;
 6 | use Mockery\Adapter\Phpunit\MockeryTestCase;
 7 | use ORM\EntityManager;
 8 | use ORM\Test\Entity\Examples\Article;
 9 | use ORM\Testing\MocksEntityManager;
10 | 
11 | class ExpectDeleteTest extends MockeryTestCase
12 | {
13 |     use MocksEntityManager;
14 | 
15 |     /** @var EntityManager|m\MockInterface */
16 |     protected $em;
17 | 
18 |     protected function setUp(): void
19 |     {
20 |         $this->em = $this->ormInitMock();
21 |     }
22 | 
23 |     protected function tearDown(): void
24 |     {
25 |         m::close();
26 |     }
27 | 
28 |     /** @test */
29 |     public function allowsDeleteOfEntity()
30 |     {
31 |         $article = $this->ormCreateMockedEntity(Article::class, ['id' => 42]);
32 | 
33 |         $this->ormExpectDelete($article);
34 | 
35 |         $this->deleteArticle(42);
36 |     }
37 | 
38 |     /** @test */
39 |     public function allowsDeleteOfClass()
40 |     {
41 |         $article = $this->ormCreateMockedEntity(Article::class, ['id' => 42]);
42 | 
43 |         $this->ormExpectDelete(Article::class);
44 | 
45 |         $this->deleteArticle(42);
46 |     }
47 | 
48 |     protected function deleteArticle($id)
49 |     {
50 |         $article = $this->em->fetch(Article::class, $id);
51 |         $this->em->delete($article);
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/tests/Testing/ExpectFetchTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Testing;
 4 | 
 5 | use Mockery\Adapter\Phpunit\MockeryTestCase;
 6 | use Mockery\MockInterface;
 7 | use ORM\EntityFetcher;
 8 | use ORM\EntityManager;
 9 | use ORM\Test\Entity\Examples\Article;
10 | use ORM\Test\Entity\Examples\Category;
11 | use ORM\Testing\MocksEntityManager;
12 | 
13 | class ExpectFetchTest extends MockeryTestCase
14 | {
15 |     use MocksEntityManager;
16 | 
17 |     /** @var EntityManager|MockInterface */
18 |     protected $em;
19 | 
20 |     protected function setUp(): void
21 |     {
22 |         $this->em = $this->ormInitMock();
23 |     }
24 | 
25 |     protected function tearDown(): void
26 |     {
27 |         \Mockery::close();
28 |     }
29 | 
30 |     /** @test */
31 |     public function returnsFetcher()
32 |     {
33 |         $fetcher = $this->ormExpectFetch(Article::class);
34 | 
35 |         self::assertInstanceOf(EntityFetcher::class, $fetcher);
36 | 
37 |         \Mockery::resetContainer();
38 |     }
39 | 
40 |     /** @test */
41 |     public function mocksFetch()
42 |     {
43 |         $fetcher = $this->ormExpectFetch(Article::class);
44 | 
45 |         self::assertSame($fetcher, $this->em->fetch(Article::class));
46 |     }
47 | 
48 |     /** @test */
49 |     public function returnsNull()
50 |     {
51 |         $this->ormExpectFetch(Article::class);
52 | 
53 |         $fetcher = $this->em->fetch(Article::class);
54 |         $result = $fetcher->one();
55 | 
56 |         self::assertNull($result);
57 |     }
58 | 
59 |     /** @test */
60 |     public function returnsEntities()
61 |     {
62 |         $articles = [new Article(), new Article()];
63 |         $this->ormExpectFetch(Article::class, $articles);
64 | 
65 |         $fetcher = $this->em->fetch(Article::class);
66 |         $result = $fetcher->all();
67 | 
68 |         self::assertSame($articles, $result);
69 |     }
70 | 
71 |     /** @test */
72 |     public function returnsCount()
73 |     {
74 |         $articles = [new Article(), new Article()];
75 |         $this->ormExpectFetch(Article::class, $articles);
76 | 
77 |         $fetcher = $this->em->fetch(Article::class);
78 |         $result = $fetcher->count();
79 | 
80 |         self::assertSame(2, $result);
81 |     }
82 | 
83 |     /** @test */
84 |     public function expectFetchOnEntity()
85 |     {
86 |         $categories = [new Category(), new Category()];
87 |         $article = $this->ormCreateMockedEntity(Article::class, ['id' => 42]);
88 |         $this->ormExpectFetch(Category::class, $categories);
89 | 
90 |         $fetcher = $article->fetch('categories');
91 |         $result = $fetcher->all();
92 | 
93 |         self::assertSame($categories, $result);
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/tests/Testing/ExpectInsertTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ORM\Test\Testing;
 4 | 
 5 | use Mockery\Adapter\Phpunit\MockeryTestCase;
 6 | use Mockery\MockInterface;
 7 | use ORM\EntityManager;
 8 | use ORM\Test\Entity\Examples\Article;
 9 | use ORM\Test\Entity\Examples\Category;
10 | use ORM\Testing\MocksEntityManager;
11 | 
12 | class ExpectInsertTest extends MockeryTestCase
13 | {
14 |     use MocksEntityManager;
15 | 
16 |     /** @var EntityManager|MockInterface */
17 |     protected $em;
18 | 
19 |     protected function setUp(): void
20 |     {
21 |         $this->em = $this->ormInitMock();
22 |     }
23 | 
24 |     protected function tearDown(): void
25 |     {
26 |         \Mockery::close();
27 |     }
28 | 
29 |     /** @test */
30 |     public function allowsInsertOfSpecifiedClass()
31 |     {
32 |         $this->ormExpectInsert(Article::class, ['id' => 42]);
33 |         $article = new Article();
34 | 
35 |         $article->save();
36 |     }
37 | 
38 |     /** @test */
39 |     public function doesNotAllowInsertsOfOtherClasses()
40 |     {
41 |         $this->ormExpectInsert(Category::class);
42 |         $article = new Article();
43 | 
44 |         self::expectException(\BadMethodCallException::class);
45 |         self::expectExceptionMessage('but no expectations were specified');
46 | 
47 |         try {
48 |             $article->save();
49 |         } catch (\Exception $e) {
50 |             \Mockery::resetContainer();
51 |             throw $e;
52 |         }
53 |     }
54 | 
55 |     /** @test */
56 |     public function setsDefaultData()
57 |     {
58 |         $defaults = ['id' => 42, 'created' => date('c')];
59 |         $this->ormExpectInsert(Article::class, $defaults);
60 |         $article = new Article();
61 | 
62 |         $article->save();
63 | 
64 |         self::assertSame($defaults, $article->getData());
65 |     }
66 | 
67 |     /** @test */
68 |     public function doesNotOverwriteCurrentData()
69 |     {
70 |         $defaults = ['id' => 42, 'created' => date('c')];
71 |         $this->ormExpectInsert(Article::class, $defaults);
72 |         $article = new Article();
73 | 
74 |         $article->id = 1337;
75 |         $article->created = date('c', strtotime('-1 Hour'));
76 |         $article->save();
77 | 
78 |         self::assertNotEquals($defaults, $article->getData());
79 |     }
80 | 
81 |     /** @test */
82 |     public function emulatesAutoIncrementWithRandomValue()
83 |     {
84 |         $this->ormExpectInsert(Article::class);
85 |         $article = new Article();
86 | 
87 |         $article->save();
88 | 
89 |         self::assertGreaterThan(0, $article->id);
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/tests/Testing/ExpectUpdateTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ORM\Test\Testing;
  4 | 
  5 | use Mockery as m;
  6 | use Mockery\Adapter\Phpunit\MockeryTestCase;
  7 | use ORM\EntityManager;
  8 | use ORM\Test\Entity\Examples\Article;
  9 | use ORM\Testing\MocksEntityManager;
 10 | 
 11 | class ExpectUpdateTest extends MockeryTestCase
 12 | {
 13 |     use MocksEntityManager;
 14 | 
 15 |     /** @var EntityManager|m\MockInterface */
 16 |     protected $em;
 17 | 
 18 |     protected function setUp(): void
 19 |     {
 20 |         $this->em = $this->ormInitMock();
 21 |     }
 22 | 
 23 |     protected function tearDown(): void
 24 |     {
 25 |         m::close();
 26 |     }
 27 | 
 28 |     /** @test */
 29 |     public function expectsSave()
 30 |     {
 31 |         $article = $this->ormCreateMockedEntity(Article::class, ['id' => 42]);
 32 |         $this->ormExpectUpdate($article);
 33 | 
 34 |         self::expectException(m\Exception\InvalidCountException::class);
 35 | 
 36 |         m::close();
 37 |     }
 38 | 
 39 |     /** @test */
 40 |     public function doesNotEmulateUpdateWhenNotDirty()
 41 |     {
 42 |         $article = $this->ormCreateMockedEntity(Article::class, ['id' => 42]);
 43 |         $this->ormExpectUpdate($article);
 44 | 
 45 |         $article->shouldNotReceive('preUpdate');
 46 | 
 47 |         $this->updateEntity(Article::class, 42);
 48 |     }
 49 | 
 50 |     /** @test */
 51 |     public function updatesTheDataFromDatabase()
 52 |     {
 53 |         $article = $this->ormCreateMockedEntity(Article::class, ['id' => 42, 'title' => 'Hello World!']);
 54 |         $this->ormExpectUpdate($article, [], ['title' => 'Don`t Panic!']);
 55 | 
 56 |         $article->shouldNotReceive('preUpdate');
 57 | 
 58 |         $this->updateEntity(Article::class, 42, ['title' => 'Don`t Panic!']);
 59 |     }
 60 | 
 61 |     /** @test */
 62 |     public function emulatesUpdate()
 63 |     {
 64 |         $article = $this->ormCreateMockedEntity(Article::class, [
 65 |             'id' => 42,
 66 |             'title' => 'Hello World!',
 67 |             'changed' => date('c', strtotime('-1 Hour')),
 68 |         ]);
 69 |         $changingData = ['changed' => date('c')];
 70 |         $this->ormExpectUpdate($article, $changingData);
 71 | 
 72 |         $article->shouldReceive('preUpdate')->once()->ordered()->passthru();
 73 |         $article->shouldReceive('setOriginalData')->with(m::subset(array_merge(
 74 |             $article->getData(),
 75 |             ['title' => 'Don`t Panic!'],
 76 |             $changingData
 77 |         )))->once()->ordered()->passthru();
 78 |         $article->shouldReceive('reset')->once()->ordered()->passthru();
 79 |         $article->shouldReceive('postUpdate')->once()->ordered()->passthru();
 80 | 
 81 |         $this->updateEntity(Article::class, 42, ['title' => 'Don`t Panic!']);
 82 | 
 83 | //        self::assertSame($changingData['changed'], $article->changed);
 84 |     }
 85 | 
 86 |     /**
 87 |      * Update an entity with $data
 88 |      *
 89 |      * @param string $class
 90 |      * @param int    $id
 91 |      * @param array  $data
 92 |      */
 93 |     protected function updateEntity($class, $id, $data = [])
 94 |     {
 95 |         $entity = $this->em->fetch($class, $id);
 96 |         $entity->fill($data);
 97 |         $entity->save();
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/tests/Testing/InitMockTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ORM\Test\Testing;
  4 | 
  5 | use Mockery\MockInterface;
  6 | use ORM\EntityManager;
  7 | use ORM\Exception\NoEntity;
  8 | use ORM\Test\Entity\Examples\Article;
  9 | use ORM\Testing\EntityFetcherMock;
 10 | use ORM\Testing\MocksEntityManager;
 11 | use PHPUnit\Framework\TestCase;
 12 | 
 13 | class InitMockTest extends TestCase
 14 | {
 15 |     use MocksEntityManager;
 16 | 
 17 |     /** @test */
 18 |     public function returnsAnEntityManager()
 19 |     {
 20 |         $em = $this->ormInitMock();
 21 | 
 22 |         self::assertInstanceOf(EntityManager::class, $em);
 23 |     }
 24 | 
 25 |     /** @test */
 26 |     public function entityManagerIsAMock()
 27 |     {
 28 |         $em = $this->ormInitMock();
 29 | 
 30 |         self::assertInstanceOf(MockInterface::class, $em);
 31 |     }
 32 | 
 33 |     /** @test */
 34 |     public function setsOptions()
 35 |     {
 36 |         $em = $this->ormInitMock(['tableNameTemplate' => '%short%s']);
 37 | 
 38 |         self::assertSame('articles', $em->getNamer()->getTableName(Article::class));
 39 |     }
 40 | 
 41 |     /** @test */
 42 |     public function mocksConnection()
 43 |     {
 44 |         $em = $this->ormInitMock();
 45 |         $connection = $em->getConnection();
 46 | 
 47 |         self::assertInstanceOf(MockInterface::class, $em);
 48 |     }
 49 | 
 50 |     /** @test */
 51 |     public function mocksSetAttribute()
 52 |     {
 53 |         $em = $this->ormInitMock();
 54 |         $connection = $em->getConnection();
 55 | 
 56 |         $result = $connection->setAttribute(\PDO::ATTR_AUTOCOMMIT, true);
 57 | 
 58 |         self::assertTrue($result);
 59 |     }
 60 | 
 61 |     /** @test */
 62 |     public function mocksDriverName()
 63 |     {
 64 |         $em = $this->ormInitMock([], 'mssql');
 65 |         $connection = $em->getConnection();
 66 | 
 67 |         $result = $connection->getAttribute(\PDO::ATTR_DRIVER_NAME);
 68 | 
 69 |         self::assertSame('mssql', $result);
 70 |     }
 71 | 
 72 |     /** @test */
 73 |     public function mocksQuote()
 74 |     {
 75 |         $em = $this->ormInitMock();
 76 |         $connection = $em->getConnection();
 77 | 
 78 |         $result = $connection->quote('Wayne\'s World!');
 79 | 
 80 |         self::assertSame('\'Wayne\\\'s World!\'', $result);
 81 |     }
 82 | 
 83 |     /** @test */
 84 |     public function createsAnEntityFetcherMock()
 85 |     {
 86 |         $em = $this->ormInitMock();
 87 | 
 88 |         $fetcher = $em->fetch(Article::class);
 89 | 
 90 |         self::assertInstanceOf(EntityFetcherMock::class, $fetcher);
 91 |     }
 92 | 
 93 |     /** @test */
 94 |     public function returnsMappedEntities()
 95 |     {
 96 |         $em = $this->ormInitMock();
 97 |         $em->map($original = new Article(['id' => 23]));
 98 | 
 99 |         $article = $em->fetch(Article::class, 23);
100 | 
101 |         self::assertSame($original, $article);
102 |     }
103 | 
104 |     /** @test */
105 |     public function returnsNullWithPrimaryKey()
106 |     {
107 |         $em = $this->ormInitMock();
108 | 
109 |         $article = $em->fetch(Article::class, 23);
110 | 
111 |         self::assertNull($article);
112 |     }
113 | 
114 |     /** @test */
115 |     public function throwsWhenTheClassIsNotAnEntity()
116 |     {
117 |         $em = $this->ormInitMock();
118 | 
119 |         self::expectException(NoEntity::class);
120 | 
121 |         $em->fetch(NoEntity::class);
122 |     }
123 | }
124 | 


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