├── .format_exclude
├── .gitignore
├── .phan
    └── config.php
├── .php_cs.dist
├── .travis.yml
├── CHANGELOG.md
├── COPYING
├── Makefile
├── README.md
├── RELEASE.md
├── bin
    ├── compile
    ├── package
    ├── profile.php
    ├── profilers
    │   ├── css-optimizer.php
    │   └── pcre-tokenizer.php
    ├── publish
    └── update-ca-certificates
├── composer.json
├── composer.lock
├── docker
    ├── entrypoint
    └── php74
├── package.json
├── phpunit.xml
├── src
    ├── Build
    │   ├── ASCIIPrettyPrinter.php
    │   ├── Compiler.php
    │   └── ScriptInliner.php
    ├── Cache
    │   ├── Cache.php
    │   └── Sqlite
    │   │   ├── Cache.php
    │   │   ├── Connection.php
    │   │   └── Manager.php
    ├── Common
    │   ├── Base64url.php
    │   ├── JSMinifier.php
    │   ├── JSON.php
    │   ├── ObjectifiedFunctions.php
    │   ├── OutputBufferHandler.php
    │   └── System.php
    ├── Diagnostics
    │   ├── Diagnostics.php
    │   ├── Status.php
    │   └── SystemDiagnostics.php
    ├── Environment
    │   ├── Configuration.php
    │   ├── DefaultConfiguration.php
    │   ├── Exceptions
    │   │   ├── PackageHasNoDiagnosticsException.php
    │   │   └── PackageHasNoFactoryException.php
    │   ├── Package.php
    │   ├── Switches.php
    │   └── config-default.php
    ├── Exceptions
    │   ├── CachedExceptionException.php
    │   ├── ItemNotFoundException.php
    │   ├── LogicException.php
    │   ├── RuntimeException.php
    │   ├── UnauthorizedException.php
    │   └── UndefinedObjectifiedFunction.php
    ├── Filters
    │   ├── CSS
    │   │   ├── CSSMinifier
    │   │   │   ├── Factory.php
    │   │   │   └── Filter.php
    │   │   ├── CSSURLRewriter
    │   │   │   ├── Factory.php
    │   │   │   └── Filter.php
    │   │   ├── CommentsRemoval
    │   │   │   └── Filter.php
    │   │   ├── Composite
    │   │   │   ├── Factory.php
    │   │   │   └── Filter.php
    │   │   ├── FontSwap
    │   │   │   ├── Factory.php
    │   │   │   └── Filter.php
    │   │   ├── ImageURLRewriter
    │   │   │   ├── Factory.php
    │   │   │   └── Filter.php
    │   │   └── ImportsStripper
    │   │   │   ├── Factory.php
    │   │   │   └── Filter.php
    │   ├── HTML
    │   │   ├── AMPCompatibleFilter.php
    │   │   ├── BaseHTMLStreamFilter.php
    │   │   ├── BaseURLSetter
    │   │   │   └── Filter.php
    │   │   ├── CSSInlining
    │   │   │   ├── Factory.php
    │   │   │   ├── Filter.php
    │   │   │   ├── Optimizer.php
    │   │   │   ├── OptimizerFactory.php
    │   │   │   ├── ie-fallback.js
    │   │   │   └── inlined-css-retriever.js
    │   │   ├── CommentsRemoval
    │   │   │   └── Filter.php
    │   │   ├── Composite
    │   │   │   ├── Factory.php
    │   │   │   └── Filter.php
    │   │   ├── DelayedIFrameLoading
    │   │   │   └── Filter.php
    │   │   ├── Diagnostics
    │   │   │   ├── Factory.php
    │   │   │   ├── Filter.php
    │   │   │   └── diagnostics.js
    │   │   ├── HTMLFilterFactory.php
    │   │   ├── HTMLPageContext.php
    │   │   ├── HTMLStreamFilter.php
    │   │   ├── Helpers
    │   │   │   └── JSDetectorTrait.php
    │   │   ├── ImagesOptimizationService
    │   │   │   ├── CSS
    │   │   │   │   ├── Factory.php
    │   │   │   │   └── Filter.php
    │   │   │   ├── ImageInliningManager.php
    │   │   │   ├── ImageInliningManagerFactory.php
    │   │   │   ├── ImageURLRewriter.php
    │   │   │   ├── ImageURLRewriterFactory.php
    │   │   │   └── Tags
    │   │   │   │   ├── Factory.php
    │   │   │   │   └── Filter.php
    │   │   ├── LazyImageLoading
    │   │   │   └── Filter.php
    │   │   ├── MetaCharset
    │   │   │   └── Filter.php
    │   │   ├── Minify
    │   │   │   └── Filter.php
    │   │   ├── MinifyScripts
    │   │   │   ├── Factory.php
    │   │   │   └── Filter.php
    │   │   ├── PhastScriptsCompiler
    │   │   │   ├── Factory.php
    │   │   │   ├── Filter.php
    │   │   │   ├── PhastJavaScriptCompiler.php
    │   │   │   ├── es6-promise.js
    │   │   │   ├── hash.js
    │   │   │   ├── phast.js
    │   │   │   ├── resources-loader.js
    │   │   │   ├── runner.js
    │   │   │   └── service-url.js
    │   │   ├── ScriptsDeferring
    │   │   │   ├── Factory.php
    │   │   │   ├── Filter.php
    │   │   │   ├── rewrite.js
    │   │   │   └── scripts-loader.js
    │   │   └── ScriptsProxyService
    │   │   │   ├── Factory.php
    │   │   │   ├── Filter.php
    │   │   │   └── rewrite-function.js
    │   ├── Image
    │   │   ├── CommonDiagnostics
    │   │   │   ├── DiagnosticsRetriever.php
    │   │   │   ├── kibo-logo.jpg
    │   │   │   └── kibo-logo.png
    │   │   ├── Composite
    │   │   │   ├── Factory.php
    │   │   │   └── Filter.php
    │   │   ├── Exceptions
    │   │   │   └── ImageProcessingException.php
    │   │   ├── Image.php
    │   │   ├── ImageAPIClient
    │   │   │   ├── Diagnostics.php
    │   │   │   ├── Factory.php
    │   │   │   └── Filter.php
    │   │   ├── ImageFactory.php
    │   │   ├── ImageFilter.php
    │   │   ├── ImageFilterFactory.php
    │   │   └── ImageImplementations
    │   │   │   ├── BaseImage.php
    │   │   │   ├── DefaultImage.php
    │   │   │   └── DummyImage.php
    │   ├── JavaScript
    │   │   └── Minification
    │   │   │   └── JSMinifierFilter.php
    │   ├── Service
    │   │   ├── CachedResultServiceFilter.php
    │   │   ├── CachingServiceFilter.php
    │   │   └── CompositeFilter.php
    │   └── Text
    │   │   └── Decode
    │   │       ├── Factory.php
    │   │       └── Filter.php
    ├── HTTP
    │   ├── CURLClient.php
    │   ├── Client.php
    │   ├── ClientFactory.php
    │   ├── Exceptions
    │   │   ├── HTTPError.php
    │   │   └── NetworkError.php
    │   ├── Request.php
    │   ├── Response.php
    │   └── cacert.pem
    ├── JSMin
    │   ├── JSMin.php
    │   ├── UnterminatedCommentException.php
    │   ├── UnterminatedRegExpException.php
    │   └── UnterminatedStringException.php
    ├── Logging
    │   ├── Common
    │   │   └── JSONLFileLogTrait.php
    │   ├── Log.php
    │   ├── LogEntry.php
    │   ├── LogLevel.php
    │   ├── LogReader.php
    │   ├── LogReaders
    │   │   └── JSONLFile
    │   │   │   └── Reader.php
    │   ├── LogWriter.php
    │   ├── LogWriters
    │   │   ├── BaseLogWriter.php
    │   │   ├── Composite
    │   │   │   ├── Factory.php
    │   │   │   └── Writer.php
    │   │   ├── Dummy
    │   │   │   └── Writer.php
    │   │   ├── Factory.php
    │   │   ├── JSONLFile
    │   │   │   ├── Factory.php
    │   │   │   └── Writer.php
    │   │   ├── PHPError
    │   │   │   ├── Factory.php
    │   │   │   └── Writer.php
    │   │   └── RotatingTextFile
    │   │   │   ├── Factory.php
    │   │   │   └── Writer.php
    │   ├── Logger.php
    │   └── LoggingTrait.php
    ├── Parsing
    │   └── HTML
    │   │   ├── HTMLInfo.php
    │   │   ├── HTMLStreamElements
    │   │       ├── ClosingTag.php
    │   │       ├── Comment.php
    │   │       ├── Element.php
    │   │       ├── Junk.php
    │   │       └── Tag.php
    │   │   └── PCRETokenizer.php
    ├── PhastDocumentFilters.php
    ├── PhastServices.php
    ├── Retrievers
    │   ├── CachingRetriever.php
    │   ├── DynamicCacheSaltTrait.php
    │   ├── LocalRetriever.php
    │   ├── PostDataRetriever.php
    │   ├── RemoteRetriever.php
    │   ├── RemoteRetrieverFactory.php
    │   ├── Retriever.php
    │   └── UniversalRetriever.php
    ├── Security
    │   ├── ServiceSignature.php
    │   └── ServiceSignatureFactory.php
    ├── Services
    │   ├── BaseService.php
    │   ├── Bundler
    │   │   ├── BundlerParamsParser.php
    │   │   ├── Factory.php
    │   │   ├── Service.php
    │   │   ├── ServiceParams.php
    │   │   ├── ShortBundlerParamsParser.php
    │   │   ├── TokenRefMaker.php
    │   │   └── TokenRefMakerFactory.php
    │   ├── Css
    │   │   ├── Factory.php
    │   │   └── Service.php
    │   ├── Diagnostics
    │   │   ├── Factory.php
    │   │   └── Service.php
    │   ├── Factory.php
    │   ├── Images
    │   │   ├── Factory.php
    │   │   └── Service.php
    │   ├── Scripts
    │   │   ├── Factory.php
    │   │   └── Service.php
    │   ├── ServiceFactoryTrait.php
    │   ├── ServiceFilter.php
    │   └── ServiceRequest.php
    ├── ValueObjects
    │   ├── PhastJavaScript.php
    │   ├── Query.php
    │   ├── Resource.php
    │   └── URL.php
    ├── bootstrap.php
    ├── config-user.php
    ├── html-filters.php
    └── services.php
├── test
    ├── bootstrap.php
    ├── browser
    │   ├── bundler.php
    │   ├── index.php
    │   ├── phast-config.php
    │   ├── phast.php
    │   ├── public
    │   │   ├── es6-promise.js
    │   │   ├── hash.js
    │   │   ├── resources-loader.js
    │   │   ├── scripts-loader.js
    │   │   └── service-url.js
    │   ├── qunit.css
    │   ├── qunit.js
    │   ├── res
    │   │   ├── .htaccess
    │   │   ├── python.png
    │   │   ├── script_proxy.js
    │   │   ├── stylesheet.css
    │   │   ├── stylesheet_import.css
    │   │   ├── stylesheet_large.css
    │   │   ├── text-1.txt
    │   │   ├── text-2.txt
    │   │   └── text-3.txt
    │   ├── tests.js
    │   └── tests
    │   │   ├── _.php
    │   │   ├── csp.js
    │   │   ├── csp.php
    │   │   ├── csp_report_only.js
    │   │   ├── csp_report_only.php
    │   │   ├── currentscript.js
    │   │   ├── currentscript.php
    │   │   ├── currentscript.script.js
    │   │   ├── currentscript_async.js
    │   │   ├── currentscript_async.js.php
    │   │   ├── currentscript_async.php
    │   │   ├── document_write.js
    │   │   ├── document_write.php
    │   │   ├── document_write_async.js
    │   │   ├── document_write_async.load.js
    │   │   ├── document_write_async.php
    │   │   ├── document_write_read.js
    │   │   ├── document_write_read.php
    │   │   ├── document_write_restore.js
    │   │   ├── document_write_restore.php
    │   │   ├── document_write_script.js
    │   │   ├── document_write_script.load.js
    │   │   ├── document_write_script.php
    │   │   ├── event_count.js
    │   │   ├── event_count.php
    │   │   ├── hello_world.js
    │   │   ├── hello_world.php
    │   │   ├── iframe.content.php
    │   │   ├── iframe.js
    │   │   ├── iframe.php
    │   │   ├── iframe_js.js
    │   │   ├── iframe_js.php
    │   │   ├── inline_js.js
    │   │   ├── inline_js.php
    │   │   ├── multiple_set_timeout_before_onload.js
    │   │   ├── multiple_set_timeout_before_onload.php
    │   │   ├── request_animation_frame_before_onload.js
    │   │   ├── request_animation_frame_before_onload.php
    │   │   ├── resources_loader.js
    │   │   ├── rewrite_image_in_inline_style.js
    │   │   ├── rewrite_image_in_inline_style.php
    │   │   ├── script_error_fallback.js
    │   │   ├── script_error_fallback.php
    │   │   ├── script_once.done.js
    │   │   ├── script_once.js
    │   │   ├── script_once.php
    │   │   ├── script_once.script.js
    │   │   ├── script_order.defer.js
    │   │   ├── script_order.js
    │   │   ├── script_order.php
    │   │   ├── script_order.script.php
    │   │   ├── script_proxy_dynamic.js
    │   │   ├── script_proxy_dynamic.module.js
    │   │   ├── script_proxy_dynamic.php
    │   │   ├── script_proxy_php.js
    │   │   ├── script_proxy_php.php
    │   │   ├── script_proxy_php_script.php
    │   │   ├── script_proxy_static.js
    │   │   ├── script_proxy_static.php
    │   │   ├── scripts_load_external_async.js
    │   │   ├── scripts_load_external_async.php
    │   │   ├── scripts_loader.js
    │   │   ├── set_timeout_args.js
    │   │   ├── set_timeout_args.php
    │   │   ├── stylesheet.js
    │   │   ├── stylesheet.php
    │   │   ├── stylesheet_before_script.js
    │   │   ├── stylesheet_before_script.php
    │   │   ├── stylesheet_external.js
    │   │   ├── stylesheet_external.php
    │   │   ├── stylesheet_import.js
    │   │   ├── stylesheet_import.php
    │   │   ├── stylesheet_large.js
    │   │   ├── stylesheet_large.php
    │   │   ├── stylesheet_php.js
    │   │   ├── stylesheet_php.php
    │   │   └── stylesheet_php_css.php
    ├── browserstack
    │   ├── .gitignore
    │   ├── run
    │   └── test.php
    ├── php
    │   ├── Cache
    │   │   └── Sqlite
    │   │   │   └── CacheTest.php
    │   ├── Common
    │   │   ├── ObjectifiedFunctionsTest.php
    │   │   ├── OutputBufferHandlerTest.php
    │   │   └── PhastServicesTest.php
    │   ├── Environment
    │   │   ├── ConfigurationTest.php
    │   │   ├── PackageTest.php
    │   │   ├── TestPackage1
    │   │   │   ├── Diagnostics.php
    │   │   │   └── Filter.php
    │   │   └── TestPackage2
    │   │   │   ├── Cache.php
    │   │   │   └── Factory.php
    │   ├── Filters
    │   │   ├── CSS
    │   │   │   ├── CSSMinifier
    │   │   │   │   └── FilterTest.php
    │   │   │   ├── CSSURLRewriter
    │   │   │   │   └── CSSURLRewriterTest.php
    │   │   │   ├── Composite
    │   │   │   │   └── FilterTest.php
    │   │   │   ├── FontSwap
    │   │   │   │   └── FilterTest.php
    │   │   │   └── ImportsStripper
    │   │   │   │   └── FilterTest.php
    │   │   ├── HTML
    │   │   │   ├── BaseURLSetter
    │   │   │   │   └── FilterTest.php
    │   │   │   ├── CSSInlining
    │   │   │   │   ├── FilterTest.php
    │   │   │   │   └── OptimizerTest.php
    │   │   │   ├── CommentsRemoval
    │   │   │   │   └── FilterTest.php
    │   │   │   ├── Composite
    │   │   │   │   └── FilterTest.php
    │   │   │   ├── DelayedIFrameLoading
    │   │   │   │   └── FilterTest.php
    │   │   │   ├── HTMLFilterTestCase.php
    │   │   │   ├── ImagesOptimizationService
    │   │   │   │   ├── CSS
    │   │   │   │   │   └── FilterTest.php
    │   │   │   │   ├── ImageInliningManagerTest.php
    │   │   │   │   ├── ImageURLRewriterTest.php
    │   │   │   │   └── Tags
    │   │   │   │   │   └── TagsFilterTest.php
    │   │   │   ├── MetaCharset
    │   │   │   │   └── FilterTest.php
    │   │   │   ├── Minify
    │   │   │   │   └── FilterTest.php
    │   │   │   ├── MinifyScripts
    │   │   │   │   └── FilterTest.php
    │   │   │   ├── PhastScriptsCompiler
    │   │   │   │   ├── FilterTest.php
    │   │   │   │   └── PhastJavaScriptCompilerTest.php
    │   │   │   ├── ScriptsDeferring
    │   │   │   │   └── FilterTest.php
    │   │   │   └── ScriptsProxyService
    │   │   │   │   └── FilterTest.php
    │   │   ├── Image
    │   │   │   └── Composite
    │   │   │   │   └── FilterTest.php
    │   │   ├── JavaScript
    │   │   │   └── Minification
    │   │   │   │   └── JSMinifierFilterTest.php
    │   │   ├── Service
    │   │   │   ├── CachingServiceFilterTest.php
    │   │   │   └── CompositeFilterTest.php
    │   │   └── Text
    │   │   │   └── Decode
    │   │   │       └── FilterTest.php
    │   ├── HTTP
    │   │   ├── CURLClientTest.php
    │   │   ├── DefaultConfigurationTest.php
    │   │   └── RequestTest.php
    │   ├── Logging
    │   │   ├── LogReaders
    │   │   │   └── JSONLFile
    │   │   │   │   └── ReaderTest.php
    │   │   ├── LogWriters
    │   │   │   ├── BaseLogWriterTest.php
    │   │   │   ├── Composite
    │   │   │   │   └── WriterTest.php
    │   │   │   ├── JSONLFile
    │   │   │   │   └── WriterTest.php
    │   │   │   ├── PHPError
    │   │   │   │   └── WriterTest.php
    │   │   │   └── RotatingTextFile
    │   │   │   │   └── WriterTest.php
    │   │   └── LoggerTest.php
    │   ├── Parsing
    │   │   └── HTML
    │   │   │   ├── HTMLStreamElements
    │   │   │       └── TagTest.php
    │   │   │   └── PCRETokenizerTest.php
    │   ├── PhastDocumentFiltersTest.php
    │   ├── PhastTestCase.php
    │   ├── Retrievers
    │   │   ├── LocalRetrieverTest.php
    │   │   └── PostDataRetrieverTest.php
    │   ├── Security
    │   │   └── ServiceSignatureTest.php
    │   ├── Services
    │   │   ├── Bundler
    │   │   │   ├── BundlerParamsParserTest.php
    │   │   │   ├── ServiceTest.php
    │   │   │   └── ShortBundlerParamsParserTest.php
    │   │   ├── Scripts
    │   │   │   └── ServiceTest.php
    │   │   └── ServiceRequestTest.php
    │   ├── ValueObjects
    │   │   ├── PhastJavaScriptTest.php
    │   │   ├── ResourceTest.php
    │   │   └── URLTest.php
    │   ├── build.php
    │   └── resources
    │   │   └── large.css
    └── test-app
    │   ├── css
    │       ├── .htaccess
    │       ├── styles.css
    │       ├── styles2.css
    │       └── stylesheet_large.css
    │   ├── images
    │       ├── .htaccess
    │       ├── basset.png
    │       ├── basset@2x.png
    │       ├── batman.jpg
    │       ├── batman@2x.jpg
    │       └── python.png
    │   ├── index.php
    │   ├── js
    │       ├── .htaccess
    │       ├── deferred.js
    │       ├── injected.js
    │       └── main.js
    │   ├── phast.php
    │   └── test-config.php
└── yarn.lock


/.format_exclude:
--------------------------------------------------------------------------------
1 | src/Filters/HTML/PhastScriptsCompiler/es6-promise.js
2 | src/Filters/HTML/PhastScriptsCompiler/hash.js
3 | test/browser/qunit.js
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 | /dist
3 | /docker/*.image
4 | /node_modules
5 | /.php_cs.cache
6 | /.phpunit.result.cache
7 | /vendor
8 | 


--------------------------------------------------------------------------------
/.phan/config.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     'directory_list' => [
 5 |         'src',
 6 |         'vendor',
 7 |     ],
 8 | 
 9 |     'exclude_analysis_directory_list' => [
10 |         'vendor',
11 |     ],
12 | ];
13 | 


--------------------------------------------------------------------------------
/.php_cs.dist:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $finder = PhpCsFixer\Finder::create()
 4 |     ->in(__DIR__ . '/src')
 5 |     ->exclude('JSMin')
 6 |     ->in(__DIR__ . '/test')
 7 | ;
 8 | 
 9 | return PhpCsFixer\Config::create()
10 |     ->setRules([
11 |         '@PSR1' => true,
12 |         '@PSR2' => true,
13 |         'array_syntax' => ['syntax' => 'short'],
14 |         'braces' => ['position_after_functions_and_oop_constructs' => 'same'],
15 |         'cast_spaces' => true,
16 |         'class_attributes_separation' => true,
17 |         'concat_space' => ['spacing' => 'one'],
18 |         'include' => true,
19 |         'new_with_braces' => true,
20 |         'no_superfluous_elseif' => true,
21 |         'no_unneeded_control_parentheses' => true,
22 |         'no_unused_imports' => true,
23 |         'no_useless_else' => true,
24 |         'no_useless_return' => true,
25 |         'no_whitespace_before_comma_in_array' => true,
26 |         'no_whitespace_in_blank_line' => true,
27 |         'ordered_imports' => true,
28 |         'return_assignment' => true,
29 |         'return_type_declaration' => true,
30 |         'single_quote' => true,
31 |         'trailing_comma_in_multiline_array' => true,
32 |         'trim_array_spaces' => true,
33 |     ])
34 |     ->setFinder($finder)
35 | ;
36 | 
37 | // vim: set ft=php :
38 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: php
2 | php:
3 |     - 5.6
4 |     - 7.0
5 |     - 7.1
6 |     - 7.2
7 | install:
8 |     - composer install
9 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | .DELETE_ON_ERROR :
 2 | 
 3 | PHP74 = docker run -v $(shell pwd):/data -w /data $(shell cat docker/php74.image)
 4 | JSMIN_SOURCES := $(wildcard vendor/kiboit/jsmin-php/src/JSMin/*.php)
 5 | JSMIN_TARGETS := $(patsubst vendor/kiboit/jsmin-php/src/%,src/%,$(JSMIN_SOURCES))
 6 | 
 7 | ifdef FILTER
 8 | PHPUNIT_ARGS := --filter="$(FILTER)"
 9 | endif
10 | 
11 | .PHONY : all
12 | all : build/phast.php
13 | 
14 | .PHONY : watch
15 | watch :
16 | 	git ls-files src test | entr -c -r $(MAKE) -s test74
17 | 
18 | .PHONY : test
19 | test : test74
20 | 
21 | .PHONY : test74
22 | test74 : all docker/php74.image
23 | 	$(PHP74) vendor/bin/phpunit $(PHPUNIT_ARGS)
24 | 
25 | .PHONY : test-local
26 | test-local : all
27 | 	vendor/bin/phpunit
28 | 
29 | .PHONY : dist
30 | dist : all
31 | 	bin/package
32 | 
33 | .PHONY : clean
34 | clean :
35 | 	rm -rf build docker/php74.image
36 | 
37 | .PHONY : format
38 | format : node_modules
39 | 	fd -g '*.js' -t f --ignore-file .format_exclude -X node_modules/.bin/prettier -w
40 | 
41 | 
42 | build/phast.php : vendor/autoload.php node_modules $(JSMIN_TARGETS) $(shell git ls-files src)
43 | 	bin/compile $(dir $@)
44 | 
45 | src/JSMin/% : vendor/kiboit/jsmin-php/src/JSMin/% | vendor/autoload.php
46 | 	@mkdir -p $(dir $@)
47 | 	cat $< | perl -p -e 's~(\bnamespace\s+)(?=JSMin\b)~$$1Kibo\\Phast\\~g' > $@
48 | 
49 | vendor/autoload.php : composer.json composer.lock
50 | 	composer install
51 | 	touch vendor/autoload.php
52 | 
53 | docker/%.image : docker/% docker/entrypoint
54 | 	docker build --pull --iidfile $@~ -f $< docker
55 | 	mv $@~ $@
56 | 
57 | node_modules : yarn.lock
58 | 	yarn
59 | 	touch $@
60 | 


--------------------------------------------------------------------------------
/RELEASE.md:
--------------------------------------------------------------------------------
 1 | # Release instructions
 2 | 
 3 | ## Phast
 4 | 
 5 | We follow semantic versioning. Did you only fix bugs, then increment the
 6 | patchlevel. Did you also add any new features, then increment the minor version
 7 | and reset the patchlevel. In case of breaking changes we will increment the
 8 | major version.
 9 | 
10 | Follow these steps to release a new version of Phast:
11 | 
12 | 1. Update the change log.
13 |     1. Make sure all important changes since the last release are mentioned.
14 |     1. Make sure the header links are set. (Version numbers link to GitHub log.)
15 | 1. Commit changelog.
16 | 1. Tag release: `git tag 1.5.0`
17 | 1. Push commits and tags: `git push --tags origin master`
18 | 1. Release PhastPress.
19 | 
20 | ## PhastPress
21 | 
22 | PhastPress versions follow those of Phast. If a change is made to PhastPress
23 | without an accompanying update of Phast itself, a letter is used to indicate the
24 | change. Eg, 1.5.1 → 1.5.1a.
25 | 


--------------------------------------------------------------------------------
/bin/compile:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env php
 2 | <?php
 3 | 
 4 | require_once __DIR__ . '/../vendor/autoload.php';
 5 | 
 6 | if (sizeof($argv) !== 2) {
 7 |     fwrite(STDERR, "Usage: {$argv[0]} <output>\n");
 8 |     exit(1);
 9 | }
10 | 
11 | Kibo\Phast\Build\Compiler::getPhastCompiler()->compile($argv[1]);
12 | 


--------------------------------------------------------------------------------
/bin/package:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -euo pipefail
 4 | cd "$(dirname "$0")"/..
 5 | 
 6 | release="$(git tag -l --points-at=HEAD | grep -P '^[0-9]\.' || :)"
 7 | if [[ $release = "" ]]; then
 8 |     release=HEAD
 9 | fi
10 | 
11 | tmp="$(mktemp -d)"
12 | trap "rm -rf '$tmp'" EXIT
13 | 
14 | mkdir -p dist
15 | 
16 | git archive HEAD composer.{json,lock} src certificates | tar xf - -C "$tmp"
17 | 
18 | (
19 |     cd "$tmp"
20 |     composer install -o --no-dev
21 |     rm -f composer.{json,lock}
22 |     find -not -name . -not -name .. -name '.*' -exec rm -r {} +
23 |     tar cJf - --xform 's/^\./phast/' .
24 | ) > dist/phast-$release.txz
25 | 
26 | echo dist/phast-$release.txz
27 | 


--------------------------------------------------------------------------------
/bin/profile.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | if (PHP_SAPI != 'cli') {
 4 |     fwrite(STDERR, "This script must be run from the command line.\n");
 5 |     exit(1);
 6 | }
 7 | 
 8 | if (sizeof($argv) != 3) {
 9 |     fwrite(STDERR, "Run a script that returns in callable inside a profiling loop for\n");
10 |     fwrite(STDERR, "the specified number of iterations.\n\n");
11 |     fwrite(STDERR, "Usage: {$argv[0]} <script> <iterations>\n");
12 |     exit(1);
13 | }
14 | 
15 | require_once __DIR__ . '/../vendor/autoload.php';
16 | 
17 | $file = $argv[1];
18 | $iterations = (int) $argv[2];
19 | 
20 | $callback = require_once $file;
21 | if (!is_callable($callback)) {
22 |     fwrite(STDERR, "$file did not return a callable\n");
23 |     exit(1);
24 | }
25 | 
26 | $profile = function_exists('tideways_xhprof_enable');
27 | 
28 | if (!$profile) {
29 |     fwrite(STDERR, "Warning: Tideways/XHProf extension is missing; not profiling...\n");
30 | }
31 | 
32 | if ($profile) {
33 |     tideways_xhprof_enable();
34 | }
35 | 
36 | $timeStart = microtime(true);
37 | for ($i = 0; $i < $iterations; $i++) {
38 |     $callback();
39 | }
40 | $timeEnd = microtime(true);
41 | 
42 | $timeElapsed = $timeEnd - $timeStart;
43 | fprintf(STDERR, "Ran %d iterations in %.4fs (%.4fs/iteration)\n", $iterations, $timeElapsed, $timeElapsed/$iterations);
44 | 
45 | if ($profile) {
46 |     echo serialize(tideways_xhprof_disable());
47 | }
48 | 


--------------------------------------------------------------------------------
/bin/profilers/css-optimizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Kibo\Phast\Cache\Sqlite\Cache;
 4 | use Kibo\Phast\Filters\HTML\CSSInlining\Optimizer;
 5 | 
 6 | return call_user_func(function () {
 7 |     $css = file_get_contents(__DIR__ . '/../../test/resources/large.css');
 8 | 
 9 |     $mocker = new PHPUnit_Framework_MockObject_Generator();
10 |     $cache = $mocker->getMock(Cache::class, [], [], '', false);
11 | 
12 |     $optimizer = new Optimizer(new \ArrayIterator([]), $cache);
13 | 
14 |     return Closure::bind(function () use ($css) {
15 |         $this->parseCSS($css);
16 |     }, $optimizer, $optimizer);
17 | });
18 | 


--------------------------------------------------------------------------------
/bin/profilers/pcre-tokenizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Kibo\Phast\Parsing\HTML\PCRETokenizer;
 4 | 
 5 | return call_user_func(function () {
 6 |     $data = file_get_contents(__DIR__ . '/../../test/test-app/example.php');
 7 | 
 8 |     return function () use ($data) {
 9 |         $tok = new PCRETokenizer();
10 |         $tokens = iterator_to_array($tok->tokenize($data));
11 |     };
12 | });
13 | 


--------------------------------------------------------------------------------
/bin/publish:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | 
3 | set -euo pipefail
4 | 
5 | git describe --tags --exact-match HEAD
6 | 
7 | git push git@github.com:kiboit/phast master --tags
8 | 


--------------------------------------------------------------------------------
/bin/update-ca-certificates:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -euo pipefail
 4 | cd "$(dirname "$0")/.."
 5 | 
 6 | file="src/HTTP/cacert.pem"
 7 | 
 8 | wget -O "$file~" "https://curl.haxx.se/ca/cacert.pem"
 9 | mv "$file~" "$file"
10 | 
11 | git commit -m "Update CA certificates" "$file"
12 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "kiboit/phast",
 3 |     "description": "A toolbox for optimizing web page performance",
 4 |     "type": "library",
 5 |     "license": "AGPL-3.0-or-later",
 6 |     "repositories": [
 7 |         {
 8 |             "type": "vcs",
 9 |             "url": "https://github.com/kiboit/jsmin-php"
10 |         }
11 |     ],
12 |     "require": {
13 |         "php": ">=7.2",
14 |         "ext-json": "*"
15 |     },
16 |     "require-dev": {
17 |         "facebook/webdriver": "^1.5",
18 |         "ext-dom": "*",
19 |         "friendsofphp/php-cs-fixer": "^2.16",
20 |         "kiboit/jsmin-php": "dev-master",
21 |         "nikic/php-parser": "^4.13",
22 |         "phpunit/phpunit": "^9.5"
23 |     },
24 |     "suggest": {
25 |         "nikic/php-parser": "Needed for compilation"
26 |     },
27 |     "autoload": {
28 |         "psr-4": {
29 |             "Kibo\\Phast\\": [
30 |                 "src/"
31 |             ]
32 |         }
33 |     },
34 |     "autoload-dev": {
35 |         "psr-4": {
36 |             "Kibo\\Phast\\": [
37 |                 "test/php/"
38 |             ]
39 |         }
40 |     },
41 |     "config": {
42 |         "platform": {
43 |             "php": "7.4"
44 |         }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/docker/entrypoint:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | set -eu
 4 | 
 5 | if [ -d /data ]; then
 6 |     usermod -u `stat -c %u /data` docker 2>&1 | grep -v '^usermod: no changes' || :
 7 | fi
 8 | 
 9 | sudo -u docker "$@"
10 | 


--------------------------------------------------------------------------------
/docker/php74:
--------------------------------------------------------------------------------
 1 | FROM alpine:3.15
 2 | 
 3 | RUN apk add --no-cache \
 4 |         shadow \
 5 |         sudo \
 6 |         php7 \
 7 |         php7-dom \
 8 |         php7-json \
 9 |         php7-mbstring \
10 |         php7-tokenizer \
11 |         php7-xml \
12 |         php7-xmlwriter \
13 |         php7-pdo_sqlite \
14 |         php7-posix
15 | 
16 | RUN useradd -m docker
17 | 
18 | COPY entrypoint /entrypoint
19 | ENTRYPOINT ["/bin/sh", "/entrypoint"]
20 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 |   "dependencies": {
3 |     "uglify-js": "^3.6.0"
4 |   },
5 |   "devDependencies": {
6 |     "prettier": "^2.3.2"
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <phpunit
 2 |     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 |     xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.5/phpunit.xsd"
 4 |     colors="true"
 5 |     bootstrap="test/bootstrap.php"
 6 | >
 7 |     <testsuites>
 8 |         <testsuite name="all">
 9 |             <directory>test/</directory>
10 |             <exclude>test/php/HTTP/CURLClientTest.php</exclude>
11 |         </testsuite>
12 |     </testsuites>
13 | </phpunit>
14 | 


--------------------------------------------------------------------------------
/src/Build/ASCIIPrettyPrinter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Build;
 3 | 
 4 | use PhpParser\PrettyPrinter;
 5 | 
 6 | class ASCIIPrettyPrinter extends PrettyPrinter\Standard {
 7 |     protected function escapeString($string, $quote) {
 8 |         if (null === $quote) {
 9 |             // For doc strings, don't escape newlines
10 |             $escaped = addcslashes($string, "\t\f\v$\\");
11 |         } else {
12 |             $escaped = addcslashes($string, "\n\r\t\f\v$" . $quote . '\\');
13 |         }
14 | 
15 |         // Escape other control characters
16 |         return preg_replace_callback('/([^\x20-\x7F])(?=([0-7]?))/', function ($matches) {
17 |             $oct = decoct(ord($matches[1]));
18 |             if ($matches[2] !== '') {
19 |                 // If there is a trailing digit, use the full three character form
20 |                 return '\\' . str_pad($oct, 3, '0', STR_PAD_LEFT);
21 |             }
22 |             return '\\' . $oct;
23 |         }, $escaped);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Cache/Cache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Cache;
 4 | 
 5 | interface Cache {
 6 |     /**
 7 |      * @param string $key
 8 |      * @param callable|null $cached
 9 |      * @param int $expiresIn
10 |      * @return mixed
11 |      */
12 |     public function get($key, callable $cached = null, $expiresIn = 0);
13 | 
14 |     /**
15 |      * @param string $key
16 |      * @param mixed $value
17 |      * @param int $expiresIn
18 |      * @return mixed
19 |      */
20 |     public function set($key, $value, $expiresIn = 0);
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Cache/Sqlite/Cache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Cache\Sqlite;
 4 | 
 5 | use Kibo\Phast\Cache\Cache as CacheInterface;
 6 | use Kibo\Phast\Common\ObjectifiedFunctions;
 7 | 
 8 | class Cache implements CacheInterface {
 9 |     private static $managers = [];
10 | 
11 |     private $cacheRoot;
12 | 
13 |     private $name;
14 | 
15 |     private $maxSize;
16 | 
17 |     private $namespace;
18 | 
19 |     private $functions;
20 | 
21 |     public function __construct(array $config, string $namespace, ObjectifiedFunctions $functions = null) {
22 |         $this->cacheRoot = (string) $config['cacheRoot'];
23 |         $this->name = (string) ($config['name'] ?? 'cache');
24 |         $this->maxSize = (int) $config['maxSize'];
25 |         $this->namespace = $namespace;
26 |         $this->functions = $functions ?? new ObjectifiedFunctions();
27 |     }
28 | 
29 |     public function get($key, callable $fn = null, $expiresIn = 0) {
30 |         return $this->getManager()->get($this->getKey($key), $fn, $expiresIn, $this->functions);
31 |     }
32 | 
33 |     private function getKey(string $key): string {
34 |         return $this->namespace . "\0" . $key;
35 |     }
36 | 
37 |     public function set($key, $value, $expiresIn = 0): void {
38 |         $this->getManager()->set($this->getKey($key), $value, $expiresIn, $this->functions);
39 |     }
40 | 
41 |     public function getManager(): Manager {
42 |         $key = $this->cacheRoot . '/' . $this->name;
43 |         if (!isset(self::$managers[$key])) {
44 |             self::$managers[$key] = new Manager($this->cacheRoot, $this->name, $this->maxSize);
45 |         }
46 |         return self::$managers[$key];
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Cache/Sqlite/Connection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Cache\Sqlite;
 4 | 
 5 | class Connection extends \PDO {
 6 |     private $statements;
 7 | 
 8 |     public function prepare($query, $options = null): \PDOStatement {
 9 |         if ($options) {
10 |             return parent::prepare($query, $options);
11 |         }
12 |         if (!isset($this->statements[$query])) {
13 |             $this->statements[$query] = parent::prepare($query);
14 |         }
15 |         return $this->statements[$query];
16 |     }
17 | 
18 |     public function getPageSize(): int {
19 |         return (int) $this->query('PRAGMA page_size')->fetchColumn();
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Common/Base64url.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Common;
 3 | 
 4 | class Base64url {
 5 |     public static function encode($data) {
 6 |         return rtrim(strtr(base64_encode($data), '+/', '-_'), '=');
 7 |     }
 8 | 
 9 |     public static function decode($data) {
10 |         return base64_decode(str_pad(strtr($data, '-_', '+/'), strlen($data) % 4, '=', STR_PAD_RIGHT));
11 |     }
12 | 
13 |     public static function shortHash($data) {
14 |         return self::encode(substr(sha1($data, true), 0, 8));
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Common/JSMinifier.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Common;
 3 | 
 4 | use Kibo\Phast\JSMin\JSMin;
 5 | 
 6 | class JSMinifier extends JSMin {
 7 |     protected $removeLicenseHeaders;
 8 | 
 9 |     public function __construct($input, $removeLicenseHeaders = false) {
10 |         parent::__construct($input);
11 |         $this->removeLicenseHeaders = $removeLicenseHeaders;
12 |     }
13 | 
14 |     protected function consumeMultipleLineComment() {
15 |         parent::consumeMultipleLineComment();
16 |         if ($this->removeLicenseHeaders) {
17 |             $this->keptComment = preg_replace('~/\*!.*?\*/~s', '', $this->keptComment);
18 |         }
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Common/ObjectifiedFunctions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Common;
 4 | 
 5 | use Kibo\Phast\Exceptions\UndefinedObjectifiedFunction;
 6 | 
 7 | class ObjectifiedFunctions {
 8 |     /**
 9 |      * @param string $name
10 |      * @param array $arguments
11 |      */
12 |     public function __call($name, array $arguments) {
13 |         if (isset($this->$name) && is_callable($this->$name)) {
14 |             $fn = $this->$name;
15 |             return $fn(...$arguments);
16 |         }
17 |         if (function_exists($name)) {
18 |             return $name(...$arguments);
19 |         }
20 |         throw new UndefinedObjectifiedFunction("Undefined objectified function $name");
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Common/System.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Common;
 4 | 
 5 | use Kibo\Phast\Exceptions\UndefinedObjectifiedFunction;
 6 | 
 7 | class System {
 8 |     private $functions;
 9 | 
10 |     public function __construct(ObjectifiedFunctions $functions = null) {
11 |         if ($functions === null) {
12 |             $functions = new ObjectifiedFunctions();
13 |         }
14 | 
15 |         $this->functions = $functions;
16 |     }
17 | 
18 |     public function getUserId() {
19 |         try {
20 |             return (int) $this->functions->posix_geteuid();
21 |         } catch (UndefinedObjectifiedFunction $e) {
22 |             return 0;
23 |         }
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Diagnostics/Diagnostics.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Diagnostics;
 5 | 
 6 | interface Diagnostics {
 7 |     /**
 8 |      * @param array $config
 9 |      */
10 |     public function diagnose(array $config);
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Diagnostics/Status.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Diagnostics;
 4 | 
 5 | use Kibo\Phast\Environment\Package;
 6 | 
 7 | class Status implements \JsonSerializable {
 8 |     /**
 9 |      * @var Package
10 |      */
11 |     private $package;
12 | 
13 |     /**
14 |      * @var bool
15 |      */
16 |     private $available;
17 | 
18 |     /**
19 |      * @var string
20 |      */
21 |     private $reason;
22 | 
23 |     /**
24 |      * @var bool
25 |      */
26 |     private $enabled;
27 | 
28 |     /**
29 |      * Status constructor.
30 |      * @param Package $package
31 |      * @param bool $available
32 |      * @param string $reason
33 |      * @param bool $enabled
34 |      */
35 |     public function __construct(Package $package, $available, $reason, $enabled) {
36 |         $this->package = $package;
37 |         $this->available = $available;
38 |         $this->reason = $reason;
39 |         $this->enabled = $enabled;
40 |     }
41 | 
42 |     /**
43 |      * @return Package
44 |      */
45 |     public function getPackage() {
46 |         return $this->package;
47 |     }
48 | 
49 |     /**
50 |      * @return bool
51 |      */
52 |     public function isAvailable() {
53 |         return $this->available;
54 |     }
55 | 
56 |     /**
57 |      * @return string
58 |      */
59 |     public function getReason() {
60 |         return $this->reason;
61 |     }
62 | 
63 |     /**
64 |      * @return bool
65 |      */
66 |     public function isEnabled() {
67 |         return $this->enabled;
68 |     }
69 | 
70 |     public function toArray(): array {
71 |         return [
72 |             'package' => [
73 |                 'type' => $this->package->getType(),
74 |                 'name' => $this->package->getNamespace(),
75 |             ],
76 |             'available' => $this->available,
77 |             'reason' => $this->reason,
78 |             'enabled' => $this->enabled,
79 |         ];
80 |     }
81 | 
82 |     public function jsonSerialize(): array {
83 |         return $this->toArray();
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/src/Environment/Exceptions/PackageHasNoDiagnosticsException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Environment\Exceptions;
 5 | 
 6 | use Kibo\Phast\Exceptions\LogicException;
 7 | 
 8 | class PackageHasNoDiagnosticsException extends LogicException {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Environment/Exceptions/PackageHasNoFactoryException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Environment\Exceptions;
 5 | 
 6 | use Kibo\Phast\Exceptions\LogicException;
 7 | 
 8 | class PackageHasNoFactoryException extends LogicException {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Environment/Switches.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Environment;
 4 | 
 5 | class Switches {
 6 |     const SWITCH_PHAST = 'phast';
 7 | 
 8 |     const SWITCH_DIAGNOSTICS = 'diagnostics';
 9 | 
10 |     private static $defaults = [
11 |         self::SWITCH_PHAST => true,
12 |         self::SWITCH_DIAGNOSTICS => false,
13 |     ];
14 | 
15 |     private $switches = [];
16 | 
17 |     public static function fromArray(array $switches) {
18 |         $instance = new self();
19 |         $instance->switches = array_merge($instance->switches, $switches);
20 |         return $instance;
21 |     }
22 | 
23 |     public static function fromString($switches) {
24 |         $instance = new self();
25 |         if (empty($switches)) {
26 |             return $instance;
27 |         }
28 |         foreach (explode(',', $switches) as $switch) {
29 |             if ($switch[0] == '-') {
30 |                 $instance->switches[substr($switch, 1)] = false;
31 |             } else {
32 |                 $instance->switches[$switch] = true;
33 |             }
34 |         }
35 |         return $instance;
36 |     }
37 | 
38 |     public function merge(Switches $switches) {
39 |         $instance = new self();
40 |         $instance->switches = array_merge($this->switches, $switches->switches);
41 |         return $instance;
42 |     }
43 | 
44 |     public function isOn($switch) {
45 |         if (isset($this->switches[$switch])) {
46 |             return (bool) $this->switches[$switch];
47 |         }
48 |         if (isset(self::$defaults[$switch])) {
49 |             return (bool) self::$defaults[$switch];
50 |         }
51 |         return true;
52 |     }
53 | 
54 |     public function toArray() {
55 |         return array_merge(self::$defaults, $this->switches);
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Environment/config-default.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | return Kibo\Phast\Environment\DefaultConfiguration::get();
4 | 


--------------------------------------------------------------------------------
/src/Exceptions/CachedExceptionException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Kibo\Phast\Exceptions;
4 | 
5 | class CachedExceptionException extends \Exception {
6 | }
7 | 


--------------------------------------------------------------------------------
/src/Exceptions/ItemNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Exceptions;
 4 | 
 5 | use Kibo\Phast\ValueObjects\URL;
 6 | use Throwable;
 7 | 
 8 | class ItemNotFoundException extends \Exception {
 9 |     /**
10 |      * @var URL
11 |      */
12 |     private $url;
13 | 
14 |     public function __construct($message = '', $code = 0, Throwable $previous = null, URL $failed = null) {
15 |         parent::__construct($message, $code, $previous);
16 |         $this->url = $failed;
17 |     }
18 | 
19 |     /**
20 |      * @return URL
21 |      */
22 |     public function getUrl() {
23 |         return $this->url;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Exceptions/LogicException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace Kibo\Phast\Exceptions;
5 | 
6 | class LogicException extends \LogicException {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Exceptions/RuntimeException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace Kibo\Phast\Exceptions;
5 | 
6 | class RuntimeException extends \RuntimeException {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Exceptions/UnauthorizedException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Kibo\Phast\Exceptions;
4 | 
5 | class UnauthorizedException extends \Exception {
6 | }
7 | 


--------------------------------------------------------------------------------
/src/Exceptions/UndefinedObjectifiedFunction.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Kibo\Phast\Exceptions;
4 | 
5 | class UndefinedObjectifiedFunction extends \RuntimeException {
6 | }
7 | 


--------------------------------------------------------------------------------
/src/Filters/CSS/CSSMinifier/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\CSS\CSSMinifier;
 5 | 
 6 | class Factory {
 7 |     public function make() {
 8 |         return new Filter();
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Filters/CSS/CSSMinifier/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\CSS\CSSMinifier;
 4 | 
 5 | use Kibo\Phast\Services\ServiceFilter;
 6 | use Kibo\Phast\ValueObjects\Resource;
 7 | 
 8 | class Filter implements ServiceFilter {
 9 |     /**
10 |      * @param Resource $resource
11 |      * @param array $request
12 |      * @return Resource
13 |      */
14 |     public function apply(Resource $resource, array $request) {
15 |         $content = $resource->getContent();
16 | 
17 |         // Normalize whitespace
18 |         $content = preg_replace('~\s+~', ' ', $content);
19 | 
20 |         // Remove whitespace before and after operators
21 |         $chars = [',', '{', '}', ';'];
22 |         foreach ($chars as $char) {
23 |             $content = str_replace("$char ", $char, $content);
24 |             $content = str_replace(" $char", $char, $content);
25 |         }
26 | 
27 |         // Remove whitespace after colons
28 |         $content = str_replace(': ', ':', $content);
29 | 
30 |         return $resource->withContent(trim($content));
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Filters/CSS/CSSURLRewriter/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\CSS\CSSURLRewriter;
 5 | 
 6 | class Factory {
 7 |     public function make() {
 8 |         return new Filter();
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Filters/CSS/CSSURLRewriter/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\CSS\CSSURLRewriter;
 5 | 
 6 | use Kibo\Phast\Services\ServiceFilter;
 7 | use Kibo\Phast\ValueObjects\Resource;
 8 | use Kibo\Phast\ValueObjects\URL;
 9 | 
10 | class Filter implements ServiceFilter {
11 |     /**
12 |      * @param Resource $resource
13 |      * @param array $request
14 |      * @return Resource
15 |      */
16 |     public function apply(Resource $resource, array $request) {
17 |         $baseUrl = $resource->getUrl();
18 |         $callback = function ($match) use ($baseUrl) {
19 |             if (preg_match('~^[a-z]+:|^#~i', $match[3])) {
20 |                 return $match[0];
21 |             }
22 |             return $match[1] . URL::fromString($match[3])->withBase($baseUrl) . $match[4];
23 |         };
24 | 
25 |         $cssContent = preg_replace_callback(
26 |             '~
27 |                 \b
28 |                 ( url\( \s*+ ([\'"]?) )
29 |                 ([A-Za-z0-9_/.:?&=+%,#@-]+)
30 |                 ( \2 \s*+ \) )
31 |             ~x',
32 |             $callback,
33 |             $resource->getContent()
34 |         );
35 | 
36 |         $cssContent = preg_replace_callback(
37 |             '~
38 |                 ( @import \s+ ([\'"]) )
39 |                 ([A-Za-z0-9_/.:?&=+%,#@-]+)
40 |                 ( \2 )
41 |             ~x',
42 |             $callback,
43 |             $cssContent
44 |         );
45 | 
46 |         return $resource->withContent($cssContent);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Filters/CSS/CommentsRemoval/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\CSS\CommentsRemoval;
 5 | 
 6 | use Kibo\Phast\Services\ServiceFilter;
 7 | use Kibo\Phast\ValueObjects\Resource;
 8 | 
 9 | class Filter implements ServiceFilter {
10 |     public function apply(Resource $resource, array $request) {
11 |         $content = preg_replace('~/\*[^*]*\*+([^/*][^*]*\*+)*/~', '', $resource->getContent());
12 |         return $resource->withContent($content);
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Filters/CSS/Composite/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\CSS\Composite;
 5 | 
 6 | use Kibo\Phast\Environment\Package;
 7 | 
 8 | class Factory {
 9 |     /**
10 |      * @param array $config
11 |      * @return Filter
12 |      */
13 |     public function make(array $config) {
14 |         $class = \Kibo\Phast\Filters\HTML\ImagesOptimizationService\CSS\Filter::class;
15 |         if (isset($config['documents']['filters'][$class]['serviceUrl'])) {
16 |             $serviceUrl = $config['documents']['filters'][$class]['serviceUrl'];
17 |         } else {
18 |             $serviceUrl = $config['servicesUrl'] . '?service=images';
19 |         }
20 | 
21 |         $filter = new Filter($serviceUrl);
22 |         foreach (array_keys($config['styles']['filters']) as $filterClass) {
23 |             $filter->addFilter(
24 |                 Package::fromPackageClass($filterClass)
25 |                     ->getFactory()
26 |                     ->make($config)
27 |             );
28 |         }
29 |         return $filter;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Filters/CSS/Composite/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\CSS\Composite;
 5 | 
 6 | use Kibo\Phast\Filters\CSS\CommentsRemoval;
 7 | use Kibo\Phast\Filters\Service\CachedResultServiceFilter;
 8 | use Kibo\Phast\Filters\Service\CompositeFilter;
 9 | 
10 | class Filter extends CompositeFilter implements CachedResultServiceFilter {
11 |     public function __construct() {
12 |         $this->addFilter(new CommentsRemoval\Filter());
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Filters/CSS/FontSwap/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\CSS\FontSwap;
 5 | 
 6 | class Factory {
 7 |     public function make() {
 8 |         return new Filter();
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Filters/CSS/FontSwap/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\CSS\FontSwap;
 5 | 
 6 | use Kibo\Phast\Services\ServiceFilter;
 7 | use Kibo\Phast\ValueObjects\Resource;
 8 | 
 9 | class Filter implements ServiceFilter {
10 |     const FONT_FACE_REGEXP = '/(@font-face\s*\{)([^}]*)/i';
11 | 
12 |     const ICON_FONT_FAMILIES = [
13 |         'Font Awesome',
14 |         'GeneratePress',
15 |         'Dashicons',
16 |         'Ionicons',
17 |     ];
18 | 
19 |     private $fontDisplayBlockPattern;
20 | 
21 |     public function __construct() {
22 |         $this->fontDisplayBlockPattern = $this->getFontDisplayBlockPattern();
23 |     }
24 | 
25 |     public function apply(Resource $resource, array $request) {
26 |         $css = $resource->getContent();
27 |         $filtered = preg_replace_callback(self::FONT_FACE_REGEXP, function ($match) {
28 |             list($block, $start, $contents) = $match;
29 |             $mode = preg_match($this->fontDisplayBlockPattern, $contents) ? 'block' : 'swap';
30 |             return $start . 'font-display:' . $mode . ';' . $contents;
31 |         }, $css);
32 |         return $resource->withContent($filtered);
33 |     }
34 | 
35 |     private function getFontDisplayBlockPattern() {
36 |         $patterns = [];
37 |         foreach (self::ICON_FONT_FAMILIES as $family) {
38 |             $chars = str_split($family);
39 |             $chars = array_map(function ($char) {
40 |                 return preg_quote($char, '~');
41 |             }, $chars);
42 |             $patterns[] = implode('\s*', $chars);
43 |         }
44 |         return '~' . implode('|', $patterns) . '~i';
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Filters/CSS/ImageURLRewriter/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\CSS\ImageURLRewriter;
 5 | 
 6 | use Kibo\Phast\Filters\HTML\ImagesOptimizationService\ImageURLRewriterFactory;
 7 | 
 8 | class Factory {
 9 |     public function make(array $config) {
10 |         return new Filter(
11 |             (new ImageURLRewriterFactory())->make($config, Filter::class)
12 |         );
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Filters/CSS/ImageURLRewriter/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\CSS\ImageURLRewriter;
 4 | 
 5 | use Kibo\Phast\Filters\HTML\ImagesOptimizationService\ImageURLRewriter;
 6 | use Kibo\Phast\Filters\Service\CachedResultServiceFilter;
 7 | use Kibo\Phast\ValueObjects\Resource;
 8 | 
 9 | class Filter implements CachedResultServiceFilter {
10 |     /**
11 |      * @var ImageURLRewriter
12 |      */
13 |     private $rewriter;
14 | 
15 |     /**
16 |      * Filter constructor.
17 |      * @param ImageURLRewriter $rewriter
18 |      */
19 |     public function __construct(ImageURLRewriter $rewriter) {
20 |         $this->rewriter = $rewriter;
21 |     }
22 | 
23 |     public function getCacheSalt(Resource $resource, array $request) {
24 |         return $this->rewriter->getCacheSalt();
25 |     }
26 | 
27 |     public function apply(Resource $resource, array $request) {
28 |         $content = $this->rewriter->rewriteStyle($resource->getContent());
29 |         $dependencies = $this->rewriter->getInlinedResources();
30 |         return $resource->withContent($content)
31 |                         ->withDependencies($dependencies);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Filters/CSS/ImportsStripper/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\CSS\ImportsStripper;
 5 | 
 6 | class Factory {
 7 |     public function make() {
 8 |         return new Filter();
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Filters/CSS/ImportsStripper/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\CSS\ImportsStripper;
 5 | 
 6 | use Kibo\Phast\Filters\HTML\CSSInlining;
 7 | use Kibo\Phast\Filters\Service\CachedResultServiceFilter;
 8 | use Kibo\Phast\Logging\LoggingTrait;
 9 | use Kibo\Phast\ValueObjects\Resource;
10 | 
11 | class Filter implements CachedResultServiceFilter {
12 |     use LoggingTrait;
13 | 
14 |     public function getCacheSalt(Resource $resource, array $request) {
15 |         return $this->shouldStripImports($request) ? 'strip-imports' : 'no-strip-imports';
16 |     }
17 | 
18 |     public function apply(Resource $resource, array $request) {
19 |         if (!$this->shouldStripImports($request)) {
20 |             $this->logger()->info('No import stripping requested! Skipping!');
21 |             return $resource;
22 |         }
23 |         $css = $resource->getContent();
24 |         $stripped = preg_replace(CSSInlining\Filter::CSS_IMPORTS_REGEXP, '', $css);
25 |         return $resource->withContent($stripped);
26 |     }
27 | 
28 |     private function shouldStripImports(array $request) {
29 |         return isset($request['strip-imports']);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/AMPCompatibleFilter.php:
--------------------------------------------------------------------------------
1 | <?php
2 | namespace Kibo\Phast\Filters\HTML;
3 | 
4 | interface AMPCompatibleFilter {
5 | }
6 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/BaseHTMLStreamFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\HTML;
 5 | 
 6 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\Element;
 7 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\Tag;
 8 | 
 9 | abstract class BaseHTMLStreamFilter implements HTMLStreamFilter {
10 |     /**
11 |      * @var HTMLPageContext
12 |      */
13 |     protected $context;
14 | 
15 |     /**
16 |      * @var \Traversable
17 |      */
18 |     protected $elements;
19 | 
20 |     /**
21 |      * @param Tag $tag
22 |      * @return Element[]|\Generator
23 |      */
24 |     abstract protected function handleTag(Tag $tag);
25 | 
26 |     public function transformElements(\Traversable $elements, HTMLPageContext $context) {
27 |         $this->context = $context;
28 |         $this->elements = $elements;
29 |         $this->beforeLoop();
30 |         foreach ($this->elements as $element) {
31 |             if (($element instanceof Tag) && $this->isTagOfInterest($element)) {
32 |                 foreach ($this->handleTag($element) as $item) {
33 |                     yield $item;
34 |                 }
35 |             } else {
36 |                 yield $element;
37 |             }
38 |         }
39 |         $this->afterLoop();
40 |     }
41 | 
42 |     /**
43 |      * @param Tag $tag
44 |      * @return bool
45 |      */
46 |     protected function isTagOfInterest(Tag $tag) {
47 |         return true;
48 |     }
49 | 
50 |     protected function beforeLoop() {
51 |     }
52 | 
53 |     protected function afterLoop() {
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/BaseURLSetter/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\HTML\BaseURLSetter;
 5 | 
 6 | use Kibo\Phast\Filters\HTML\BaseHTMLStreamFilter;
 7 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\Tag;
 8 | use Kibo\Phast\ValueObjects\URL;
 9 | 
10 | class Filter extends BaseHTMLStreamFilter {
11 |     protected function isTagOfInterest(Tag $tag) {
12 |         return $tag->getTagName() == 'base' && $tag->hasAttribute('href');
13 |     }
14 | 
15 |     protected function handleTag(Tag $tag) {
16 |         $base = URL::fromString($tag->getAttribute('href'));
17 |         $current = $this->context->getBaseUrl();
18 |         $this->context->setBaseUrl($base->withBase($current));
19 |         yield $tag;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/CSSInlining/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML\CSSInlining;
 4 | 
 5 | use Kibo\Phast\Cache\Sqlite\Cache;
 6 | use Kibo\Phast\Filters\CSS\Composite\Factory as CSSCompositeFactory;
 7 | use Kibo\Phast\Filters\HTML\HTMLFilterFactory;
 8 | use Kibo\Phast\Retrievers\CachingRetriever;
 9 | use Kibo\Phast\Retrievers\LocalRetriever;
10 | use Kibo\Phast\Retrievers\UniversalRetriever;
11 | use Kibo\Phast\Security\ServiceSignatureFactory;
12 | use Kibo\Phast\Services\Bundler\TokenRefMakerFactory;
13 | use Kibo\Phast\ValueObjects\URL;
14 | 
15 | class Factory implements HTMLFilterFactory {
16 |     public function make(array $config) {
17 |         $localRetriever = new LocalRetriever($config['retrieverMap']);
18 | 
19 |         $retriever = new UniversalRetriever();
20 |         $retriever->addRetriever($localRetriever);
21 |         $retriever->addRetriever(
22 |             new CachingRetriever(
23 |                 new Cache($config['cache'], 'css')
24 |             )
25 |         );
26 | 
27 |         if (!isset($config['documents']['filters'][Filter::class]['serviceUrl'])) {
28 |             $config['documents']['filters'][Filter::class]['serviceUrl'] = $config['servicesUrl'];
29 |         }
30 | 
31 |         return new Filter(
32 |             (new ServiceSignatureFactory())->make($config),
33 |             URL::fromString($config['documents']['baseUrl']),
34 |             $config['documents']['filters'][Filter::class],
35 |             $localRetriever,
36 |             $retriever,
37 |             new OptimizerFactory($config),
38 |             (new CSSCompositeFactory())->make($config),
39 |             (new TokenRefMakerFactory())->make($config),
40 |             $config['csp']['nonce']
41 |         );
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/CSSInlining/OptimizerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML\CSSInlining;
 4 | 
 5 | use Kibo\Phast\Cache\Sqlite\Cache;
 6 | 
 7 | class OptimizerFactory {
 8 |     /**
 9 |      * @var Cache
10 |      */
11 |     private $cache;
12 | 
13 |     public function __construct(array $config) {
14 |         $this->cache = new Cache($config['cache'], 'css-optimizitor');
15 |     }
16 | 
17 |     /**
18 |      * @param \Traversable $elements
19 |      * @return Optimizer
20 |      */
21 |     public function makeForElements(\Traversable $elements) {
22 |         return new Optimizer($elements, $this->cache);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/CSSInlining/ie-fallback.js:
--------------------------------------------------------------------------------
 1 | (function () {
 2 |   // https://github.com/filamentgroup/woff2-feature-test/blob/master/woff2.js
 3 |   var supportsWoff2 = (function () {
 4 |     if (!("FontFace" in window)) {
 5 |       return false;
 6 |     }
 7 | 
 8 |     var f = new FontFace(
 9 |       "t",
10 |       'url( "data:font/woff2;base64,d09GMgABAAAAAADwAAoAAAAAAiQAAACoAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmAALAogOAE2AiQDBgsGAAQgBSAHIBuDAciO1EZ3I/mL5/+5/rfPnTt9/9Qa8H4cUUZxaRbh36LiKJoVh61XGzw6ufkpoeZBW4KphwFYIJGHB4LAY4hby++gW+6N1EN94I49v86yCpUdYgqeZrOWN34CMQg2tAmthdli0eePIwAKNIIRS4AGZFzdX9lbBUAQlm//f262/61o8PlYO/D1/X4FrWFFgdCQD9DpGJSxmFyjOAGUU4P0qigcNb82GAAA" ) format( "woff2" )',
11 |       {}
12 |     );
13 |     f.load()["catch"](function () {});
14 | 
15 |     return f.status == "loading" || f.status == "loaded";
16 |   })();
17 | 
18 |   if (supportsWoff2) {
19 |     return;
20 |   }
21 | 
22 |   console.log(
23 |     "[Phast] Browser does not support WOFF2, falling back to original stylesheets"
24 |   );
25 | 
26 |   Array.prototype.forEach.call(
27 |     document.querySelectorAll("style[data-phast-ie-fallback-url]"),
28 |     function (el) {
29 |       var link = document.createElement("link");
30 |       if (el.hasAttribute("media")) {
31 |         link.setAttribute("media", el.getAttribute("media"));
32 |       }
33 |       link.setAttribute("rel", "stylesheet");
34 |       link.setAttribute("href", el.getAttribute("data-phast-ie-fallback-url"));
35 |       el.parentNode.insertBefore(link, el);
36 |       el.parentNode.removeChild(el);
37 |     }
38 |   );
39 | 
40 |   Array.prototype.forEach.call(
41 |     document.querySelectorAll("style[data-phast-nested-inlined]"),
42 |     function (groupEl) {
43 |       groupEl.parentNode.removeChild(groupEl);
44 |     }
45 |   );
46 | })();
47 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/CSSInlining/inlined-css-retriever.js:
--------------------------------------------------------------------------------
 1 | /* globals phast */
 2 | 
 3 | phast.stylesLoading = 0;
 4 | 
 5 | var resourceLoader = phast.ResourceLoader.instance;
 6 | 
 7 | phast.forEachSelectedElement("style[data-phast-params]", function (style) {
 8 |   var textParams = style.getAttribute("data-phast-params");
 9 |   var params = phast.ResourceLoader.RequestParams.fromString(textParams);
10 |   phast.stylesLoading++;
11 |   resourceLoader
12 |     .get(params)
13 |     .then(function (css) {
14 |       style.textContent = css;
15 |       style.removeAttribute("data-phast-params");
16 |     })
17 |     .catch(function (err) {
18 |       console.warn("[Phast] Failed to load CSS", params, err);
19 |       var src = style.getAttribute("data-phast-original-src");
20 |       if (!src) {
21 |         console.error("[Phast] No data-phast-original-src on <style>!", style);
22 |         return;
23 |       }
24 |       console.info("[Phast] Falling back to <link> element for", src);
25 |       var link = document.createElement("link");
26 |       link.href = src;
27 |       link.media = style.media;
28 |       link.rel = "stylesheet";
29 |       link.addEventListener("load", function () {
30 |         if (style.parentNode) {
31 |           style.parentNode.removeChild(style);
32 |         }
33 |       });
34 |       style.parentNode.insertBefore(link, style.nextSibling);
35 |     })
36 |     .finally(function () {
37 |       phast.stylesLoading--;
38 |       if (phast.stylesLoading === 0 && phast.onStylesLoaded) {
39 |         phast.onStylesLoaded();
40 |       }
41 |     });
42 | });
43 | 
44 | (function () {
45 |   var ids = [];
46 | 
47 |   phast.forEachSelectedElement(
48 |     "style[data-phast-original-id]",
49 |     function (style) {
50 |       var id = style.getAttribute("data-phast-original-id");
51 |       if (ids[id]) {
52 |         return;
53 |       }
54 |       ids[id] = true;
55 |       console.warn(
56 |         "[Phast] The style element with id",
57 |         id,
58 |         "has been split into multiple style tags due to @import statements and the id attribute has been removed. Normally, this does not cause any issues."
59 |       );
60 |     }
61 |   );
62 | })();
63 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/CommentsRemoval/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\HTML\CommentsRemoval;
 5 | 
 6 | use Kibo\Phast\Filters\HTML\HTMLPageContext;
 7 | use Kibo\Phast\Filters\HTML\HTMLStreamFilter;
 8 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\Comment;
 9 | 
10 | class Filter implements HTMLStreamFilter {
11 |     public function transformElements(\Traversable $elements, HTMLPageContext $context) {
12 |         foreach ($elements as $element) {
13 |             if (!($element instanceof Comment) || $element->isIEConditional()) {
14 |                 yield $element;
15 |             }
16 |         }
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/Composite/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML\Composite;
 4 | 
 5 | use Kibo\Phast\Environment\Package;
 6 | use Kibo\Phast\Logging\LoggingTrait;
 7 | use Kibo\Phast\ValueObjects\URL;
 8 | 
 9 | class Factory {
10 |     use LoggingTrait;
11 | 
12 |     public function make(array $config) {
13 |         $composite = new Filter(URL::fromString($config['documents']['baseUrl']), $config['outputServerSideStats']);
14 |         foreach (array_keys($config['documents']['filters']) as $class) {
15 |             $package = Package::fromPackageClass($class);
16 |             if ($package->hasFactory()) {
17 |                 $filter = $package->getFactory()->make($config);
18 |             } elseif (!class_exists($class)) {
19 |                 $this->logger(__METHOD__, __LINE__)
20 |                      ->error("Skipping non-existent filter class: $class");
21 |                 continue;
22 |             } else {
23 |                 $filter = new $class();
24 |             }
25 |             $composite->addHTMLFilter($filter);
26 |         }
27 |         return $composite;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/DelayedIFrameLoading/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Filters\HTML\DelayedIFrameLoading;
 3 | 
 4 | use Kibo\Phast\Filters\HTML\BaseHTMLStreamFilter;
 5 | use Kibo\Phast\Logging\LoggingTrait;
 6 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\Tag;
 7 | 
 8 | class Filter extends BaseHTMLStreamFilter {
 9 |     use LoggingTrait;
10 | 
11 |     protected function isTagOfInterest(Tag $tag) {
12 |         return $tag->getTagName() == 'iframe'
13 |                && $tag->hasAttribute('src');
14 |     }
15 | 
16 |     protected function handleTag(Tag $tag) {
17 |         if (!$tag->hasAttribute('loading')) {
18 |             $tag->setAttribute('loading', 'lazy');
19 |         }
20 |         yield $tag;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/Diagnostics/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML\Diagnostics;
 4 | 
 5 | use Kibo\Phast\Filters\HTML\HTMLFilterFactory;
 6 | 
 7 | class Factory implements HTMLFilterFactory {
 8 |     public function make(array $config) {
 9 |         $url =  isset($config['documents']['filters'][Filter::class]['serviceUrl'])
10 |                 ? $config['documents']['filters'][Filter::class]['serviceUrl']
11 |                 : $config['servicesUrl'] . '?service=diagnostics';
12 |         return new Filter($url);
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/Diagnostics/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\HTML\Diagnostics;
 5 | 
 6 | use Kibo\Phast\Filters\HTML\HTMLPageContext;
 7 | use Kibo\Phast\Filters\HTML\HTMLStreamFilter;
 8 | use Kibo\Phast\Services\ServiceRequest;
 9 | use Kibo\Phast\ValueObjects\PhastJavaScript;
10 | use Kibo\Phast\ValueObjects\URL;
11 | 
12 | class Filter implements HTMLStreamFilter {
13 |     private $serviceUrl;
14 | 
15 |     public function __construct($serviceUrl) {
16 |         $this->serviceUrl = $serviceUrl;
17 |     }
18 | 
19 |     public function transformElements(\Traversable $elements, HTMLPageContext $context) {
20 |         $url = (new ServiceRequest())->withUrl(URL::fromString($this->serviceUrl))->serialize();
21 |         $script = PhastJavaScript::fromFile(__DIR__ . '/diagnostics.js');
22 |         $script->setConfig('diagnostics', ['serviceUrl' => $url]);
23 |         $context->addPhastJavaScript($script);
24 |         foreach ($elements as $element) {
25 |             yield $element;
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/HTMLFilterFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML;
 4 | 
 5 | interface HTMLFilterFactory {
 6 |     /**
 7 |      * @param array $config
 8 |      * @return HTMLStreamFilter
 9 |      */
10 |     public function make(array $config);
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/HTMLPageContext.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\HTML;
 5 | 
 6 | use Kibo\Phast\ValueObjects\PhastJavaScript;
 7 | use Kibo\Phast\ValueObjects\URL;
 8 | 
 9 | class HTMLPageContext {
10 |     /**
11 |      * @var URL
12 |      */
13 |     private $baseUrl;
14 | 
15 |     /**
16 |      * @var PhastJavaScript[]
17 |      */
18 |     private $phastJavaScripts = [];
19 | 
20 |     /**
21 |      * HTMLPageContext constructor.
22 |      * @param URL $baseUrl
23 |      */
24 |     public function __construct(URL $baseUrl) {
25 |         $this->baseUrl = $baseUrl;
26 |     }
27 | 
28 |     /**
29 |      * @param URL $baseUrl
30 |      */
31 |     public function setBaseUrl(URL $baseUrl) {
32 |         $this->baseUrl = $baseUrl;
33 |     }
34 | 
35 |     /**
36 |      * @return URL
37 |      */
38 |     public function getBaseUrl() {
39 |         return $this->baseUrl;
40 |     }
41 | 
42 |     /**
43 |      * @param PhastJavaScript $script
44 |      */
45 |     public function addPhastJavascript(PhastJavaScript $script) {
46 |         $this->phastJavaScripts[] = $script;
47 |     }
48 | 
49 |     /**
50 |      * @return PhastJavaScript[]
51 |      */
52 |     public function getPhastJavaScripts() {
53 |         return $this->phastJavaScripts;
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/HTMLStreamFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\HTML;
 5 | 
 6 | interface HTMLStreamFilter {
 7 |     /**
 8 |      * @param \Traversable $elements
 9 |      * @param HTMLPageContext $context
10 |      * @return \Traversable
11 |      */
12 |     public function transformElements(\Traversable $elements, HTMLPageContext $context);
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/Helpers/JSDetectorTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML\Helpers;
 4 | 
 5 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\Tag;
 6 | 
 7 | trait JSDetectorTrait {
 8 |     /**
 9 |      * @param Tag $element
10 |      * @return bool
11 |      */
12 |     private function isJSElement(Tag $element) {
13 |         if (!$element->hasAttribute('type')) {
14 |             return true;
15 |         }
16 |         return (bool) preg_match('~^(text|application)/javascript(;|$)~i', $element->getAttribute('type'));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/ImagesOptimizationService/CSS/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML\ImagesOptimizationService\CSS;
 4 | 
 5 | use Kibo\Phast\Filters\HTML\HTMLFilterFactory;
 6 | use Kibo\Phast\Filters\HTML\ImagesOptimizationService\ImageURLRewriterFactory;
 7 | 
 8 | class Factory implements HTMLFilterFactory {
 9 |     public function make(array $config) {
10 |         return new Filter(
11 |             (new ImageURLRewriterFactory())->make($config, Filter::class)
12 |         );
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/ImagesOptimizationService/CSS/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML\ImagesOptimizationService\CSS;
 4 | 
 5 | use Kibo\Phast\Filters\HTML\BaseHTMLStreamFilter;
 6 | use Kibo\Phast\Filters\HTML\ImagesOptimizationService\ImageURLRewriter;
 7 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\Tag;
 8 | 
 9 | class Filter extends BaseHTMLStreamFilter {
10 |     /**
11 |      * @var ImageURLRewriter
12 |      */
13 |     protected $rewriter;
14 | 
15 |     /**
16 |      * Filter constructor.
17 |      * @param ImageURLRewriter $rewriter
18 |      */
19 |     public function __construct(ImageURLRewriter $rewriter) {
20 |         $this->rewriter = $rewriter;
21 |     }
22 | 
23 |     protected function handleTag(Tag $tag) {
24 |         if ($tag->hasAttribute('style')) {
25 |             $tag->setAttribute(
26 |                 'style',
27 |                 $this->rewriter->rewriteStyle($tag->getAttribute('style'))
28 |             );
29 |         }
30 |         yield $tag;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/ImagesOptimizationService/ImageInliningManagerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\HTML\ImagesOptimizationService;
 5 | 
 6 | use Kibo\Phast\Cache\Sqlite\Cache;
 7 | 
 8 | class ImageInliningManagerFactory {
 9 |     public function make(array $config) {
10 |         $cache = new Cache($config['cache'], 'inline-images-1');
11 |         return new ImageInliningManager($cache, $config['images']['maxImageInliningSize']);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/ImagesOptimizationService/ImageURLRewriterFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\HTML\ImagesOptimizationService;
 5 | 
 6 | use Kibo\Phast\Retrievers\LocalRetriever;
 7 | use Kibo\Phast\Security\ServiceSignatureFactory;
 8 | use Kibo\Phast\ValueObjects\URL;
 9 | 
10 | class ImageURLRewriterFactory {
11 |     public function make(array $config, $filterClass = '') {
12 |         $signature = (new ServiceSignatureFactory())->make($config);
13 | 
14 |         if (isset($config['documents']['filters'][$filterClass])) {
15 |             $classConfig = $config['documents']['filters'][$filterClass];
16 |         } elseif (isset($config['styles']['filters'][$filterClass])) {
17 |             $classConfig = $config['styles']['filters'][$filterClass];
18 |         } else {
19 |             $classConfig = [];
20 |         }
21 | 
22 |         if (isset($classConfig['serviceUrl'])) {
23 |             $serviceUrl = $classConfig['serviceUrl'];
24 |         } else {
25 |             $serviceUrl = $config['servicesUrl'] . '?service=images';
26 |         }
27 |         return new ImageURLRewriter(
28 |             $signature,
29 |             new LocalRetriever($config['retrieverMap']),
30 |             (new ImageInliningManagerFactory())->make($config),
31 |             URL::fromString($config['documents']['baseUrl']),
32 |             URL::fromString($serviceUrl),
33 |             $config['images']['whitelist']
34 |         );
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/ImagesOptimizationService/Tags/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML\ImagesOptimizationService\Tags;
 4 | 
 5 | use Kibo\Phast\Filters\HTML\HTMLFilterFactory;
 6 | use Kibo\Phast\Filters\HTML\ImagesOptimizationService\ImageURLRewriterFactory;
 7 | 
 8 | class Factory implements HTMLFilterFactory {
 9 |     public function make(array $config) {
10 |         return new Filter(
11 |             (new ImageURLRewriterFactory())->make($config, Filter::class)
12 |         );
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/LazyImageLoading/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Filters\HTML\LazyImageLoading;
 3 | 
 4 | use Kibo\Phast\Filters\HTML\BaseHTMLStreamFilter;
 5 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\Tag;
 6 | 
 7 | class Filter extends BaseHTMLStreamFilter {
 8 |     protected function handleTag(Tag $tag) {
 9 |         if (!$tag->hasAttribute('loading')) {
10 |             $tag->setAttribute('loading', 'lazy');
11 |         }
12 |         yield $tag;
13 |     }
14 | 
15 |     protected function isTagOfInterest(Tag $tag) {
16 |         return $tag->getTagName() == 'img';
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/MetaCharset/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Filters\HTML\MetaCharset;
 3 | 
 4 | use Kibo\Phast\Filters\HTML\HTMLPageContext;
 5 | use Kibo\Phast\Filters\HTML\HTMLStreamFilter;
 6 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\Tag;
 7 | 
 8 | class Filter implements HTMLStreamFilter {
 9 |     public function transformElements(\Traversable $elements, HTMLPageContext $context) {
10 |         $didYield = false;
11 |         foreach ($elements as $element) {
12 |             if ($element instanceof Tag) {
13 |                 if ($element->tagName == 'meta'
14 |                     && !array_diff(array_keys($element->getAttributes()), ['charset', '/'])
15 |                 ) {
16 |                     continue;
17 |                 }
18 |                 if (!$didYield && !in_array($element->tagName, ['html', 'head', '!doctype'])) {
19 |                     yield new Tag('meta', ['charset' => 'utf-8']);
20 |                     $didYield = true;
21 |                 }
22 |             }
23 |             yield $element;
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/Minify/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Filters\HTML\Minify;
 3 | 
 4 | use Kibo\Phast\Filters\HTML\HTMLPageContext;
 5 | use Kibo\Phast\Filters\HTML\HTMLStreamFilter;
 6 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\ClosingTag;
 7 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\Junk;
 8 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\Tag;
 9 | 
10 | class Filter implements HTMLStreamFilter {
11 |     public function transformElements(\Traversable $elements, HTMLPageContext $context) {
12 |         $inTags = [
13 |             'pre' => 0,
14 |             'textarea' => 0,
15 |         ];
16 |         foreach ($elements as $element) {
17 |             if ($element instanceof Tag && isset($inTags[$element->getTagName()])) {
18 |                 $inTags[$element->getTagName()]++;
19 |             } elseif ($element instanceof ClosingTag && !empty($inTags[$element->getTagName()])) {
20 |                 $inTags[$element->getTagName()]--;
21 |             } elseif ($element instanceof Junk && !array_sum($inTags)) {
22 |                 $element->originalString = preg_replace_callback('~\s++~', function ($match) {
23 |                     return strpos($match[0], "\n") === false ? ' ' : "\n";
24 |                 }, $element->originalString);
25 |             }
26 |             yield $element;
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/MinifyScripts/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Filters\HTML\MinifyScripts;
 3 | 
 4 | use Kibo\Phast\Cache\Sqlite\Cache;
 5 | 
 6 | class Factory {
 7 |     public function make(array $config) {
 8 |         return new Filter(new Cache($config['cache'], 'minified-inline-scripts'));
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/MinifyScripts/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Filters\HTML\MinifyScripts;
 3 | 
 4 | use Kibo\Phast\Cache\Sqlite\Cache;
 5 | use Kibo\Phast\Common\JSMinifier;
 6 | use Kibo\Phast\Filters\HTML\Helpers\JSDetectorTrait;
 7 | use Kibo\Phast\Filters\HTML\HTMLPageContext;
 8 | use Kibo\Phast\Filters\HTML\HTMLStreamFilter;
 9 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\Tag;
10 | 
11 | class Filter implements HTMLStreamFilter {
12 |     use JSDetectorTrait;
13 | 
14 |     private $cache;
15 | 
16 |     public function __construct(Cache $cache) {
17 |         $this->cache = $cache;
18 |     }
19 | 
20 |     public function transformElements(\Traversable $elements, HTMLPageContext $context) {
21 |         foreach ($elements as $element) {
22 |             if ($element instanceof Tag
23 |                 && $element->getTagName() === 'script'
24 |                 && ($content = $element->getTextContent()) !== ''
25 |             ) {
26 |                 $content = trim($content);
27 |                 if ($this->isJSElement($element)
28 |                     && preg_match('~[()[\]{};]\s~', $content)
29 |                 ) {
30 |                     $content = preg_replace('~^\s*<!--\s*\n(.*)\n\s*-->\s*$~s', '$1', $content);
31 |                     $content = $this->cache->get(md5($content), function () use ($content) {
32 |                         return (new JSMinifier($content, true))->min();
33 |                     });
34 |                 } elseif (($data = @json_decode($content)) !== null
35 |                          && ($newContent = json_encode(
36 |                              $data,
37 |                              JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES
38 |                          )) !== false
39 |                 ) {
40 |                     $content = str_replace('</', '<\\/', $newContent);
41 |                 }
42 |                 $element->setTextContent($content);
43 |             }
44 |             yield $element;
45 |         }
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/PhastScriptsCompiler/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Filters\HTML\PhastScriptsCompiler;
 3 | 
 4 | use Kibo\Phast\Cache\Sqlite\Cache;
 5 | use Kibo\Phast\Filters\HTML\HTMLFilterFactory;
 6 | 
 7 | class Factory implements HTMLFilterFactory {
 8 |     public function make(array $config) {
 9 |         $cache = new Cache($config['cache'], 'phast-scripts');
10 |         $compiler = new PhastJavaScriptCompiler(
11 |             $cache,
12 |             $config['servicesUrl'],
13 |             $config['serviceRequestFormat']
14 |         );
15 |         return new Filter($compiler, $config['csp']['nonce']);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/PhastScriptsCompiler/runner.js:
--------------------------------------------------------------------------------
1 | phast.config = JSON.parse(atob(phast.config));
2 | 
3 | while (phast.scripts.length) {
4 |   phast.scripts.shift()();
5 | }
6 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/PhastScriptsCompiler/service-url.js:
--------------------------------------------------------------------------------
 1 | /* globals
 2 |      phast
 3 |      btoa
 4 | */
 5 | 
 6 | phast.buildServiceUrl = function (config, params) {
 7 |   if (config.pathInfo) {
 8 |     return appendPathInfo(config.serviceUrl, buildQuery(params));
 9 |   } else {
10 |     return appendQueryString(config.serviceUrl, buildQuery(params));
11 |   }
12 | };
13 | 
14 | function buildQuery(params) {
15 |   if (typeof params === "string") {
16 |     return params;
17 |   }
18 |   var pieces = [];
19 |   for (var k in params) {
20 |     if (params.hasOwnProperty(k)) {
21 |       pieces.push(encodeURIComponent(k) + "=" + encodeURIComponent(params[k]));
22 |     }
23 |   }
24 |   return pieces.join("&");
25 | }
26 | 
27 | function appendPathInfo(url, query) {
28 |   var data = btoa(query)
29 |     .replace(/=/g, "")
30 |     .replace(/\//g, "_")
31 |     .replace(/\+/g, "-");
32 | 
33 |   var path = insertPathSeparators(data + ".q.js");
34 | 
35 |   return url.replace(/\?.*$/, "").replace(/\/__p__\.js$/, "") + "/" + path;
36 | 
37 |   function insertPathSeparators(path) {
38 |     return strrev(
39 |       strrev(path)
40 |         .match(/[\s\S]{1,255}/g)
41 |         .join("/")
42 |     );
43 |   }
44 | 
45 |   function strrev(s) {
46 |     return s.split("").reverse().join("");
47 |   }
48 | }
49 | 
50 | function appendQueryString(url, queryString) {
51 |   var glue = url.indexOf("?") > -1 ? "&" : "?";
52 |   return url + glue + queryString;
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/ScriptsDeferring/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Filters\HTML\ScriptsDeferring;
 3 | 
 4 | use Kibo\Phast\Filters\HTML\HTMLFilterFactory;
 5 | 
 6 | class Factory implements HTMLFilterFactory {
 7 |     public function make(array $config) {
 8 |         return new Filter($config['csp']);
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Filters/HTML/ScriptsProxyService/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML\ScriptsProxyService;
 4 | 
 5 | use Kibo\Phast\Filters\HTML\HTMLFilterFactory;
 6 | use Kibo\Phast\Retrievers\LocalRetriever;
 7 | use Kibo\Phast\Security\ServiceSignatureFactory;
 8 | use Kibo\Phast\Services\Bundler\TokenRefMakerFactory;
 9 | 
10 | class Factory implements HTMLFilterFactory {
11 |     public function make(array $config) {
12 |         if (!isset($config['documents']['filters'][Filter::class]['serviceUrl'])) {
13 |             $config['documents']['filters'][Filter::class]['serviceUrl'] = $config['servicesUrl'];
14 |         }
15 |         $filterConfig = $config['documents']['filters'][Filter::class];
16 |         $filterConfig['match'] = $config['scripts']['whitelist'];
17 |         return new Filter(
18 |             $filterConfig,
19 |             (new ServiceSignatureFactory())->make($config),
20 |             new LocalRetriever($config['retrieverMap']),
21 |             (new TokenRefMakerFactory())->make($config)
22 |         );
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Filters/Image/CommonDiagnostics/DiagnosticsRetriever.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\Image\CommonDiagnostics;
 5 | 
 6 | use Kibo\Phast\Retrievers\Retriever;
 7 | use Kibo\Phast\ValueObjects\URL;
 8 | 
 9 | class DiagnosticsRetriever implements Retriever {
10 |     /**
11 |      * @var string
12 |      */
13 |     private $file;
14 | 
15 |     /**
16 |      * DiagnosticsRetriever constructor.
17 |      * @param string $file
18 |      */
19 |     public function __construct($file) {
20 |         $this->file = $file;
21 |     }
22 | 
23 |     public function retrieve(URL $url) {
24 |         return file_get_contents($this->file);
25 |     }
26 | 
27 |     public function getCacheSalt(URL $url) {
28 |         return '';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Filters/Image/CommonDiagnostics/kibo-logo.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kiboit/phast/96a50e2fcd71c6db72ac451e1f10d9c92f7f6b6a/src/Filters/Image/CommonDiagnostics/kibo-logo.jpg


--------------------------------------------------------------------------------
/src/Filters/Image/CommonDiagnostics/kibo-logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kiboit/phast/96a50e2fcd71c6db72ac451e1f10d9c92f7f6b6a/src/Filters/Image/CommonDiagnostics/kibo-logo.png


--------------------------------------------------------------------------------
/src/Filters/Image/Composite/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\Image\Composite;
 4 | 
 5 | use Kibo\Phast\Cache\Sqlite\Cache;
 6 | use Kibo\Phast\Environment\Package;
 7 | use Kibo\Phast\Exceptions\LogicException;
 8 | use Kibo\Phast\Filters\HTML\ImagesOptimizationService\ImageInliningManagerFactory;
 9 | use Kibo\Phast\Filters\Service\CachingServiceFilter;
10 | use Kibo\Phast\Retrievers\LocalRetriever;
11 | 
12 | class Factory {
13 |     /**
14 |      * @var array
15 |      */
16 |     private $config;
17 | 
18 |     /**
19 |      * CompositeImageFilterFactory constructor.
20 |      *
21 |      * @param array $config
22 |      */
23 |     public function __construct(array $config) {
24 |         $this->config = $config;
25 |     }
26 | 
27 |     public function make() {
28 |         $imageFactoryClass = $this->config['images']['factory'];
29 |         if (!class_exists($imageFactoryClass)) {
30 |             throw new LogicException("No such class: $imageFactoryClass");
31 |         }
32 |         $composite = new Filter(
33 |             new $imageFactoryClass($this->config),
34 |             (new ImageInliningManagerFactory())->make($this->config)
35 |         );
36 |         foreach ($this->config['images']['filters'] as $class => $config) {
37 |             if ($config === null) {
38 |                 continue;
39 |             }
40 |             $package = Package::fromPackageClass($class);
41 |             $filter = $package->getFactory()->make($this->config);
42 |             $composite->addImageFilter($filter);
43 |         }
44 |         if ($this->config['images']['enable-cache']) {
45 |             return new CachingServiceFilter(
46 |                 new Cache($this->config['cache'], 'images-1'),
47 |                 $composite,
48 |                 new LocalRetriever($this->config['retrieverMap'])
49 |             );
50 |         }
51 |         return $composite;
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Filters/Image/Exceptions/ImageProcessingException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Kibo\Phast\Filters\Image\Exceptions;
4 | 
5 | use Kibo\Phast\Exceptions\RuntimeException;
6 | 
7 | class ImageProcessingException extends RuntimeException {
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Filters/Image/Image.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\Image;
 4 | 
 5 | interface Image {
 6 |     const TYPE_JPEG  = 'image/jpeg';
 7 | 
 8 |     const TYPE_PNG   = 'image/png';
 9 | 
10 |     const TYPE_WEBP  = 'image/webp';
11 | 
12 |     /**
13 |      * @return integer
14 |      */
15 |     public function getWidth();
16 | 
17 |     /**
18 |      * @return integer
19 |      */
20 |     public function getHeight();
21 | 
22 |     /**
23 |      * @return string
24 |      */
25 |     public function getType();
26 | 
27 |     /**
28 |      * @return string
29 |      */
30 |     public function getAsString();
31 | 
32 |     /**
33 |      * @return integer
34 |      */
35 |     public function getSizeAsString();
36 | 
37 |     /**
38 |      * @param integer $width
39 |      * @param integer $height
40 |      * @return Image
41 |      */
42 |     public function resize($width, $height);
43 | 
44 |     /**
45 |      * @param integer $compression
46 |      * @return Image
47 |      */
48 |     public function compress($compression);
49 | 
50 |     /**
51 |      * @param string $type - One of Image::TYPE_JPEG, Image::TYPE_PNG or Image::TYPE_WEBP
52 |      * @return Image
53 |      */
54 |     public function encodeTo($type);
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Filters/Image/ImageAPIClient/Diagnostics.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\Image\ImageAPIClient;
 5 | 
 6 | use Kibo\Phast\Diagnostics\Diagnostics as DiagnosticsInterface;
 7 | use Kibo\Phast\Environment\Package;
 8 | use Kibo\Phast\Exceptions\RuntimeException;
 9 | use Kibo\Phast\Filters\Image\ImageFilter;
10 | use Kibo\Phast\Filters\Image\ImageImplementations\DummyImage;
11 | 
12 | class Diagnostics implements DiagnosticsInterface {
13 |     public function diagnose(array $config) {
14 |         $package = Package::fromPackageClass(get_class($this));
15 |         /** @var ImageFilter $filter */
16 |         $filter = $package->getFactory()->make($config);
17 |         $imageData = @file_get_contents(__DIR__ . '/../CommonDiagnostics/kibo-logo.png');
18 |         if ($imageData === false) {
19 |             throw new RuntimeException('Could not read testing image for ' . static::class . ' diagnostics.');
20 |         }
21 |         $image = new DummyImage();
22 |         $image->setImageString($imageData);
23 |         $filter->transformImage($image, []);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Filters/Image/ImageAPIClient/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\Image\ImageAPIClient;
 5 | 
 6 | use Kibo\Phast\Cache\Sqlite\Cache;
 7 | use Kibo\Phast\Filters\Image\ImageFilterFactory;
 8 | use Kibo\Phast\HTTP\ClientFactory;
 9 | use Kibo\Phast\Security\ServiceSignature;
10 | 
11 | class Factory implements ImageFilterFactory {
12 |     public function make(array $config) {
13 |         $signature = new ServiceSignature(new Cache($config['cache'], 'api-service-signature'));
14 |         return new Filter(
15 |             $config['images']['filters'][Filter::class],
16 |             $signature,
17 |             (new ClientFactory())->make($config)
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Filters/Image/ImageFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\Image;
 4 | 
 5 | use Kibo\Phast\Filters\Image\ImageImplementations\DefaultImage;
 6 | use Kibo\Phast\Retrievers\LocalRetriever;
 7 | use Kibo\Phast\Retrievers\RemoteRetrieverFactory;
 8 | use Kibo\Phast\Retrievers\UniversalRetriever;
 9 | use Kibo\Phast\ValueObjects\Resource;
10 | use Kibo\Phast\ValueObjects\URL;
11 | 
12 | class ImageFactory {
13 |     private $config;
14 | 
15 |     public function __construct(array $config) {
16 |         $this->config = $config;
17 |     }
18 | 
19 |     /**
20 |      * @param URL $url
21 |      * @return Image
22 |      */
23 |     public function getForURL(URL $url) {
24 |         $retriever = new UniversalRetriever();
25 |         $retriever->addRetriever(new LocalRetriever($this->config['retrieverMap']));
26 |         $retriever->addRetriever((new RemoteRetrieverFactory())->make($this->config));
27 |         return new DefaultImage($url, $retriever);
28 |     }
29 | 
30 |     /**
31 |      * @param Resource $resource
32 |      * @return Image
33 |      */
34 |     public function getForResource(Resource $resource) {
35 |         return $this->getForURL($resource->getUrl());
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Filters/Image/ImageFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\Image;
 4 | 
 5 | interface ImageFilter {
 6 |     /**
 7 |      * @param array $request
 8 |      * @return string
 9 |      */
10 |     public function getCacheSalt(array $request);
11 | 
12 |     /**
13 |      * @param Image $image
14 |      * @param array $request
15 |      * @return Image
16 |      */
17 |     public function transformImage(Image $image, array $request);
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Filters/Image/ImageFilterFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\Image;
 5 | 
 6 | interface ImageFilterFactory {
 7 |     /**
 8 |      * @param array $config
 9 |      * @return ImageFilter
10 |      */
11 |     public function make(array $config);
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Filters/Image/ImageImplementations/BaseImage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\Image\ImageImplementations;
 4 | 
 5 | abstract class BaseImage {
 6 |     /**
 7 |      * @var integer
 8 |      */
 9 |     protected $width;
10 | 
11 |     /**
12 |      * @var integer
13 |      */
14 |     protected $height;
15 | 
16 |     /**
17 |      * @var integer
18 |      */
19 |     protected $compression;
20 | 
21 |     /**
22 |      * @var string
23 |      */
24 |     protected $type;
25 | 
26 |     /**
27 |      * @return string
28 |      */
29 |     abstract public function getAsString();
30 | 
31 |     /**
32 |      * @return integer
33 |      */
34 |     public function getSizeAsString() {
35 |         return strlen($this->getAsString());
36 |     }
37 | 
38 |     /**
39 |      * @param $width
40 |      * @param $height
41 |      * @return static
42 |      */
43 |     public function resize($width, $height) {
44 |         $im = clone $this;
45 |         $im->width = $width;
46 |         $im->height = $height;
47 |         return $im;
48 |     }
49 | 
50 |     /**
51 |      * @param $compression
52 |      * @return static
53 |      */
54 |     public function compress($compression) {
55 |         $im = clone $this;
56 |         $im->compression = $compression;
57 |         return $im;
58 |     }
59 | 
60 |     /**
61 |      * @param $type
62 |      * @return static
63 |      */
64 |     public function encodeTo($type) {
65 |         $im = clone $this;
66 |         $im->type = $type;
67 |         return $im;
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/Filters/Image/ImageImplementations/DummyImage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\Image\ImageImplementations;
 4 | 
 5 | use Kibo\Phast\Filters\Image\Image;
 6 | 
 7 | class DummyImage extends BaseImage implements Image {
 8 |     /**
 9 |      * @var string
10 |      */
11 |     private $imageString;
12 | 
13 |     private $transformationString;
14 | 
15 |     /**
16 |      * DummyImage constructor.
17 |      *
18 |      * @param int $width
19 |      * @param int $height
20 |      */
21 |     public function __construct($width = null, $height = null) {
22 |         $this->width = $width;
23 |         $this->height = $height;
24 |     }
25 | 
26 |     /**
27 |      * @return int
28 |      */
29 |     public function getWidth() {
30 |         return $this->width;
31 |     }
32 | 
33 |     /**
34 |      * @return int
35 |      */
36 |     public function getHeight() {
37 |         return $this->height;
38 |     }
39 | 
40 |     /**
41 |      * @return string
42 |      */
43 |     public function getType() {
44 |         return $this->type;
45 |     }
46 | 
47 |     /**
48 |      * @param string $type
49 |      */
50 |     public function setType($type) {
51 |         $this->type = $type;
52 |     }
53 | 
54 |     /**
55 |      * @return int
56 |      */
57 |     public function getCompression() {
58 |         return $this->compression;
59 |     }
60 | 
61 |     /**
62 |      * @return string
63 |      */
64 |     public function getAsString() {
65 |         return $this->imageString;
66 |     }
67 | 
68 |     /**
69 |      * @param string $imageString
70 |      */
71 |     public function setImageString($imageString) {
72 |         $this->imageString = $imageString;
73 |     }
74 | 
75 |     /**
76 |      * @param mixed $transformationString
77 |      */
78 |     public function setTransformationString($transformationString) {
79 |         $this->transformationString = $transformationString;
80 |     }
81 | 
82 |     protected function __clone() {
83 |         $this->imageString = $this->transformationString;
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/src/Filters/JavaScript/Minification/JSMinifierFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\JavaScript\Minification;
 5 | 
 6 | use Kibo\Phast\Common\JSMinifier;
 7 | use Kibo\Phast\Filters\Service\CachedResultServiceFilter;
 8 | use Kibo\Phast\ValueObjects\Resource;
 9 | 
10 | class JSMinifierFilter implements CachedResultServiceFilter {
11 |     const VERSION = 3;
12 | 
13 |     private $removeLicenseHeaders = true;
14 | 
15 |     /**
16 |      * JSMinifierFilter constructor.
17 |      * @param bool $removeLicenseHeaders
18 |      */
19 |     public function __construct($removeLicenseHeaders) {
20 |         $this->removeLicenseHeaders = (bool) $removeLicenseHeaders;
21 |     }
22 | 
23 |     public function getCacheSalt(Resource $resource, array $request) {
24 |         return http_build_query([
25 |             'v' => self::VERSION,
26 |             'removeLicenseHeaders' => $this->removeLicenseHeaders,
27 |         ]);
28 |     }
29 | 
30 |     public function apply(Resource $resource, array $request) {
31 |         $minified = (new JSMinifier($resource->getContent(), $this->removeLicenseHeaders))->min();
32 |         return $resource->withContent($minified);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Filters/Service/CachedResultServiceFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Filters\Service;
 5 | 
 6 | use Kibo\Phast\Services\ServiceFilter;
 7 | use Kibo\Phast\ValueObjects\Resource;
 8 | 
 9 | interface CachedResultServiceFilter extends ServiceFilter {
10 |     /**
11 |      * @param Resource $resource
12 |      * @param array $request
13 |      * @return string
14 |      */
15 |     public function getCacheSalt(Resource $resource, array $request);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Filters/Text/Decode/Factory.php:
--------------------------------------------------------------------------------
1 | <?php
2 | namespace Kibo\Phast\Filters\Text\Decode;
3 | 
4 | class Factory {
5 |     public function make() {
6 |         return new Filter();
7 |     }
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Filters/Text/Decode/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Filters\Text\Decode;
 3 | 
 4 | use Kibo\Phast\Services\ServiceFilter;
 5 | use Kibo\Phast\ValueObjects\Resource;
 6 | 
 7 | class Filter implements ServiceFilter {
 8 |     const UTF8_BOM = "\xef\xbb\xbf";
 9 | 
10 |     public function apply(Resource $resource, array $request = []) {
11 |         $content = $resource->getContent();
12 |         if (substr($content, 0, strlen(self::UTF8_BOM)) == self::UTF8_BOM) {
13 |             $content = substr($content, strlen(self::UTF8_BOM));
14 |         }
15 |         return $resource->withContent($content);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/HTTP/Client.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\HTTP;
 4 | 
 5 | use Kibo\Phast\ValueObjects\URL;
 6 | 
 7 | interface Client {
 8 |     /**
 9 |      * Retrieve a URL using the GET HTTP method
10 |      *
11 |      * @param URL $url
12 |      * @param array $headers - headers to send in headerName => headerValue format
13 |      * @return Response
14 |      * @throws \Exception
15 |      */
16 |     public function get(URL $url, array $headers = []);
17 | 
18 |     /**
19 |      * Send data to a URL using the POST HTTP method
20 |      *
21 |      * @param URL $url
22 |      * @param array|string $data - if array, it will be encoded as form data, if string - will be sent as is
23 |      * @param array $headers - headers to send in headerName => headerValue format
24 |      * @return Response
25 |      * @throws \Exception
26 |      */
27 |     public function post(URL $url, $data, array $headers = []);
28 | }
29 | 


--------------------------------------------------------------------------------
/src/HTTP/ClientFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\HTTP;
 5 | 
 6 | use Kibo\Phast\Exceptions\RuntimeException;
 7 | 
 8 | class ClientFactory {
 9 |     const CONFIG_KEY = 'httpClient';
10 | 
11 |     /**
12 |      * @param array $config
13 |      * @return Client
14 |      */
15 |     public function make(array $config) {
16 |         $spec = $config[self::CONFIG_KEY];
17 | 
18 |         if (is_callable($spec)) {
19 |             $client = $spec();
20 |         } elseif (class_exists($spec)) {
21 |             $client = new $spec();
22 |         } else {
23 |             throw new RuntimeException(self::CONFIG_KEY . ' config value must be either callable or a class name');
24 |         }
25 | 
26 |         return $client;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/HTTP/Exceptions/HTTPError.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace Kibo\Phast\HTTP\Exceptions;
5 | 
6 | class HTTPError extends \RuntimeException {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/HTTP/Exceptions/NetworkError.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace Kibo\Phast\HTTP\Exceptions;
5 | 
6 | class NetworkError extends \RuntimeException {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/HTTP/Response.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\HTTP;
 4 | 
 5 | class Response {
 6 |     /**
 7 |      * @var int
 8 |      */
 9 |     private $code = 200;
10 | 
11 |     /**
12 |      * @var array
13 |      */
14 |     private $headers = [];
15 | 
16 |     /**
17 |      * @var string|iterable
18 |      */
19 |     private $content;
20 | 
21 |     /**
22 |      * @return int
23 |      */
24 |     public function getCode() {
25 |         return $this->code;
26 |     }
27 | 
28 |     /**
29 |      * @param int $code
30 |      */
31 |     public function setCode($code) {
32 |         $this->code = $code;
33 |     }
34 | 
35 |     /**
36 |      * @return array
37 |      */
38 |     public function getHeaders() {
39 |         return $this->headers;
40 |     }
41 | 
42 |     /**
43 |      * @param string $name
44 |      * @return string|null
45 |      */
46 |     public function getHeader($name) {
47 |         foreach ($this->headers as $k => $v) {
48 |             if (strcasecmp($name, $k) === 0) {
49 |                 return $v;
50 |             }
51 |         }
52 |         return null;
53 |     }
54 | 
55 |     public function setHeaders(array $headers) {
56 |         $this->headers = $headers;
57 |     }
58 | 
59 |     /**
60 |      * @param $name
61 |      * @param $value
62 |      */
63 |     public function setHeader($name, $value) {
64 |         $this->headers[$name] = $value;
65 |     }
66 | 
67 |     /**
68 |      * @return string|iterable
69 |      */
70 |     public function getContent() {
71 |         return $this->content;
72 |     }
73 | 
74 |     /**
75 |      * @param string|iterable $content
76 |      */
77 |     public function setContent($content) {
78 |         $this->content = $content;
79 |     }
80 | 
81 |     public function isCompressible() {
82 |         return strpos($this->getHeader('Content-Type'), 'image/') === false;
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/src/JSMin/UnterminatedCommentException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Kibo\Phast\JSMin;
4 | 
5 | class UnterminatedCommentException extends \Exception {
6 | }
7 | 


--------------------------------------------------------------------------------
/src/JSMin/UnterminatedRegExpException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Kibo\Phast\JSMin;
4 | 
5 | class UnterminatedRegExpException extends \Exception {
6 | }
7 | 


--------------------------------------------------------------------------------
/src/JSMin/UnterminatedStringException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Kibo\Phast\JSMin;
4 | 
5 | class UnterminatedStringException extends \Exception {
6 | }
7 | 


--------------------------------------------------------------------------------
/src/Logging/Common/JSONLFileLogTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Logging\Common;
 4 | 
 5 | trait JSONLFileLogTrait {
 6 |     /**
 7 |      * @var string
 8 |      */
 9 |     private $dir;
10 | 
11 |     /**
12 |      * @var string
13 |      */
14 |     private $filename;
15 | 
16 |     /**
17 |      * JSONLFileLogWriter constructor.
18 |      * @param string $dir
19 |      * @param string $suffix
20 |      */
21 |     public function __construct($dir, $suffix) {
22 |         $this->dir = $dir;
23 |         $suffix = preg_replace('/[^0-9A-Za-z_-]/', '', (string) $suffix);
24 |         if (!empty($suffix)) {
25 |             $suffix = '-' . $suffix;
26 |         }
27 |         $this->filename = $this->dir . '/log' . $suffix . '.jsonl';
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Logging/LogEntry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Logging;
 4 | 
 5 | class LogEntry implements \JsonSerializable {
 6 |     /**
 7 |      * @var int
 8 |      */
 9 |     private $level;
10 | 
11 |     /**
12 |      * @var string
13 |      */
14 |     private $message;
15 | 
16 |     /**
17 |      * @var array
18 |      */
19 |     private $context;
20 | 
21 |     /**
22 |      * LogEntry constructor.
23 |      * @param int $level
24 |      * @param string $message
25 |      * @param array $context
26 |      */
27 |     public function __construct($level, $message, array $context) {
28 |         $this->level = (int) $level;
29 |         $this->message = $message;
30 |         $this->context = $context;
31 |     }
32 | 
33 |     /**
34 |      * @return int
35 |      */
36 |     public function getLevel() {
37 |         return $this->level;
38 |     }
39 | 
40 |     /**
41 |      * @return string
42 |      */
43 |     public function getMessage() {
44 |         return $this->message;
45 |     }
46 | 
47 |     /**
48 |      * @return array
49 |      */
50 |     public function getContext() {
51 |         return $this->context;
52 |     }
53 | 
54 |     public function toArray(): array {
55 |         return [
56 |             'level' => $this->level,
57 |             'message' => $this->message,
58 |             'context' => $this->context,
59 |         ];
60 |     }
61 | 
62 |     public function jsonSerialize(): array {
63 |         return $this->toArray();
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/Logging/LogLevel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Logging;
 3 | 
 4 | class LogLevel {
 5 |     const EMERGENCY = 128;
 6 | 
 7 |     const ALERT     =  64;
 8 | 
 9 |     const CRITICAL  =  32;
10 | 
11 |     const ERROR     =  16;
12 | 
13 |     const WARNING   =   8;
14 | 
15 |     const NOTICE    =   4;
16 | 
17 |     const INFO      =   2;
18 | 
19 |     const DEBUG     =   1;
20 | 
21 |     public static function toString($level) {
22 |         switch ($level) {
23 |         case self::EMERGENCY:   return 'EMERGENCY';
24 |         case self::ALERT:       return 'ALERT';
25 |         case self::CRITICAL:    return 'CRITICAL';
26 |         case self::ERROR:       return 'ERROR';
27 |         case self::WARNING:     return 'WARNING';
28 |         case self::NOTICE:      return 'NOTICE';
29 |         case self::INFO:        return 'INFO';
30 |         case self::DEBUG:       return 'DEBUG';
31 |         default:                return 'UNKNOWN';
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Logging/LogReader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Logging;
 4 | 
 5 | interface LogReader {
 6 |     /**
 7 |      * Reads LogMessage objects
 8 |      *
 9 |      * @return \Generator
10 |      */
11 |     public function readEntries();
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Logging/LogReaders/JSONLFile/Reader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Logging\LogReaders\JSONLFile;
 4 | 
 5 | use Kibo\Phast\Logging\Common\JSONLFileLogTrait;
 6 | use Kibo\Phast\Logging\LogEntry;
 7 | use Kibo\Phast\Logging\LogReader;
 8 | 
 9 | class Reader implements LogReader {
10 |     use JSONLFileLogTrait;
11 | 
12 |     public function readEntries() {
13 |         $fp = @fopen($this->filename, 'r');
14 |         while ($fp && ($row = @fgets($fp))) {
15 |             $decoded = @json_decode($row, true);
16 |             if (!$decoded) {
17 |                 continue;
18 |             }
19 |             yield new LogEntry(@$decoded['level'], @$decoded['message'], @$decoded['context']);
20 |         }
21 |         @fclose($fp);
22 |         @unlink($this->filename);
23 |     }
24 | 
25 |     public function __destruct() {
26 |         if (!($dir = @opendir($this->dir))) {
27 |             return;
28 |         }
29 |         $tenMinutesAgo = time() - 600;
30 |         while ($file = @readdir($dir)) {
31 |             $filename = $this->dir . "/$file";
32 |             if (preg_match('/\.jsonl$/', $file) && @filectime($filename) < $tenMinutesAgo) {
33 |                 @unlink($filename);
34 |             }
35 |         }
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Logging/LogWriter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Logging;
 4 | 
 5 | interface LogWriter {
 6 |     /**
 7 |      * Set a bit-mask to filter entries that are actually written
 8 |      *
 9 |      * @param int $mask
10 |      * @return void
11 |      */
12 |     public function setLevelMask($mask);
13 | 
14 |     /**
15 |      * Write an entry to the log
16 |      *
17 |      * @param LogEntry $entry
18 |      * @return void
19 |      */
20 |     public function writeEntry(LogEntry $entry);
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Logging/LogWriters/BaseLogWriter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Logging\LogWriters;
 5 | 
 6 | use Kibo\Phast\Logging\LogEntry;
 7 | use Kibo\Phast\Logging\LogWriter;
 8 | 
 9 | abstract class BaseLogWriter implements LogWriter {
10 |     protected $levelMask = ~0;
11 | 
12 |     abstract protected function doWriteEntry(LogEntry $entry);
13 | 
14 |     public function setLevelMask($mask) {
15 |         $this->levelMask = $mask;
16 |     }
17 | 
18 |     public function writeEntry(LogEntry $entry) {
19 |         if ($this->levelMask & $entry->getLevel()) {
20 |             $this->doWriteEntry($entry);
21 |         }
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Logging/LogWriters/Composite/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Logging\LogWriters\Composite;
 5 | 
 6 | use Kibo\Phast\Logging\LogWriters\Factory as WritersFactory;
 7 | use Kibo\Phast\Services\ServiceRequest;
 8 | 
 9 | class Factory {
10 |     public function make(array $config, ServiceRequest $request) {
11 |         $writer = new Writer();
12 |         $factory = new WritersFactory();
13 |         foreach ($config['logWriters'] as $writerConfig) {
14 |             $writer->addWriter($factory->make($writerConfig, $request));
15 |         }
16 |         return $writer;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Logging/LogWriters/Composite/Writer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Logging\LogWriters\Composite;
 4 | 
 5 | use Kibo\Phast\Logging\LogEntry;
 6 | use Kibo\Phast\Logging\LogWriter;
 7 | use Kibo\Phast\Logging\LogWriters\BaseLogWriter;
 8 | 
 9 | class Writer extends BaseLogWriter {
10 |     /**
11 |      * @var Writer[]
12 |      */
13 |     private $writers = [];
14 | 
15 |     public function addWriter(LogWriter $writer) {
16 |         $this->writers[] = $writer;
17 |     }
18 | 
19 |     protected function doWriteEntry(LogEntry $entry) {
20 |         foreach ($this->writers as $writer) {
21 |             $writer->writeEntry($entry);
22 |         }
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Logging/LogWriters/Dummy/Writer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Logging\LogWriters\Dummy;
 5 | 
 6 | use Kibo\Phast\Logging\LogEntry;
 7 | use Kibo\Phast\Logging\LogWriter;
 8 | 
 9 | class Writer implements LogWriter {
10 |     public function setLevelMask($mask) {
11 |     }
12 | 
13 |     public function writeEntry(LogEntry $entry) {
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Logging/LogWriters/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Logging\LogWriters;
 5 | 
 6 | use Kibo\Phast\Environment\Package;
 7 | use Kibo\Phast\Logging\LogWriters\Composite\Writer;
 8 | use Kibo\Phast\Services\ServiceRequest;
 9 | 
10 | class Factory {
11 |     public function make(array $config, ServiceRequest $request) {
12 |         if (isset($config['logWriters']) && count($config['logWriters']) > 1) {
13 |             $class = Writer::class;
14 |         } elseif (isset($config['logWriters'])) {
15 |             $config = array_pop($config['logWriters']);
16 |             $class = $config['class'];
17 |         } else {
18 |             $class = $config['class'];
19 |         }
20 |         $package = Package::fromPackageClass($class);
21 |         $writer = $package->getFactory()->make($config, $request);
22 |         if (isset($config['levelMask'])) {
23 |             $writer->setLevelMask($config['levelMask']);
24 |         }
25 |         return $writer;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Logging/LogWriters/JSONLFile/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Logging\LogWriters\JSONLFile;
 5 | 
 6 | use Kibo\Phast\Services\ServiceRequest;
 7 | 
 8 | class Factory {
 9 |     public function make(array $config, ServiceRequest $request) {
10 |         return new \Kibo\Phast\Logging\LogWriters\JSONLFile\Writer($config['logRoot'], $request->getDocumentRequestId());
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Logging/LogWriters/JSONLFile/Writer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Logging\LogWriters\JSONLFile;
 4 | 
 5 | use Kibo\Phast\Common\JSON;
 6 | use Kibo\Phast\Logging\Common\JSONLFileLogTrait;
 7 | use Kibo\Phast\Logging\LogEntry;
 8 | use Kibo\Phast\Logging\LogWriters\BaseLogWriter;
 9 | 
10 | class Writer extends BaseLogWriter {
11 |     use JSONLFileLogTrait;
12 | 
13 |     /**
14 |      * @param LogEntry $entry
15 |      */
16 |     protected function doWriteEntry(LogEntry $entry) {
17 |         $encoded = @JSON::encode($entry->toArray());
18 |         if ($encoded) {
19 |             $this->makeDirIfNotExists();
20 |             @file_put_contents($this->filename, $encoded . "\n", FILE_APPEND | LOCK_EX);
21 |         }
22 |     }
23 | 
24 |     private function makeDirIfNotExists() {
25 |         if (!@file_exists($this->dir)) {
26 |             @mkdir($this->dir, 0777, true);
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Logging/LogWriters/PHPError/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Logging\LogWriters\PHPError;
 5 | 
 6 | use Kibo\Phast\Services\ServiceRequest;
 7 | 
 8 | class Factory {
 9 |     public function make(array $config, ServiceRequest $request) {
10 |         return new Writer($config);
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Logging/LogWriters/PHPError/Writer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Logging\LogWriters\PHPError;
 4 | 
 5 | use Kibo\Phast\Common\ObjectifiedFunctions;
 6 | use Kibo\Phast\Logging\LogEntry;
 7 | use Kibo\Phast\Logging\LogWriters\BaseLogWriter;
 8 | 
 9 | class Writer extends BaseLogWriter {
10 |     private $messageType = 0;
11 | 
12 |     private $destination = null;
13 | 
14 |     private $extraHeaders = null;
15 | 
16 |     /**
17 |      * @var ObjectifiedFunctions
18 |      */
19 |     private $funcs;
20 | 
21 |     /**
22 |      * PHPErrorLogWriter constructor.
23 |      * @param array $config
24 |      * @param ObjectifiedFunctions $funcs
25 |      */
26 |     public function __construct(array $config, ObjectifiedFunctions $funcs = null) {
27 |         foreach (['messageType', 'destination', 'extraHeaders'] as $field) {
28 |             if (isset($config[$field])) {
29 |                 $this->$field = $config[$field];
30 |             }
31 |         }
32 |         $this->funcs = is_null($funcs) ? new ObjectifiedFunctions() : $funcs;
33 |     }
34 | 
35 |     protected function doWriteEntry(LogEntry $entry) {
36 |         if ($this->levelMask & $entry->getLevel()) {
37 |             $this->funcs->error_log(
38 |                 $this->interpolate($entry->getMessage(), $entry->getContext()),
39 |                 $this->messageType,
40 |                 $this->destination,
41 |                 $this->extraHeaders
42 |             );
43 |         }
44 |     }
45 | 
46 |     private function interpolate($message, $context) {
47 |         $prefix = '';
48 |         $prefixKeys = [
49 |             'requestId',
50 |             'service',
51 |             'class',
52 |             'method',
53 |             'line',
54 |         ];
55 |         foreach ($prefixKeys as $key) {
56 |             if (isset($context[$key])) {
57 |                 $prefix .= '{' . $key . "}\t";
58 |             }
59 |         }
60 |         return preg_replace_callback('/{(.+?)}/', function ($match) use ($context) {
61 |             return array_key_exists($match[1], $context) ? $context[$match[1]] : $match[0];
62 |         }, $prefix . $message);
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/Logging/LogWriters/RotatingTextFile/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Logging\LogWriters\RotatingTextFile;
 3 | 
 4 | use Kibo\Phast\Services\ServiceRequest;
 5 | 
 6 | class Factory {
 7 |     public function make(array $config, ServiceRequest $request) {
 8 |         return new Writer($config);
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Logging/LoggingTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Logging;
 4 | 
 5 | trait LoggingTrait {
 6 |     protected function logger($method = null, $line = null) {
 7 |         $context = ['class' => get_class($this)];
 8 |         if (!is_null($method)) {
 9 |             $context['method'] = $method;
10 |         }
11 |         if (!is_null($line)) {
12 |             $context['line'] = $line;
13 |         }
14 |         return Log::context($context);
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Parsing/HTML/HTMLStreamElements/ClosingTag.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Parsing\HTML\HTMLStreamElements;
 5 | 
 6 | class ClosingTag extends Element {
 7 |     /**
 8 |      * @var string
 9 |      */
10 |     private $tagName;
11 | 
12 |     /**
13 |      * ClosingTag constructor.
14 |      * @param string $tagName
15 |      */
16 |     public function __construct($tagName) {
17 |         $this->tagName = strtolower($tagName);
18 |     }
19 | 
20 |     /**
21 |      * @return string
22 |      */
23 |     public function getTagName() {
24 |         return $this->tagName;
25 |     }
26 | 
27 |     public function appendChild(Element $element) {
28 |         $this->stream->insertBeforeElement($this, $element);
29 |     }
30 | 
31 |     public function dumpValue() {
32 |         return $this->tagName;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Parsing/HTML/HTMLStreamElements/Comment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Parsing\HTML\HTMLStreamElements;
 5 | 
 6 | class Comment extends Element {
 7 |     public function isIEConditional() {
 8 |         return (bool) preg_match('/^<!--\[if\s/', $this->originalString);
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Parsing/HTML/HTMLStreamElements/Element.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Parsing\HTML\HTMLStreamElements;
 5 | 
 6 | use Kibo\Phast\Common\JSON;
 7 | 
 8 | class Element {
 9 |     /**
10 |      * @var string
11 |      */
12 |     public $originalString;
13 | 
14 |     /**
15 |      * @param string $originalString
16 |      */
17 |     public function setOriginalString($originalString) {
18 |         $this->originalString = $originalString;
19 |     }
20 | 
21 |     public function __get($name) {
22 |         $method = 'get' . ucfirst($name);
23 |         if (method_exists($this, $method)) {
24 |             return call_user_func([$this, $method]);
25 |         }
26 |     }
27 | 
28 |     public function __set($name, $value) {
29 |         $method = 'set' . ucfirst($name);
30 |         if (method_exists($this, $method)) {
31 |             return call_user_func([$this, $method], $value);
32 |         }
33 |     }
34 | 
35 |     public function toString() {
36 |         return $this->__toString();
37 |     }
38 | 
39 |     public function __toString() {
40 |         return isset($this->originalString) ? $this->originalString : '';
41 |     }
42 | 
43 |     public function dump() {
44 |         return '<' . preg_replace('~^.*\\\\~', '', get_class($this)) . ' ' . $this->dumpValue() . '>';
45 |     }
46 | 
47 |     public function dumpValue() {
48 |         return JSON::encode($this->originalString);
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Parsing/HTML/HTMLStreamElements/Junk.php:
--------------------------------------------------------------------------------
1 | <?php
2 | namespace Kibo\Phast\Parsing\HTML\HTMLStreamElements;
3 | 
4 | class Junk extends Element {
5 | }
6 | 


--------------------------------------------------------------------------------
/src/Retrievers/CachingRetriever.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Retrievers;
 4 | 
 5 | use Kibo\Phast\Cache\Cache;
 6 | use Kibo\Phast\ValueObjects\URL;
 7 | 
 8 | class CachingRetriever implements Retriever {
 9 |     use DynamicCacheSaltTrait {
10 |         getCacheSalt as getDynamicCacheSalt;
11 |     }
12 | 
13 |     /**
14 |      * @var Cache
15 |      */
16 |     private $cache;
17 | 
18 |     /**
19 |      * @var Retriever
20 |      */
21 |     private $retriever;
22 | 
23 |     /**
24 |      * CachingRetriever constructor.
25 |      *
26 |      * @param Retriever $retriever
27 |      * @param Cache $cache
28 |      * @param int $defaultCacheTime
29 |      */
30 |     public function __construct(Cache $cache, Retriever $retriever = null, $defaultCacheTime = 0) {
31 |         $this->cache = $cache;
32 |         $this->retriever = $retriever;
33 |     }
34 | 
35 |     public function retrieve(URL $url) {
36 |         if ($this->retriever) {
37 |             return $this->getCachedWithRetriever($url);
38 |         }
39 |         return $this->getFromCacheOnly($url);
40 |     }
41 | 
42 |     public function getCacheSalt(URL $url) {
43 |         if ($this->retriever) {
44 |             return $this->retriever->getCacheSalt($url);
45 |         }
46 |         return $this->getDynamicCacheSalt($url);
47 |     }
48 | 
49 |     private function getCachedWithRetriever(URL $url) {
50 |         return $this->cache->get($this->getCacheKey($url), function () use ($url) {
51 |             return $this->retriever->retrieve($url);
52 |         });
53 |     }
54 | 
55 |     private function getFromCacheOnly(URL $url) {
56 |         $cached = $this->cache->get($this->getCacheKey($url));
57 |         if (!$cached) {
58 |             return false;
59 |         }
60 |         return $cached;
61 |     }
62 | 
63 |     private function getCacheKey(URL $url) {
64 |         return $url . '-' . $this->getCacheSalt($url);
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Retrievers/DynamicCacheSaltTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Retrievers;
 5 | 
 6 | use Kibo\Phast\ValueObjects\URL;
 7 | 
 8 | trait DynamicCacheSaltTrait {
 9 |     public function getCacheSalt(URL $url) {
10 |         return md5($url->toString()) . '-' . floor(time() / 7200);
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Retrievers/PostDataRetriever.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Retrievers;
 5 | 
 6 | use Kibo\Phast\Common\ObjectifiedFunctions;
 7 | use Kibo\Phast\ValueObjects\URL;
 8 | 
 9 | class PostDataRetriever implements Retriever {
10 |     /**
11 |      * @var ObjectifiedFunctions
12 |      */
13 |     private $funcs;
14 | 
15 |     private $content;
16 | 
17 |     /**
18 |      * PostDataRetriever constructor.
19 |      * @param ObjectifiedFunctions $funcs
20 |      */
21 |     public function __construct(ObjectifiedFunctions $funcs = null) {
22 |         $this->funcs = is_null($funcs) ? new ObjectifiedFunctions() : $funcs;
23 |     }
24 | 
25 |     public function retrieve(URL $url) {
26 |         if (!isset($this->content)) {
27 |             $this->content = $this->funcs->file_get_contents('php://input');
28 |         }
29 |         return $this->content;
30 |     }
31 | 
32 |     public function getCacheSalt(URL $url) {
33 |         return md5($this->retrieve($url));
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Retrievers/RemoteRetriever.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Retrievers;
 4 | 
 5 | use Kibo\Phast\HTTP\Client;
 6 | use Kibo\Phast\Logging\LoggingTrait;
 7 | use Kibo\Phast\ValueObjects\URL;
 8 | 
 9 | class RemoteRetriever implements Retriever {
10 |     use DynamicCacheSaltTrait;
11 |     use LoggingTrait;
12 | 
13 |     private $client;
14 | 
15 |     public function __construct(Client $client) {
16 |         $this->client = $client;
17 |     }
18 | 
19 |     public function retrieve(URL $url) {
20 |         $cdnLoop = ['Phast'];
21 |         if (!empty($_SERVER['HTTP_CDN_LOOP'])) {
22 |             $cdnLoop[] = $_SERVER['HTTP_CDN_LOOP'];
23 |         }
24 |         try {
25 |             $response = $this->client->get($url, [
26 |                 'User-Agent' => 'Mozilla/5.0 (X11; Fedora; Linux x86_64; rv:56.0) Gecko/20100101 Firefox/56.0',
27 |                 'CDN-Loop' => implode(', ', $cdnLoop),
28 |             ]);
29 |         } catch (\Exception $e) {
30 |             $this->logger()->warning('Caught {cls} while fetching {url}: ({code}) {message}', [
31 |                 'cls' => get_class($e),
32 |                 'url' => (string) $url,
33 |                 'code' => $e->getCode(),
34 |                 'message' => $e->getMessage(),
35 |             ]);
36 |             return false;
37 |         }
38 |         return $response->getContent();
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Retrievers/RemoteRetrieverFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Retrievers;
 4 | 
 5 | use Kibo\Phast\HTTP\ClientFactory;
 6 | 
 7 | class RemoteRetrieverFactory {
 8 |     public function make(array $config) {
 9 |         return new RemoteRetriever(
10 |             (new ClientFactory())->make($config)
11 |         );
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Retrievers/Retriever.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Retrievers;
 4 | 
 5 | use Kibo\Phast\ValueObjects\URL;
 6 | 
 7 | interface Retriever {
 8 |     /**
 9 |      * @param URL $url
10 |      * @return string|bool
11 |      */
12 |     public function retrieve(URL $url);
13 | 
14 |     /**
15 |      * @param URL $url
16 |      * @return integer|bool
17 |      */
18 |     public function getCacheSalt(URL $url);
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Retrievers/UniversalRetriever.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Retrievers;
 4 | 
 5 | use Kibo\Phast\ValueObjects\URL;
 6 | 
 7 | class UniversalRetriever implements Retriever {
 8 |     /**
 9 |      * @var Retriever[]
10 |      */
11 |     private $retrievers = [];
12 | 
13 |     public function retrieve(URL $url) {
14 |         return $this->iterateRetrievers(function (Retriever $retriever) use ($url) {
15 |             return $retriever->retrieve($url);
16 |         });
17 |     }
18 | 
19 |     public function getCacheSalt(URL $url) {
20 |         return $this->iterateRetrievers(function (Retriever $retriever) use ($url) {
21 |             return $retriever->getCacheSalt($url);
22 |         });
23 |     }
24 | 
25 |     private function iterateRetrievers(callable $callback) {
26 |         foreach ($this->retrievers as $retriever) {
27 |             $result = $callback($retriever);
28 |             if ($result !== false) {
29 |                 return $result;
30 |             }
31 |         }
32 |         return false;
33 |     }
34 | 
35 |     public function addRetriever(Retriever $retriever) {
36 |         $this->retrievers[] = $retriever;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Security/ServiceSignatureFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Security;
 4 | 
 5 | use Kibo\Phast\Cache\Sqlite\Cache;
 6 | 
 7 | class ServiceSignatureFactory {
 8 |     const CACHE_NAMESPACE = 'signature';
 9 | 
10 |     public function make(array $config) {
11 |         $cache = new Cache(array_merge($config['cache'], [
12 |             'name' => self::CACHE_NAMESPACE,
13 |             'maxSize' => 1024 * 1024,
14 |         ]), self::CACHE_NAMESPACE);
15 |         $signature = new ServiceSignature($cache);
16 |         if (isset($config['securityToken'])) {
17 |             $signature->setIdentities($config['securityToken']);
18 |         }
19 |         return $signature;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Services/Bundler/BundlerParamsParser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Services\Bundler;
 5 | 
 6 | use Kibo\Phast\Services\ServiceRequest;
 7 | 
 8 | class BundlerParamsParser {
 9 |     public function parse(ServiceRequest $request) {
10 |         $result = [];
11 |         foreach ($request->getParams() as $name => $value) {
12 |             if (strpos($name, '_') !== false) {
13 |                 list($name, $key) = explode('_', $name, 2);
14 |                 $result[$key][$name] = $value;
15 |             }
16 |         }
17 |         return $result;
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Services/Bundler/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Services\Bundler;
 5 | 
 6 | use \Kibo\Phast\Services\Css;
 7 | use \Kibo\Phast\Services\Scripts;
 8 | use Kibo\Phast\Security\ServiceSignatureFactory;
 9 | use Kibo\Phast\Services\ServiceFactoryTrait;
10 | 
11 | class Factory {
12 |     use ServiceFactoryTrait;
13 | 
14 |     public function make(array $config) {
15 |         $cssServiceFactory = new Css\Factory();
16 |         $jsServiceFactory = new Scripts\Factory();
17 | 
18 |         $cssFilter = $this->makeCachingServiceFilter(
19 |             $config,
20 |             $cssServiceFactory->makeFilter($config),
21 |             'bundler-css'
22 |         );
23 | 
24 |         $jsFilter = $this->makeCachingServiceFilter(
25 |             $config,
26 |             $jsServiceFactory->makeFilter($config),
27 |             'bundler-js'
28 |         );
29 | 
30 |         return new Service(
31 |             (new ServiceSignatureFactory())->make($config),
32 |             $cssServiceFactory->makeRetriever($config),
33 |             $cssFilter,
34 |             $jsServiceFactory->makeRetriever($config),
35 |             $jsFilter,
36 |             (new TokenRefMakerFactory())->make($config)
37 |         );
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Services/Bundler/TokenRefMaker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Services\Bundler;
 3 | 
 4 | use Kibo\Phast\Cache\Cache;
 5 | use Kibo\Phast\Common\Base64url;
 6 | use Kibo\Phast\Common\JSON;
 7 | 
 8 | class TokenRefMaker {
 9 |     private $cache;
10 | 
11 |     public function __construct(Cache $cache) {
12 |         $this->cache = $cache;
13 |     }
14 | 
15 |     public function getRef($token, array $params) {
16 |         $ref = Base64url::shortHash(JSON::encode($params));
17 |         $cachedParams = $this->cache->get($ref);
18 |         if (!$cachedParams) {
19 |             $this->cache->set($ref, $params);
20 |             $cachedParams = $this->cache->get($ref);
21 |         }
22 |         if ($cachedParams === $params) {
23 |             return $ref;
24 |         }
25 |     }
26 | 
27 |     public function getParams($ref) {
28 |         return $this->cache->get($ref);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Services/Bundler/TokenRefMakerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Services\Bundler;
 3 | 
 4 | use Kibo\Phast\Cache\Sqlite\Cache;
 5 | 
 6 | class TokenRefMakerFactory {
 7 |     public function make(array $config) {
 8 |         $cache = new Cache($config['cache'], 'token-refs');
 9 |         return new TokenRefMaker($cache);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Services/Css/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Services\Css;
 4 | 
 5 | use Kibo\Phast\Filters\CSS\Composite\Factory as CSSCompositeFilterFactory;
 6 | use Kibo\Phast\Security\ServiceSignatureFactory;
 7 | use Kibo\Phast\Services\ServiceFactoryTrait;
 8 | 
 9 | class Factory {
10 |     use ServiceFactoryTrait;
11 | 
12 |     public function make(array $config) {
13 |         $cssComposite = $this->makeFilter($config);
14 |         $composite = $this->makeCachingServiceFilter($config, $cssComposite, 'css-processing-2');
15 | 
16 |         return new Service(
17 |             (new ServiceSignatureFactory())->make($config),
18 |             [],
19 |             $this->makeRetriever($config),
20 |             $composite,
21 |             $config
22 |         );
23 |     }
24 | 
25 |     public function makeRetriever(array $config) {
26 |         return $this->makeUniversalCachingRetriever($config, 'css');
27 |     }
28 | 
29 |     public function makeFilter(array $config) {
30 |         return (new CSSCompositeFilterFactory())->make($config);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Services/Css/Service.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Services\Css;
 4 | 
 5 | use Kibo\Phast\Services\BaseService;
 6 | use Kibo\Phast\ValueObjects\Resource;
 7 | 
 8 | class Service extends BaseService {
 9 |     protected function makeResponse(Resource $resource, array $request) {
10 |         $response = parent::makeResponse($resource, $request);
11 |         $response->setHeader('Content-Type', 'text/css');
12 |         return $response;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Services/Diagnostics/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Services\Diagnostics;
 5 | 
 6 | use Kibo\Phast\Logging\LogWriters\JSONLFile\Writer;
 7 | 
 8 | class Factory {
 9 |     public function make(array $config) {
10 |         $logRoot = null;
11 |         foreach ($config['logging']['logWriters'] as $writerConfig) {
12 |             if ($writerConfig['class'] == Writer::class) {
13 |                 $logRoot = $writerConfig['logRoot'];
14 |                 break;
15 |             }
16 |         }
17 |         return new Service($logRoot);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Services/Diagnostics/Service.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Services\Diagnostics;
 5 | 
 6 | use Kibo\Phast\Common\JSON;
 7 | use Kibo\Phast\Diagnostics\SystemDiagnostics;
 8 | use Kibo\Phast\HTTP\Response;
 9 | use Kibo\Phast\Logging\LogReaders\JSONLFile\Reader;
10 | use Kibo\Phast\Services\ServiceRequest;
11 | 
12 | class Service {
13 |     private $logRoot;
14 | 
15 |     public function __construct($logRoot) {
16 |         $this->logRoot = $logRoot;
17 |     }
18 | 
19 |     public function serve(ServiceRequest $request) {
20 |         $params = $request->getParams();
21 |         if (isset($params['documentRequestId'])) {
22 |             $items = $this->getRequestLog($params['documentRequestId']);
23 |         } else {
24 |             $items = $this->getSystemDiagnostics();
25 |         }
26 | 
27 |         $response = new Response();
28 |         $response->setContent(JSON::prettyEncode($items));
29 |         $response->setHeader('Content-Type', 'application/json');
30 |         return $response;
31 |     }
32 | 
33 |     private function getRequestLog($requestId) {
34 |         return iterator_to_array((new Reader($this->logRoot, $requestId))->readEntries());
35 |     }
36 | 
37 |     private function getSystemDiagnostics() {
38 |         return (new SystemDiagnostics())->run(require PHAST_CONFIG_FILE);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Services/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Services;
 4 | 
 5 | use Kibo\Phast\Exceptions\ItemNotFoundException;
 6 | 
 7 | class Factory {
 8 |     /**
 9 |      * @param string $service
10 |      * @param array $config
11 |      * @return BaseService
12 |      * @throws ItemNotFoundException
13 |      */
14 |     public function make($service, array $config) {
15 |         if (!preg_match('/^[a-z]+$/', $service)) {
16 |             throw new ItemNotFoundException('Bad service');
17 |         }
18 |         $class = __NAMESPACE__ . '\\' . ucfirst($service) . '\\Factory';
19 |         if (class_exists($class)) {
20 |             return (new $class())->make($config);
21 |         }
22 |         throw new ItemNotFoundException('Unknown service');
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Services/Images/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Services\Images;
 4 | 
 5 | use Kibo\Phast\Filters\Image\Composite\Factory as CompositeImageFilterFactory;
 6 | use Kibo\Phast\Retrievers\LocalRetriever;
 7 | use Kibo\Phast\Retrievers\PostDataRetriever;
 8 | use Kibo\Phast\Retrievers\RemoteRetrieverFactory;
 9 | use Kibo\Phast\Retrievers\UniversalRetriever;
10 | use Kibo\Phast\Security\ServiceSignatureFactory;
11 | 
12 | class Factory {
13 |     public function make(array $config) {
14 |         if ($config['images']['api-mode']) {
15 |             $retriever = new PostDataRetriever();
16 |         } else {
17 |             $retriever = new UniversalRetriever();
18 |             $retriever->addRetriever(new LocalRetriever($config['retrieverMap']));
19 |             $retriever->addRetriever((new RemoteRetrieverFactory())->make($config));
20 |         }
21 |         return new Service(
22 |             (new ServiceSignatureFactory())->make($config),
23 |             $config['images']['whitelist'],
24 |             $retriever,
25 |             (new CompositeImageFilterFactory($config))->make(),
26 |             $config
27 |         );
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Services/Images/Service.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Services\Images;
 4 | 
 5 | use Kibo\Phast\Filters\Image\Image;
 6 | use Kibo\Phast\HTTP\Request;
 7 | use Kibo\Phast\Logging\Log;
 8 | use Kibo\Phast\Services\BaseService;
 9 | use Kibo\Phast\Services\ServiceRequest;
10 | use Kibo\Phast\ValueObjects\Resource;
11 | 
12 | class Service extends BaseService {
13 |     protected function getParams(ServiceRequest $request) {
14 |         $params = parent::getParams($request);
15 |         if ($this->proxySupportsAccept($request->getHTTPRequest())) {
16 |             $params['varyAccept'] = true;
17 |             if ($this->browserSupportsWebp($request->getHTTPRequest())) {
18 |                 $params['preferredType'] = Image::TYPE_WEBP;
19 |                 Log::info('WebP will be served if possible!');
20 |             }
21 |         }
22 |         return $params;
23 |     }
24 | 
25 |     protected function makeResponse(Resource $resource, array $request) {
26 |         $response = parent::makeResponse($resource, $request);
27 |         $srcUrl = $resource->getUrl();
28 |         $response->setHeader('Link', "<$srcUrl>; rel=\"canonical\"");
29 |         $response->setHeader('Content-Type', $resource->getMimeType());
30 |         if ($resource->getMimeType() != Image::TYPE_PNG
31 |             && @$request['varyAccept']
32 |         ) {
33 |             $response->setHeader('Vary', 'Accept');
34 |         }
35 |         return $response;
36 |     }
37 | 
38 |     protected function validateIntegrity(ServiceRequest $request) {
39 |         if (!$this->config['images']['api-mode']) {
40 |             parent::validateIntegrity($request);
41 |         }
42 |     }
43 | 
44 |     protected function validateWhitelisted(ServiceRequest $request) {
45 |         if (!$this->config['images']['api-mode']) {
46 |             parent::validateWhitelisted($request);
47 |         }
48 |     }
49 | 
50 |     private function browserSupportsWebp(Request $request) {
51 |         return strpos($request->getHeader('accept'), 'image/webp') !== false;
52 |     }
53 | 
54 |     private function proxySupportsAccept(Request $request) {
55 |         return !$request->isCloudflare();
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Services/Scripts/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Services\Scripts;
 4 | 
 5 | use Kibo\Phast\Filters\JavaScript\Minification\JSMinifierFilter;
 6 | use Kibo\Phast\Filters\Service\CompositeFilter;
 7 | use Kibo\Phast\Filters\Text\Decode\Filter as DecodeFilter;
 8 | use Kibo\Phast\Security\ServiceSignatureFactory;
 9 | use Kibo\Phast\Services\ServiceFactoryTrait;
10 | 
11 | class Factory {
12 |     use ServiceFactoryTrait;
13 | 
14 |     public function make(array $config) {
15 |         $cachedComposite = $this->makeFilter($config);
16 | 
17 |         return new Service(
18 |             (new ServiceSignatureFactory())->make($config),
19 |             $config['scripts']['whitelist'],
20 |             $this->makeRetriever($config),
21 |             $this->makeCachingServiceFilter($config, $cachedComposite, 'scripts-minified'),
22 |             $config
23 |         );
24 |     }
25 | 
26 |     public function makeRetriever(array $config) {
27 |         return $this->makeUniversalCachingRetriever($config, 'scripts');
28 |     }
29 | 
30 |     public function makeFilter(array $config) {
31 |         $filter = new CompositeFilter();
32 |         $filter->addFilter(new DecodeFilter());
33 |         $filter->addFilter(new JSMinifierFilter(@$config['scripts']['removeLicenseHeaders']));
34 |         return $filter;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Services/Scripts/Service.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Services\Scripts;
 4 | 
 5 | use Kibo\Phast\Services\BaseService;
 6 | use Kibo\Phast\ValueObjects\Resource;
 7 | 
 8 | class Service extends BaseService {
 9 |     protected function makeResponse(Resource $resource, array $request) {
10 |         $response = parent::makeResponse($resource, $request);
11 |         $response->setHeader('Content-Type', 'application/javascript');
12 |         return $response;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Services/ServiceFactoryTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Services;
 5 | 
 6 | use Kibo\Phast\Cache\Sqlite\Cache;
 7 | use Kibo\Phast\Filters\Service\CachingServiceFilter;
 8 | use Kibo\Phast\Filters\Service\CompositeFilter;
 9 | use Kibo\Phast\Retrievers\CachingRetriever;
10 | use Kibo\Phast\Retrievers\LocalRetriever;
11 | use Kibo\Phast\Retrievers\RemoteRetrieverFactory;
12 | use Kibo\Phast\Retrievers\UniversalRetriever;
13 | 
14 | trait ServiceFactoryTrait {
15 |     /**
16 |      * @param array $config
17 |      * @param $cacheNamespace
18 |      * @return UniversalRetriever
19 |      */
20 |     public function makeUniversalCachingRetriever(array $config, $cacheNamespace) {
21 |         $retriever = new UniversalRetriever();
22 |         $retriever->addRetriever(new LocalRetriever($config['retrieverMap']));
23 |         $retriever->addRetriever(
24 |             new CachingRetriever(
25 |                 new Cache($config['cache'], $cacheNamespace),
26 |                 (new RemoteRetrieverFactory())->make($config)
27 |             )
28 |         );
29 |         return $retriever;
30 |     }
31 | 
32 |     public function makeCachingServiceFilter(array $config, CompositeFilter $compositeFilter, $cacheNamespace) {
33 |         return new CachingServiceFilter(
34 |             new Cache($config['cache'], $cacheNamespace),
35 |             $compositeFilter,
36 |             new LocalRetriever($config['retrieverMap'])
37 |         );
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Services/ServiceFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Services;
 5 | 
 6 | use Kibo\Phast\ValueObjects\Resource;
 7 | 
 8 | interface ServiceFilter {
 9 |     /**
10 |      * @param Resource $resource
11 |      * @param array $request
12 |      * @return Resource
13 |      */
14 |     public function apply(Resource $resource, array $request);
15 | }
16 | 


--------------------------------------------------------------------------------
/src/bootstrap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | if (!class_exists('\Kibo\Phast\PhastServices')) {
 3 |     if (file_exists(__DIR__ . '/../vendor/autoload.php')) {
 4 |         require_once __DIR__ . '/../vendor/autoload.php';
 5 |     } elseif (file_exists(__DIR__ . '/../../../autoload.php')) {
 6 |         require_once __DIR__ . '/../../../autoload.php';
 7 |     }
 8 | }
 9 | if (!defined('PHAST_CONFIG_FILE')) {
10 |     define('PHAST_CONFIG_FILE', __DIR__ . '/config-user.php');
11 | }
12 | 


--------------------------------------------------------------------------------
/src/config-user.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | return [];
4 | 


--------------------------------------------------------------------------------
/src/html-filters.php:
--------------------------------------------------------------------------------
1 | <?php
2 | require_once __DIR__ . '/bootstrap.php';
3 | \Kibo\Phast\PhastDocumentFilters::deploy(require_once PHAST_CONFIG_FILE);
4 | 


--------------------------------------------------------------------------------
/src/services.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | require_once __DIR__ . '/bootstrap.php';
4 | \Kibo\Phast\PhastServices::serve(function () {
5 |     return require_once PHAST_CONFIG_FILE;
6 | });
7 | 


--------------------------------------------------------------------------------
/test/bootstrap.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | ini_set('display_errors', 1);
4 | error_reporting(E_ALL);
5 | 


--------------------------------------------------------------------------------
/test/browser/bundler.php:
--------------------------------------------------------------------------------
1 | <?php
2 | define('PHAST_SERVICE', 'bundler');
3 | require_once 'phast.php';
4 | 


--------------------------------------------------------------------------------
/test/browser/index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require_once __DIR__ . '/../../build/phast.php';
 4 | 
 5 | $signature = (new Kibo\Phast\Security\ServiceSignatureFactory())
 6 |     ->make(Kibo\Phast\Environment\DefaultConfiguration::get());
 7 | 
 8 | $bundlerTestParams = [];
 9 | foreach ([1, 2, 3] as $i) {
10 |     $file = sprintf(
11 |         'http://%s%s/res/text-%s.txt',
12 |         $_SERVER['HTTP_HOST'],
13 |         dirname($_SERVER['PHP_SELF']),
14 |         $i
15 |     );
16 |     $bundlerTestParams[] = Kibo\Phast\Services\Bundler\ServiceParams::fromArray(['src' => $file])
17 |         ->sign($signature)
18 |         ->serialize();
19 | }
20 | 
21 | ?>
22 | <!DOCTYPE html>
23 | <html>
24 | <head>
25 | <meta charset="utf-8">
26 | <meta name="viewport" content="width=device-width">
27 | <title>Phast Unit Tests</title>
28 | <link rel="stylesheet" href="qunit.css">
29 | <style>
30 |     #qunit-fixture {
31 |         background: white;
32 |         position: fixed;
33 |         width: auto;
34 |         height: auto;
35 |         bottom: 10px;
36 |         right: 10px;
37 |         top: auto;
38 |         left: auto;
39 |     }
40 |     #qunit-fixture iframe {
41 |         border: 1px solid #ccc;
42 |         width: 300px;
43 |         height: 300px;
44 |     }
45 | </style>
46 | </head>
47 | <body>
48 | 
49 | <?php foreach ($bundlerTestParams as $params):?>
50 |     <div data-phast-params="<?=htmlspecialchars($params)?>"></div>
51 | <?php endforeach;?>
52 | <div id="qunit"></div>
53 | <div id="qunit-fixture"></div>
54 | <script>
55 |     window.phast = {
56 |         scripts: []
57 |     };
58 | </script>
59 | <?php foreach (['es6-promise', 'hash', 'service-url', 'resources-loader', 'scripts-loader'] as $script): ?>
60 | <script>(function () {<?= file_get_contents('public/' . $script . '.js'); ?>})();</script>
61 | <?php endforeach; ?>
62 | <script src="qunit.js"></script>
63 | <script src="tests.js?<?= uniqid(); ?>"></script>
64 | <?php foreach (preg_grep('/\..*\./', glob('tests/*.js'), PREG_GREP_INVERT) as $test): ?>
65 | <script src="<?= $test; ?>"></script>
66 | <?php endforeach; ?>
67 | </body>
68 | </html>
69 | 


--------------------------------------------------------------------------------
/test/browser/phast-config.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | return [
 3 |     'servicesUrl' => preg_replace('~^(.*/browser)?/.*~si', '$1/', $_SERVER['PHP_SELF']) . 'phast.php',
 4 |     'csp' => [
 5 |         'nonce' => defined('PHAST_CSP_NONCE') ? PHAST_CSP_NONCE : null,
 6 |         'reportOnly' => defined('PHAST_CSP_REPORT_ONLY') && PHAST_CSP_REPORT_ONLY,
 7 |         'reportUri' => '/phast-report.php',
 8 |     ],
 9 | ];
10 | 


--------------------------------------------------------------------------------
/test/browser/phast.php:
--------------------------------------------------------------------------------
1 | <?php
2 | require __DIR__ . '/../../build/phast.php';
3 | \Kibo\Phast\PhastServices::serve(function () {
4 |     return require __DIR__ . '/phast-config.php';
5 | });
6 | 


--------------------------------------------------------------------------------
/test/browser/public/es6-promise.js:
--------------------------------------------------------------------------------
1 | ../../../src/Filters/HTML/PhastScriptsCompiler/es6-promise.js


--------------------------------------------------------------------------------
/test/browser/public/hash.js:
--------------------------------------------------------------------------------
1 | ../../../src/Filters/HTML/PhastScriptsCompiler/hash.js


--------------------------------------------------------------------------------
/test/browser/public/resources-loader.js:
--------------------------------------------------------------------------------
1 | ../../../src/Filters/HTML/PhastScriptsCompiler/resources-loader.js


--------------------------------------------------------------------------------
/test/browser/public/scripts-loader.js:
--------------------------------------------------------------------------------
1 | ../../../src/Filters/HTML/ScriptsDeferring/scripts-loader.js


--------------------------------------------------------------------------------
/test/browser/public/service-url.js:
--------------------------------------------------------------------------------
1 | ../../../src/Filters/HTML/PhastScriptsCompiler/service-url.js


--------------------------------------------------------------------------------
/test/browser/res/.htaccess:
--------------------------------------------------------------------------------
1 | Deny from all
2 | 


--------------------------------------------------------------------------------
/test/browser/res/python.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kiboit/phast/96a50e2fcd71c6db72ac451e1f10d9c92f7f6b6a/test/browser/res/python.png


--------------------------------------------------------------------------------
/test/browser/res/script_proxy.js:
--------------------------------------------------------------------------------
1 | (function () {
2 |   var h1 = document.createElement("h1");
3 |   h1.appendChild(document.createTextNode("Hello, World!"));
4 |   document.body.insertBefore(h1, document.body.firstChild);
5 | })();
6 | 


--------------------------------------------------------------------------------
/test/browser/res/stylesheet.css:
--------------------------------------------------------------------------------
1 | .my-class {
2 |     background: blue;
3 | }
4 | 


--------------------------------------------------------------------------------
/test/browser/res/stylesheet_import.css:
--------------------------------------------------------------------------------
1 | @import 'stylesheet.css';
2 | 


--------------------------------------------------------------------------------
/test/browser/res/text-1.txt:
--------------------------------------------------------------------------------
1 | text-1-contents
2 | 


--------------------------------------------------------------------------------
/test/browser/res/text-2.txt:
--------------------------------------------------------------------------------
1 | text-2-contents
2 | 


--------------------------------------------------------------------------------
/test/browser/res/text-3.txt:
--------------------------------------------------------------------------------
1 | text-3-contents
2 | 


--------------------------------------------------------------------------------
/test/browser/tests/_.php:
--------------------------------------------------------------------------------
1 | <?php
2 | require_once __DIR__ . '/../../../build/phast.php';
3 | \Kibo\Phast\PhastDocumentFilters::deploy(require __DIR__ . '/../phast-config.php');
4 | 


--------------------------------------------------------------------------------
/test/browser/tests/csp.js:
--------------------------------------------------------------------------------
 1 | test("csp.php", function (assert, document) {
 2 |   assert.deepEqual(
 3 |     document.defaultView.SCRIPTS,
 4 |     ["correct nonce"],
 5 |     "Only the script with the (correct) nonce should be executed"
 6 |   );
 7 |   assert.equal(
 8 |     document.defaultView.REPORTS,
 9 |     2,
10 |     "Two reports should have been made"
11 |   );
12 | });
13 | 


--------------------------------------------------------------------------------
/test/browser/tests/csp.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | define('PHAST_CSP_NONCE', 'secret');
 3 | 
 4 | if (!(defined('PHAST_CSP_REPORT_ONLY') && PHAST_CSP_REPORT_ONLY)) {
 5 |     header("Content-Security-Policy: script-src 'nonce-secret'");
 6 | }
 7 | 
 8 | require '_.php';
 9 | ?>
10 | <!doctype html>
11 | <html>
12 | <body>
13 | <script data-phast-no-defer nonce="secret">
14 | window.REPORTS = 0;
15 | 
16 | window.fetch = function (resource, init) {
17 |     if (/phast-report/.test(resource)) {
18 |         window.REPORTS++;
19 |     }
20 | }
21 | </script>
22 | <script nonce="secret">
23 | if (!window.SCRIPTS) window.SCRIPTS = [];
24 | window.SCRIPTS.push("correct nonce");
25 | </script>
26 | <script nonce="wrong">
27 | if (!window.SCRIPTS) window.SCRIPTS = [];
28 | window.SCRIPTS.push("incorrect nonce");
29 | </script>
30 | <script>
31 | if (!window.SCRIPTS) window.SCRIPTS = [];
32 | window.SCRIPTS.push("no nonce");
33 | </script>
34 | </body>
35 | </html>
36 | 


--------------------------------------------------------------------------------
/test/browser/tests/csp_report_only.js:
--------------------------------------------------------------------------------
 1 | test("csp_report_only.php", function (assert, document) {
 2 |   assert.deepEqual(
 3 |     document.defaultView.SCRIPTS,
 4 |     ["correct nonce", "incorrect nonce", "no nonce"],
 5 |     "All scripts should be executed"
 6 |   );
 7 |   assert.equal(
 8 |     document.defaultView.REPORTS,
 9 |     2,
10 |     "Two reports should have been made"
11 |   );
12 | });
13 | 


--------------------------------------------------------------------------------
/test/browser/tests/csp_report_only.php:
--------------------------------------------------------------------------------
1 | <?php
2 | define('PHAST_CSP_REPORT_ONLY', true);
3 | require 'csp.php';
4 | 


--------------------------------------------------------------------------------
/test/browser/tests/currentscript.js:
--------------------------------------------------------------------------------
 1 | test("currentscript.php", function (assert, document) {
 2 |   if (!("currentScript" in document)) {
 3 |     return;
 4 |   }
 5 | 
 6 |   assert.equal(
 7 |     document.defaultView.SYNC_VALUE,
 8 |     "sync",
 9 |     "The sync script should see data-value=sync"
10 |   );
11 | 
12 |   var a = document.createElement("a");
13 |   a.href = "currentscript.script.js";
14 |   assert.equal(
15 |     document.defaultView.SYNC_SRC,
16 |     a.href,
17 |     "The sync script should see the original src"
18 |   );
19 | 
20 |   assert.equal(
21 |     document.defaultView.INLINE_VALUE,
22 |     "inline",
23 |     "The inline script should see data-value=inline"
24 |   );
25 | });
26 | 


--------------------------------------------------------------------------------
/test/browser/tests/currentscript.php:
--------------------------------------------------------------------------------
1 | <?php require '_.php'; ?>
2 | <!doctype html>
3 | <html>
4 | <body>
5 | <script src="currentscript.script.js" data-value="sync"></script>
6 | <script data-value="inline">window.INLINE_VALUE = document.currentScript.dataset.value</script>
7 | </body>
8 | </html>
9 | 


--------------------------------------------------------------------------------
/test/browser/tests/currentscript.script.js:
--------------------------------------------------------------------------------
1 | if (document.currentScript) {
2 |   window.SYNC_VALUE = document.currentScript.dataset.value;
3 |   window.SYNC_SRC = document.currentScript.getAttribute("src");
4 | }
5 | 


--------------------------------------------------------------------------------
/test/browser/tests/currentscript_async.js:
--------------------------------------------------------------------------------
 1 | test("currentscript_async.php", function (assert, document) {
 2 |   if (!("currentScript" in document)) {
 3 |     return;
 4 |   }
 5 | 
 6 |   assert.equal(
 7 |     document.defaultView.OK.phast,
 8 |     10,
 9 |     "phast script should have seen `phast' 10 times"
10 |   );
11 | 
12 |   assert.equal(
13 |     document.defaultView.OK.async,
14 |     10,
15 |     "async script should have seen `async' 10 times"
16 |   );
17 | });
18 | 


--------------------------------------------------------------------------------
/test/browser/tests/currentscript_async.js.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | usleep((int) $_GET['i'] * .1 * 1e6);
 3 | header('Content-Type: text/javascript');
 4 | ?>
 5 | var type = <?= json_encode($_GET['t']); ?>;
 6 | 
 7 | console.log("From", type, "script:", document.currentScript.dataset.value);
 8 | 
 9 | if (document.currentScript.dataset.value === type) {
10 |   if (!window.OK) {
11 |     window.OK = {};
12 |   }
13 |   if (!window.OK[type]) {
14 |     window.OK[type] = 0;
15 |   }
16 |   window.OK[type]++;
17 | }
18 | 


--------------------------------------------------------------------------------
/test/browser/tests/currentscript_async.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <?php for ($i = 0; $i < 10; $i++): ?>
 6 | <script src="currentscript_async.js.php?i=<?= $i ?>&t=phast"
 7 |         data-value="phast"
 8 |         data-phast-debug-force-method="SyncBrowserScript"
 9 | ></script>
10 | <?php endfor; ?>
11 | <?php for ($i = 0; $i < 10; $i++): ?>
12 | <script src="currentscript_async.js.php?i=<?= $i; ?>&t=async"
13 |         data-value="async"
14 |         data-phast-no-defer
15 |         async
16 | ></script>
17 | <?php endfor; ?>
18 | </body>
19 | </html>
20 | 


--------------------------------------------------------------------------------
/test/browser/tests/document_write.js:
--------------------------------------------------------------------------------
 1 | test("document_write.php", function (assert, document) {
 2 |   expectedHeaders = ["H1", "H2", "H3"];
 3 | 
 4 |   assert.equal(
 5 |     getTagNamesInDocumentOrder(expectedHeaders).join(","),
 6 |     expectedHeaders.join(","),
 7 |     "Headers should be on the page in the right count and order"
 8 |   );
 9 | 
10 |   expectedHeaders.forEach(function (name) {
11 |     var elements = document.getElementsByTagName(name);
12 |     assert.equal(
13 |       elements.length,
14 |       1,
15 |       "There should be one <" + name.toUpperCase() + "> element on the page"
16 |     );
17 |     assert.equal(
18 |       elements[0].textContent,
19 |       "Hello, World!",
20 |       "The <" + name.toUpperCase() + "> should say 'Hello, World!'"
21 |     );
22 |   });
23 | 
24 |   function getTagNamesInDocumentOrder(tagNames) {
25 |     var result = [];
26 |     walk(document.body, function (el) {
27 |       if (el.tagName && tagNames.indexOf(el.tagName) !== -1) {
28 |         result.push(el.tagName);
29 |       }
30 |     });
31 |     return result;
32 |   }
33 | 
34 |   function walk(el, fn) {
35 |     fn(el);
36 |     for (var i = 0; i < el.childNodes.length; i++) {
37 |       walk(el.childNodes[i], fn);
38 |     }
39 |   }
40 | });
41 | 


--------------------------------------------------------------------------------
/test/browser/tests/document_write.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <script>
 6 |     document.write('<h1>Hello, ' + 'World!</h1>');
 7 | </script>
 8 | <div><script>
 9 |     document.write('<h2>Hello, ' + 'World!</h2>');
10 | </script></div>
11 | <script>
12 |     var el = document.getElementById('remove');
13 |     el.parentNode.removeChild(el);
14 |     document.write('<h3>Hello, World!</h3>');
15 | </script><div id=remove></div>
16 | </body>
17 | </html>
18 | 


--------------------------------------------------------------------------------
/test/browser/tests/document_write_async.js:
--------------------------------------------------------------------------------
 1 | test("document_write_async.php", function (assert, document) {
 2 |   assert.equal(
 3 |     document.defaultView.WRITES,
 4 |     2,
 5 |     "document.write should've been called twice"
 6 |   );
 7 |   assert.equal(
 8 |     document.querySelectorAll("h1").length,
 9 |     0,
10 |     "There should be no H1 elements"
11 |   );
12 | });
13 | 


--------------------------------------------------------------------------------
/test/browser/tests/document_write_async.load.js:
--------------------------------------------------------------------------------
1 | document.write("<h1>Hello, World!</h1>");
2 | window.WRITES = (window.WRITES || 0) + 1;
3 | 


--------------------------------------------------------------------------------
/test/browser/tests/document_write_async.php:
--------------------------------------------------------------------------------
1 | <?php require '_.php'; ?>
2 | <!doctype html>
3 | <html>
4 | <body>
5 | <script async src="document_write_async.load.js"></script>
6 | <script defer src="document_write_async.load.js"></script>
7 | </body>
8 | </html>
9 | 


--------------------------------------------------------------------------------
/test/browser/tests/document_write_read.js:
--------------------------------------------------------------------------------
 1 | test("document_write_read.php", function (assert, document) {
 2 |   assert.ok(document.defaultView.TEST_RESULT, "TEST_RESULT is defined");
 3 |   assert.ok(
 4 |     document.defaultView.TEST_RESULT.FOUND_H1,
 5 |     "<h1> should be visible right after write"
 6 |   );
 7 |   var h1s = document.getElementsByTagName("h1");
 8 |   assert.equal(h1s.length, 1, "There should be 1 <h1> element on the page");
 9 |   assert.equal(
10 |     h1s[0].textContent,
11 |     "Hello, World!",
12 |     'The <h1> should say "Hello, World!"'
13 |   );
14 | });
15 | 


--------------------------------------------------------------------------------
/test/browser/tests/document_write_read.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <script>
 6 |     TEST_RESULT = {}
 7 |     document.write('<h1>Hello, World!</h1>');
 8 |     TEST_RESULT.FOUND_H1 = document.getElementsByTagName('h1').length == 1;
 9 | </script>
10 | </body>
11 | </html>
12 | 


--------------------------------------------------------------------------------
/test/browser/tests/document_write_restore.js:
--------------------------------------------------------------------------------
 1 | test("document_write_restore.php", function (assert, document) {
 2 |   var initialElements = document.getElementsByTagName("h1");
 3 |   assert.equal(
 4 |     initialElements.length,
 5 |     1,
 6 |     "There should be one h1 on the page before document.write"
 7 |   );
 8 | 
 9 |   document.defaultView.callDocumentWrite();
10 | 
11 |   var elements = document.getElementsByTagName("h1");
12 |   assert.equal(
13 |     elements.length,
14 |     0,
15 |     "There should be no h1 on the page after document.write"
16 |   );
17 | });
18 | 


--------------------------------------------------------------------------------
/test/browser/tests/document_write_restore.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <h1>This should be removed by the async call to document.write</h1>
 6 | <script>
 7 |     callDocumentWrite = function () {
 8 |         document.write('This is the result of the async call to document.write');
 9 |     }
10 | </script>
11 | </body>
12 | </html>
13 | 


--------------------------------------------------------------------------------
/test/browser/tests/document_write_script.js:
--------------------------------------------------------------------------------
 1 | test("document_write_script.php", function (assert, document) {
 2 |   h1s = document.getElementsByTagName("h1");
 3 |   assert.equal(h1s.length, 1, "There should be one <h1> on the page");
 4 |   assert.equal(
 5 |     h1s[0].textContent,
 6 |     "Hello, World!",
 7 |     'The <h1> should contain the string "Hello, World!"'
 8 |   );
 9 | });
10 | 


--------------------------------------------------------------------------------
/test/browser/tests/document_write_script.load.js:
--------------------------------------------------------------------------------
1 | document.write("<h1>Hello, World!</h1>");
2 | 


--------------------------------------------------------------------------------
/test/browser/tests/document_write_script.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <script>
 6 | document.write('<script src="document_write_script.load.js"><\/script>');
 7 | </script>
 8 | </body>
 9 | </html>
10 | 


--------------------------------------------------------------------------------
/test/browser/tests/event_count.js:
--------------------------------------------------------------------------------
1 | test("event_count.php", function (assert, document) {
2 |   assert.propEqual(document.defaultView.events, [
3 |     { event: "readystatechange", readyState: "interactive" },
4 |     { event: "DOMContentLoaded", readyState: "interactive" },
5 |     { event: "readystatechange", readyState: "complete" },
6 |     { event: "load", readyState: "complete" },
7 |   ]);
8 | });
9 | 


--------------------------------------------------------------------------------
/test/browser/tests/event_count.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <script>
 6 |     var events = [];
 7 | 
 8 |     function say(message) {
 9 |         var p = document.createElement('p');
10 |         p.innerText = message;
11 |         document.body.appendChild(p);
12 |     }
13 | 
14 |     function trackEvent(name) {
15 |         say("event=" + name + " readyState=" + document.readyState);
16 |         events.push({
17 |             event: name,
18 |             readyState: document.readyState
19 |         });
20 |     }
21 | 
22 |     document.addEventListener('DOMContentLoaded', function () {
23 |         trackEvent('DOMContentLoaded');
24 |     });
25 | 
26 |     document.addEventListener('readystatechange', function () {
27 |         trackEvent('readystatechange');
28 |     });
29 | 
30 |     window.addEventListener('load', function () {
31 |         trackEvent('load');
32 |     });
33 | </script>
34 | </body>
35 | </html>
36 | 


--------------------------------------------------------------------------------
/test/browser/tests/hello_world.js:
--------------------------------------------------------------------------------
 1 | test("hello_world.php", function (assert, document) {
 2 |   var h1s = document.getElementsByTagName("h1");
 3 |   assert.equal(h1s.length, 1, "There is one <H1> element on the page");
 4 |   assert.equal(
 5 |     h1s[0].textContent,
 6 |     "Hello, World!",
 7 |     "The <H1> says 'Hello, World!'"
 8 |   );
 9 | });
10 | 


--------------------------------------------------------------------------------
/test/browser/tests/hello_world.php:
--------------------------------------------------------------------------------
1 | <?php require '_.php'; ?>
2 | <!doctype html>
3 | <html>
4 | <body>
5 | <h1>Hello, World!</h1>
6 | </body>
7 | </html>
8 | 


--------------------------------------------------------------------------------
/test/browser/tests/iframe.content.php:
--------------------------------------------------------------------------------
1 | <h1>I'm the iframe!</h1>
2 | <script>
3 |     window.parent.iframeLoads = window.parent.iframeLoads || 0;
4 |     window.parent.iframeLoads++;
5 | </script>
6 | 


--------------------------------------------------------------------------------
/test/browser/tests/iframe.js:
--------------------------------------------------------------------------------
 1 | test("iframe.php", function (assert, document) {
 2 |   wait(
 3 |     assert,
 4 |     function () {
 5 |       return document.defaultView.iframeLoads > 0;
 6 |     },
 7 |     function () {
 8 |       assert.equal(
 9 |         document.defaultView.iframeLoads,
10 |         1,
11 |         "The IFrame should have been loaded once"
12 |       );
13 |       assert.ok(
14 |         document.defaultView.loadingAttrSet,
15 |         "The IFrame should have loading=lazy set"
16 |       );
17 |     }
18 |   );
19 | });
20 | 


--------------------------------------------------------------------------------
/test/browser/tests/iframe.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <iframe src="iframe.content.php"></iframe>
 6 | <script>
 7 |     (function () {
 8 |         var iframe = document.getElementsByTagName('iframe').item(0);
 9 |         loadingAttrSet = iframe.getAttribute('loading') === 'lazy';
10 |     })();
11 | </script>
12 | </body>
13 | </html>
14 | 


--------------------------------------------------------------------------------
/test/browser/tests/iframe_js.js:
--------------------------------------------------------------------------------
 1 | test("iframe_js.php", function (assert, document) {
 2 |   wait(
 3 |     assert,
 4 |     function () {
 5 |       return document.defaultView.iframeLoads > 0;
 6 |     },
 7 |     function () {
 8 |       var done = assert.async();
 9 |       setTimeout(function () {
10 |         done();
11 |         assert.equal(
12 |           document.defaultView.iframeLoads,
13 |           1,
14 |           "The IFrame should have been loaded once"
15 |         );
16 |         assert.ok(
17 |           document.defaultView.loadingAttrSet,
18 |           "The IFrame should have loading=lazy set"
19 |         );
20 |       }, 50);
21 |     }
22 |   );
23 | });
24 | 


--------------------------------------------------------------------------------
/test/browser/tests/iframe_js.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <iframe src="iframe.content.php"></iframe>
 6 | <script>
 7 |     (function () {
 8 |         var iframe = document.getElementsByTagName('iframe').item(0);
 9 |         loadingAttrSet = iframe.getAttribute('loading') === 'lazy';
10 |         iframe.src = "iframe.content.php?";
11 |     })();
12 | </script>
13 | </body>
14 | </html>
15 | 


--------------------------------------------------------------------------------
/test/browser/tests/inline_js.js:
--------------------------------------------------------------------------------
 1 | test("inline_js.php", function (assert, document) {
 2 |   assert.equal(
 3 |     document.defaultView.didLoad,
 4 |     true,
 5 |     "didLoad should be set to true by inline script"
 6 |   );
 7 |   assert.equal(
 8 |     document.defaultView.srcWasEmpty,
 9 |     true,
10 |     "srcWasEmpty should be set to true by inline script"
11 |   );
12 |   assert.equal(
13 |     document.defaultView.shouldBeGlobal,
14 |     true,
15 |     "shouldBeGlobal should be defined in global scope"
16 |   );
17 | });
18 | 


--------------------------------------------------------------------------------
/test/browser/tests/inline_js.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <head></head>
 5 | <body>
 6 | <script id="script">
 7 |     didLoad = true;
 8 |     var shouldBeGlobal = true;
 9 |     srcWasEmpty = document.getElementById('script').src === '';
10 | </script>
11 | </body>
12 | </html>
13 | 


--------------------------------------------------------------------------------
/test/browser/tests/multiple_set_timeout_before_onload.js:
--------------------------------------------------------------------------------
 1 | test("multiple_set_timeout_before_onload.php", function (assert, document) {
 2 |   events = document.defaultView.events;
 3 |   events = events.filter(function (v, i) {
 4 |     return i === events.lastIndexOf(v);
 5 |   });
 6 |   assert.deepEqual(events, [
 7 |     "setTimeout",
 8 |     "DOMContentLoaded",
 9 |     "setTimeout via DOMContentLoaded",
10 |     "load",
11 |   ]);
12 | });
13 | 


--------------------------------------------------------------------------------
/test/browser/tests/multiple_set_timeout_before_onload.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <script>
 6 |     var events = [];
 7 | 
 8 |     setTimeout(function () {
 9 |         events.push('setTimeout');
10 |     });
11 | 
12 |     document.addEventListener('DOMContentLoaded', function () {
13 |         events.push('DOMContentLoaded');
14 | 
15 |         setTimeout(function () {
16 |             next(10);
17 |         });
18 | 
19 |         function next(depth) {
20 |             events.push('setTimeout via DOMContentLoaded');
21 |             if (depth > 1) {
22 |                 setTimeout(function () {
23 |                     next(depth - 1);
24 |                 });
25 |             }
26 |         }
27 |     });
28 | 
29 |     addEventListener('load', function () {
30 |         events.push('load');
31 |     });
32 | </script>
33 | </body>
34 | </html>
35 | 


--------------------------------------------------------------------------------
/test/browser/tests/request_animation_frame_before_onload.js:
--------------------------------------------------------------------------------
1 | test("request_animation_frame_before_onload.php", function (assert, document) {
2 |   assert.deepEqual(document.defaultView.events, [
3 |     "requestAnimationFrame",
4 |     "DOMContentLoaded",
5 |     "requestAnimationFrame via DOMContentLoaded",
6 |     "load",
7 |   ]);
8 | });
9 | 


--------------------------------------------------------------------------------
/test/browser/tests/request_animation_frame_before_onload.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <script>
 6 |     var events = [];
 7 | 
 8 |     window.requestAnimationFrame(function () {
 9 |         events.push('requestAnimationFrame');
10 |     });
11 | 
12 |     document.addEventListener('DOMContentLoaded', function () {
13 |         events.push('DOMContentLoaded');
14 | 
15 |         window.requestAnimationFrame(function () {
16 |             events.push('requestAnimationFrame via DOMContentLoaded');
17 |         });
18 |     });
19 | 
20 |     window.addEventListener('load', function () {
21 |         events.push('load');
22 |     });
23 | </script>
24 | </body>
25 | </html>
26 | 


--------------------------------------------------------------------------------
/test/browser/tests/rewrite_image_in_inline_style.js:
--------------------------------------------------------------------------------
 1 | test("rewrite_image_in_inline_style.php", function (assert, document) {
 2 |   var divs = document.getElementsByTagName("div");
 3 |   assert.equal(divs.length, 1, "There is one <DIV> element on the page");
 4 |   var match = /url\("?(.+?)"?\)/.exec(divs[0].style.backgroundImage);
 5 |   assert.ok(
 6 |     match,
 7 |     "We can parse the url() in the <DIV>'s background-image style"
 8 |   );
 9 |   var url = match[1];
10 |   assert.ok(
11 |     /phast\.php/.test(url),
12 |     "The <DIV>'s background image is loaded through phast.php"
13 |   );
14 | 
15 |   // Load URL as image and check size
16 |   async(assert, function (done) {
17 |     var img = new Image();
18 |     img.onload = function () {
19 |       done();
20 |       assert.equal(img.width, 256, "The image's width is as expected");
21 |       assert.equal(img.height, 256, "The image's height is as expected");
22 |     };
23 |     img.onerror = function () {
24 |       done();
25 |       assert.ok(false, "The image loads");
26 |     };
27 |     img.src = url;
28 |   });
29 | 
30 |   // Load URL as string and check type
31 |   async(assert, function (done) {
32 |     retrieve(url, function (content) {
33 |       done();
34 |       assert.ok(content.length > 0, "The image data is not empty");
35 |       assert.ok(/^.PNG/.test(content), "The image data has a PNG signature");
36 |     });
37 |   });
38 | });
39 | 


--------------------------------------------------------------------------------
/test/browser/tests/rewrite_image_in_inline_style.php:
--------------------------------------------------------------------------------
1 | <?php require '_.php'; ?>
2 | <!doctype html>
3 | <html>
4 | <body>
5 | <div style="width: 200px; height: 200px; background: url(../res/python.png)"></div>
6 | </body>
7 | </html>
8 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_error_fallback.js:
--------------------------------------------------------------------------------
 1 | test("script_error_fallback.php", function (assert, document) {
 2 |   assert.ok(
 3 |     document.defaultView.doesNotExistSrc,
 4 |     "window.doesNotExistSrc is defined"
 5 |   );
 6 |   assert.equal(
 7 |     document.defaultView.doesNotExistSrc,
 8 |     "does-not-exist.js",
 9 |     "window.doesNotExistSrc is not correct"
10 |   );
11 | });
12 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_error_fallback.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <script id="does-not-exist" src="does-not-exist.js"></script>
 6 | <script>
 7 |     doesNotExistSrc = document.getElementById('does-not-exist').getAttribute('src');
 8 | </script>
 9 | </body>
10 | </html>
11 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_once.done.js:
--------------------------------------------------------------------------------
1 | DONE = 1;
2 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_once.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * IE would trigger a <script> again after replacing the SRC attribute, but only
 3 |  * if the TYPE attribute was present.
 4 |  */
 5 | 
 6 | test("script_once.php", function (assert, document) {
 7 |   wait(
 8 |     assert,
 9 |     function () {
10 |       return document.defaultView.DONE;
11 |     },
12 |     function () {
13 |       assert.equal(
14 |         document.defaultView.COUNT || 0,
15 |         1,
16 |         "The script should have been executed exactly once"
17 |       );
18 |     }
19 |   );
20 | });
21 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_once.php:
--------------------------------------------------------------------------------
1 | <?php require '_.php'; ?>
2 | <!doctype html>
3 | <html>
4 | <body>
5 | <script src="script_once.script.js" type="text/javascript"></script>
6 | </body>
7 | </html>
8 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_once.script.js:
--------------------------------------------------------------------------------
1 | window.COUNT = (window.COUNT || 0) + 1;
2 | console.log("Script triggered (" + window.COUNT + ")");
3 | 
4 | setTimeout(function () {
5 |   var s = document.createElement("script");
6 |   s.src = "script_once.done.js?" + Date.now();
7 |   document.body.appendChild(s);
8 | });
9 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_order.defer.js:
--------------------------------------------------------------------------------
1 | order = window.order || [];
2 | order.push("proxied defer");
3 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_order.js:
--------------------------------------------------------------------------------
 1 | test("script_order.php", function (assert, document) {
 2 |   var expected = [
 3 |     "inline",
 4 |     "deferred inline",
 5 |     "synchronous external",
 6 |     "second inline",
 7 |     "proxied defer",
 8 |     "deferred external",
 9 |   ];
10 |   assert.ok(document.defaultView.order, "window.order is defined");
11 |   var order = document.defaultView.order;
12 |   wait(
13 |     assert,
14 |     function () {
15 |       return order.length >= expected.length + 1;
16 |     },
17 |     function () {
18 |       assert.ok(
19 |         order.indexOf("async external") !== -1,
20 |         "async script was loaded"
21 |       );
22 |       assert.ok(
23 |         order.indexOf("async external") !== 0,
24 |         "async script was not loaded first"
25 |       );
26 |       order.splice(order.indexOf("async external"), 1);
27 |       assert.equal(
28 |         order.length,
29 |         expected.length,
30 |         "" + expected.length + " scripts were loaded"
31 |       );
32 |       var strOrder = order.join(", ");
33 |       var strExpected = expected.join(", ");
34 |       assert.equal(
35 |         strOrder,
36 |         strExpected,
37 |         "Scripts were loaded in the expected order"
38 |       );
39 |     }
40 |   );
41 | });
42 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_order.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <script async src="script_order.script.php?name=async+external&sleep=200&<?= uniqid(); ?>"></script>
 6 | <script defer src="script_order.defer.js"></script>
 7 | <script defer src="script_order.script.php?name=deferred+external&<?= uniqid(); ?>"></script>
 8 | <script>
 9 |     order = window.order || [];
10 |     order.push('inline');
11 | </script>
12 | <script defer>
13 |     order = window.order || [];
14 |     order.push('deferred inline');
15 | </script>
16 | <script src="script_order.script.php?name=synchronous+external&<?= uniqid(); ?>"></script>
17 | <script>
18 |     order = window.order || [];
19 |     order.push('second inline');
20 | </script>
21 | </body>
22 | </html>
23 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_order.script.php:
--------------------------------------------------------------------------------
1 | <?php
2 | if (!empty($_GET['sleep'])) {
3 |     usleep($_GET['sleep'] * 1000);
4 | }
5 | header('Content-Type: text/javascript');
6 | ?>
7 | order = window.order || [];
8 | order.push(<?= json_encode($_GET['name']); ?>);
9 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_proxy_dynamic.js:
--------------------------------------------------------------------------------
 1 | test("script_proxy_dynamic.php", function (assert, document) {
 2 |   wait(
 3 |     assert,
 4 |     function () {
 5 |       return document.getElementsByTagName("h1").length > 0;
 6 |     },
 7 |     function () {
 8 |       var h1s = Array.prototype.slice.call(document.getElementsByTagName("h1"));
 9 |       assert.equal(
10 |         h1s.length,
11 |         3,
12 |         "There should be three <H1> elements on the page"
13 |       );
14 | 
15 |       h1s.sort(function (a, b) {
16 |         return a.textContent > b.textContent
17 |           ? 1
18 |           : a.textContent < b.textContent
19 |           ? -1
20 |           : 0;
21 |       });
22 | 
23 |       for (var i = 0; i < 2; i++) {
24 |         assert.equal(
25 |           h1s[i].textContent,
26 |           "Hello, World!",
27 |           "The <H1> should say 'Hello, World!'"
28 |         );
29 |       }
30 | 
31 |       assert.equal(
32 |         h1s[i].textContent,
33 |         "Hi from module!",
34 |         "The third <H1> should say 'Hi from module!'"
35 |       );
36 | 
37 |       var scripts = Array.prototype.slice.call(
38 |         document.getElementsByTagName("script")
39 |       );
40 | 
41 |       scripts.sort(function (a, b) {
42 |         return parseInt(a.dataset.testIndex) - parseInt(b.dataset.testIndex);
43 |       });
44 | 
45 |       assert.ok(
46 |         scripts[0].hasAttribute("data-phast-rewritten"),
47 |         "The first <SCRIPT> was rewritten"
48 |       );
49 |       assert.ok(
50 |         scripts[1].hasAttribute("data-phast-rewritten"),
51 |         "The second <SCRIPT> was rewritten"
52 |       );
53 |       assert.ok(
54 |         !scripts[2].hasAttribute("data-phast-rewritten"),
55 |         "The third <SCRIPT> was not rewritten"
56 |       );
57 |     }
58 |   );
59 | });
60 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_proxy_dynamic.module.js:
--------------------------------------------------------------------------------
1 | (function () {
2 |   var h1 = document.createElement("h1");
3 |   h1.appendChild(document.createTextNode("Hi from module!"));
4 |   document.body.insertBefore(h1, document.body.firstChild);
5 | })();
6 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_proxy_dynamic.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <script>
 6 |     var index = 0;
 7 | 
 8 |     insert(function (s) {
 9 |         s.src = '../res/script_proxy.js';
10 |     });
11 | 
12 |     insert(function (s) {
13 |         s.src = '../res/script_proxy.js';
14 |         s.type = 'text/javascript';
15 |     });
16 | 
17 |     insert(function (s) {
18 |         s.src = 'script_proxy_dynamic.module.js';
19 |         s.type = 'module';
20 |     });
21 | 
22 |     function insert(fn) {
23 |         var s = document.createElement('script');
24 |         s.dataset.testIndex = ++index;
25 |         fn(s);
26 |         var before = document.getElementsByTagName('script')[0];
27 |         before.parentNode.insertBefore(s, before);
28 |     }
29 | </script>
30 | </body>
31 | </html>
32 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_proxy_php.js:
--------------------------------------------------------------------------------
1 | test("script_proxy_php.php", function (assert, document) {
2 |   var h1s = document.getElementsByTagName("h1");
3 |   assert.equal(h1s.length, 1, "There should be one <H1> element on the page");
4 | });
5 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_proxy_php.php:
--------------------------------------------------------------------------------
1 | <?php require '_.php'; ?>
2 | <!doctype html>
3 | <html>
4 | <body>
5 | <script src="script_proxy_php_script.php"></script>
6 | </body>
7 | </html>
8 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_proxy_php_script.php:
--------------------------------------------------------------------------------
1 | <?php
2 | header('Content-Type: text/javascript');
3 | ?>
4 | // <script>
5 | document.write('<h1>Hello, World!</h1>');
6 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_proxy_static.js:
--------------------------------------------------------------------------------
 1 | test("script_proxy_static.php", function (assert, document) {
 2 |   var h1s = document.getElementsByTagName("h1");
 3 |   assert.equal(h1s.length, 1, "There should be one <H1> element on the page");
 4 |   assert.equal(
 5 |     h1s[0].textContent,
 6 |     "Hello, World!",
 7 |     "The <H1> should say 'Hello, World!'"
 8 |   );
 9 | 
10 |   var scripts = document.getElementsByTagName("script");
11 |   assert.ok(
12 |     scripts.length >= 1,
13 |     "There should be one or more <SCRIPT> elements on the page"
14 |   );
15 |   assert.ok(
16 |     /script_proxy\.js/.test(scripts[0].src),
17 |     "The first <SCRIPT> src should contain the name of the script"
18 |   );
19 |   assert.ok(
20 |     !/phast\.php/.test(scripts[0].src),
21 |     "The first <SCRIPT> src should not contain phast.php"
22 |   );
23 | });
24 | 


--------------------------------------------------------------------------------
/test/browser/tests/script_proxy_static.php:
--------------------------------------------------------------------------------
1 | <?php require '_.php'; ?>
2 | <!doctype html>
3 | <html>
4 | <body>
5 | <script src="../res/script_proxy.js"></script>
6 | </body>
7 | </html>
8 | 


--------------------------------------------------------------------------------
/test/browser/tests/scripts_load_external_async.js:
--------------------------------------------------------------------------------
 1 | test("scripts_load_external_async.php", function (assert, document) {
 2 |   assert.equal(
 3 |     document.defaultView.jQuerySrc,
 4 |     "https://code.jquery.com/jquery-3.3.1.slim.min.js",
 5 |     "jQuery src is correct"
 6 |   );
 7 |   assert.notOk(
 8 |     document.defaultView.jQueryLoaded,
 9 |     "jQuery was loaded before sync script"
10 |   );
11 | 
12 |   wait(
13 |     assert,
14 |     function () {
15 |       return document.defaultView.onLoadCalledAfterJQuery !== undefined;
16 |     },
17 |     function () {
18 |       assert.ok(
19 |         document.defaultView.onLoadCalledAfterJQuery,
20 |         "window.onload called after jQuery load"
21 |       );
22 |     }
23 |   );
24 | });
25 | 


--------------------------------------------------------------------------------
/test/browser/tests/scripts_load_external_async.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <script async src="https://code.jquery.com/jquery-3.3.1.slim.min.js" id="jquery"></script>
 6 | <script>
 7 |     function checkJQuery() {
 8 |         try {
 9 |             return !!jQuery;
10 |         } catch (e) {
11 |             return false;
12 |         }
13 |     }
14 |     jQueryLoaded = checkJQuery();
15 |     var jqueryElement = document.getElementById('jquery');
16 |     jQuerySrc = jqueryElement.getAttribute('src');
17 |     window.addEventListener('load', function () {
18 |         onLoadCalledAfterJQuery = checkJQuery();
19 |     });
20 | </script>
21 | </body>
22 | </html>
23 | 


--------------------------------------------------------------------------------
/test/browser/tests/set_timeout_args.js:
--------------------------------------------------------------------------------
1 | test("set_timeout_args.php", function (assert, document) {
2 |   assert.equal(document.defaultView.ARGA, "Hello");
3 |   assert.equal(document.defaultView.ARGB, "World");
4 | });
5 | 


--------------------------------------------------------------------------------
/test/browser/tests/set_timeout_args.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <body>
 5 | <script>
 6 | setTimeout(function (a, b) {
 7 |     window.ARGA = a;
 8 |     window.ARGB = b;
 9 | }, 0, "Hello", "World");
10 | </script>
11 | </body>
12 | </html>
13 | 


--------------------------------------------------------------------------------
/test/browser/tests/stylesheet.js:
--------------------------------------------------------------------------------
 1 | test("stylesheet.php", function (assert, document) {
 2 |   var h1 = document.getElementsByTagName("h1")[0];
 3 |   var cs = document.defaultView.getComputedStyle(h1, null);
 4 |   var done = assert.async();
 5 |   wait();
 6 |   function wait() {
 7 |     if (document.querySelectorAll("style[data-phast-params]").length > 0) {
 8 |       return setTimeout(wait);
 9 |     }
10 |     done();
11 |     assert.equal(
12 |       cs.backgroundColor,
13 |       "rgb(0, 0, 255)",
14 |       "The <h1> should have a blue background"
15 |     );
16 |   }
17 | });
18 | 


--------------------------------------------------------------------------------
/test/browser/tests/stylesheet.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <head>
 5 | <link rel="stylesheet" href="../res/stylesheet.css">
 6 | </head>
 7 | <body>
 8 | <h1 class="my-class">Hello, World!</h1>
 9 | </body>
10 | </html>
11 | 


--------------------------------------------------------------------------------
/test/browser/tests/stylesheet_before_script.js:
--------------------------------------------------------------------------------
 1 | test("stylesheet_before_script.php", function (assert, document) {
 2 |   wait(
 3 |     assert,
 4 |     function () {
 5 |       return typeof document.defaultView.test !== "undefined";
 6 |     },
 7 |     function () {
 8 |       document.defaultView.test(assert);
 9 |     }
10 |   );
11 | });
12 | 


--------------------------------------------------------------------------------
/test/browser/tests/stylesheet_before_script.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <head>
 5 | <link rel="stylesheet" href="../res/stylesheet_large.css">
 6 | </head>
 7 | <body>
 8 | <h1>Hello, World!</h1>
 9 | <script>
10 |     (function () {
11 |         var h1 = document.getElementsByTagName('h1')[0];
12 |         h1.className += 'alert-danger';
13 |         var cs = document.defaultView.getComputedStyle(h1, null);
14 |         var backgroundColor = cs.backgroundColor;
15 | 
16 |         test = function(assert) {
17 |             assert.equal(backgroundColor, colorCodeToRgb('f2dede'),
18 |                          "The stylesheet should be loaded before the script runs");
19 |         };
20 | 
21 |         function colorCodeToRgb(code) {
22 |             return 'rgb(' + code.replace(/[a-f0-9]{2}/g, function (m) {
23 |                 return parseInt(m, 16) + ', ';
24 |             }).replace(/, $/, '') + ')';
25 |         }
26 |     })();
27 | </script>
28 | </body>
29 | </html>
30 | 


--------------------------------------------------------------------------------
/test/browser/tests/stylesheet_external.js:
--------------------------------------------------------------------------------
 1 | test("stylesheet_external.php", function (assert, document) {
 2 |   var h1 = document.getElementsByTagName("h1")[0];
 3 |   var cs = document.defaultView.getComputedStyle(h1, null);
 4 |   wait(
 5 |     assert,
 6 |     function () {
 7 |       return document.querySelectorAll('link[media="all"]').length > 0;
 8 |     },
 9 |     function () {
10 |       assert.equal(
11 |         cs.backgroundColor,
12 |         "rgb(0, 0, 255)",
13 |         "The <h1> should have a blue background"
14 |       );
15 |     }
16 |   );
17 | });
18 | 


--------------------------------------------------------------------------------
/test/browser/tests/stylesheet_external.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <head>
 5 | <link rel="stylesheet" href="https://peschar.net/files/phast-stylesheet.css" media="all">
 6 | </head>
 7 | <body>
 8 | <h1 class="my-class">Hello, World!</h1>
 9 | </body>
10 | </html>
11 | 


--------------------------------------------------------------------------------
/test/browser/tests/stylesheet_import.js:
--------------------------------------------------------------------------------
 1 | test("stylesheet_import.php", function (assert, document) {
 2 |   var h1 = document.getElementsByTagName("h1")[0];
 3 |   var cs = document.defaultView.getComputedStyle(h1, null);
 4 |   var done = assert.async();
 5 |   wait();
 6 |   function wait() {
 7 |     if (document.querySelectorAll("style[data-phast-params]").length > 0) {
 8 |       return setTimeout(wait);
 9 |     }
10 |     done();
11 |     assert.equal(
12 |       cs.backgroundColor,
13 |       "rgb(0, 0, 255)",
14 |       "The <h1> should have a blue background"
15 |     );
16 | 
17 |     var importStatements = 0;
18 |     [].forEach.call(document.getElementsByTagName("style"), function (style) {
19 |       if (/@import/.test(style.textContent)) {
20 |         importStatements++;
21 |       }
22 |     });
23 |     assert.equal(
24 |       importStatements,
25 |       0,
26 |       "There should be no @import statements in any <style> elements"
27 |     );
28 |   }
29 | });
30 | 


--------------------------------------------------------------------------------
/test/browser/tests/stylesheet_import.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <head>
 5 | <link rel="stylesheet" href="../res/stylesheet_import.css">
 6 | </head>
 7 | <body>
 8 | <h1 class="my-class">Hello, World!</h1>
 9 | </body>
10 | </html>
11 | 


--------------------------------------------------------------------------------
/test/browser/tests/stylesheet_large.js:
--------------------------------------------------------------------------------
 1 | test("stylesheet_large.php", function (assert, document) {
 2 |   var h1 = document.getElementsByTagName("h1")[0];
 3 |   var cs = document.defaultView.getComputedStyle(h1, null);
 4 |   var done = assert.async();
 5 |   wait();
 6 |   function wait() {
 7 |     if (document.querySelectorAll("style[data-phast-params]").length > 0) {
 8 |       return setTimeout(wait);
 9 |     }
10 |     done();
11 |     assert.equal(
12 |       cs.backgroundColor,
13 |       "rgb(242, 222, 222)",
14 |       "The <h1> should have a reddish background"
15 |     );
16 | 
17 |     var styles = document.querySelectorAll("style");
18 |     assert.equal(
19 |       styles.length,
20 |       1,
21 |       "There should be one style element on the page"
22 |     );
23 |     assert.ok(
24 |       styles[0].textContent.length >= 120 * 1000,
25 |       "The stylesheet in <style> should be at least 120K"
26 |     );
27 |   }
28 | });
29 | 


--------------------------------------------------------------------------------
/test/browser/tests/stylesheet_large.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <head>
 5 | <link rel="stylesheet" href="../res/stylesheet_large.css">
 6 | </head>
 7 | <body>
 8 | <h1 class="alert-danger">Hello, World!</h1>
 9 | </body>
10 | </html>
11 | 


--------------------------------------------------------------------------------
/test/browser/tests/stylesheet_php.js:
--------------------------------------------------------------------------------
 1 | test("stylesheet_php.php", function (assert, document) {
 2 |   var h1 = document.getElementsByTagName("h1")[0];
 3 |   var cs = document.defaultView.getComputedStyle(h1, null);
 4 |   wait(
 5 |     assert,
 6 |     function () {
 7 |       return cs.backgroundColor == "rgb(0, 0, 255)";
 8 |     },
 9 |     function () {
10 |       assert.equal(
11 |         cs.backgroundColor,
12 |         "rgb(0, 0, 255)",
13 |         "The <h1> should have a blue background"
14 |       );
15 |     }
16 |   );
17 | });
18 | 


--------------------------------------------------------------------------------
/test/browser/tests/stylesheet_php.php:
--------------------------------------------------------------------------------
 1 | <?php require '_.php'; ?>
 2 | <!doctype html>
 3 | <html>
 4 | <head>
 5 | <link rel="stylesheet" href="stylesheet_php_css.php">
 6 | </head>
 7 | <body>
 8 | <h1 class="my-class">Hello, World!</h1>
 9 | </body>
10 | </html>
11 | 


--------------------------------------------------------------------------------
/test/browser/tests/stylesheet_php_css.php:
--------------------------------------------------------------------------------
1 | <?php
2 | if (empty($_SERVER['HTTP_REFERER'])) {
3 |     http_response_code(400);
4 |     die('The request should be from the browser directly!');
5 | }
6 | header('Content-Type: text/css');
7 | echo file_get_contents(__DIR__ . '/../res/stylesheet.css');
8 | 


--------------------------------------------------------------------------------
/test/browserstack/.gitignore:
--------------------------------------------------------------------------------
1 | /data
2 | /output
3 | 


--------------------------------------------------------------------------------
/test/browserstack/run:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | set -euo pipefail
 4 | cd "$(dirname "$0")"
 5 | 
 6 | browsers_json=data/browsers.json
 7 | env_file=data/credentials
 8 | 
 9 | need_env=(
10 |     BROWSERSTACK_USERNAME
11 |     BROWSERSTACK_ACCESS_KEY
12 | )
13 | 
14 | mkdir -p data
15 | 
16 | 
17 | # Load environment variables
18 | if [[ ! -f $env_file ]]; then
19 |     read -e -p "BrowserStack username: " BROWSERSTACK_USERNAME
20 |     read -e -p "BrowserStack access key: " BROWSERSTACK_ACCESS_KEY
21 | 
22 |     read -e -p "Save credentials: [y] " -n 1 x
23 |     if [[ $x = "" ]] || [[ $x = "y" ]]; then
24 |         touch $env_file
25 |         chmod 600 $env_file
26 |         for env in "${need_env[@]}"; do
27 |             echo "$env='${!env}'" >> $env_file
28 |         done
29 |     fi
30 | fi
31 | 
32 | source $env_file
33 | 
34 | for env in "${need_env[@]}"; do
35 |     export $env
36 | done
37 | 
38 | 
39 | # Run tests
40 | mkdir -p output
41 | ./test.php | parallel -j9 --bar --joblog output/joblog --resume-failed | tee output/test.out
42 | 


--------------------------------------------------------------------------------
/test/php/Common/ObjectifiedFunctionsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Common;
 4 | 
 5 | use Kibo\Phast\Exceptions\UndefinedObjectifiedFunction;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class ObjectifiedFunctionsTest extends TestCase {
 9 |     private $funcs;
10 | 
11 |     public function setUp(): void {
12 |         parent::setUp();
13 |         $this->funcs = new ObjectifiedFunctions();
14 |     }
15 | 
16 |     public function testCallingFunction() {
17 |         $result = $this->funcs->substr('asdqwe', 0, 3);
18 |         $this->assertEquals('asd', $result);
19 |     }
20 | 
21 |     public function testCallingProperty() {
22 |         $this->funcs->substr = function (...$args) {
23 |             return $args;
24 |         };
25 |         $result = $this->funcs->substr('asdqwe', 0, 3);
26 |         $this->assertEquals(['asdqwe', 0, 3], $result);
27 |     }
28 | 
29 |     public function testNotCallingNotCallable() {
30 |         $this->funcs->substr = 'substr';
31 |         $result = $this->funcs->substr('asdqwe', 0, 3);
32 |         $this->assertEquals('asd', $result);
33 |     }
34 | 
35 |     public function testExceptionOnUndefined() {
36 |         $this->expectException(UndefinedObjectifiedFunction::class);
37 |         $this->funcs->nop();
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/test/php/Environment/TestPackage1/Diagnostics.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace Kibo\Phast\Environment\TestPackage1;
 5 | 
 6 | class Diagnostics implements \Kibo\Phast\Diagnostics\Diagnostics {
 7 |     public function diagnose(array $config) {
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/test/php/Environment/TestPackage1/Filter.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace Kibo\Phast\Environment\TestPackage1;
5 | 
6 | class Filter {
7 | }
8 | 


--------------------------------------------------------------------------------
/test/php/Environment/TestPackage2/Cache.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace Kibo\Phast\Environment\TestPackage2;
5 | 
6 | class Cache {
7 | }
8 | 


--------------------------------------------------------------------------------
/test/php/Environment/TestPackage2/Factory.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace Kibo\Phast\Environment\TestPackage2;
5 | 
6 | class Factory {
7 | }
8 | 


--------------------------------------------------------------------------------
/test/php/Filters/CSS/CSSMinifier/FilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\CSS\CSSMinifier;
 4 | 
 5 | use Kibo\Phast\ValueObjects\Resource;
 6 | use Kibo\Phast\ValueObjects\URL;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class FilterTest extends TestCase {
10 |     public function testMinifying() {
11 |         $css = 'a-tag    sub-selector { prop: 12% }';
12 |         $resource = Resource::makeWithContent(URL::fromString('http://phast.test'), $css);
13 |         $minified = (new Filter())->apply($resource, []);
14 |         $this->assertEquals('a-tag sub-selector{prop:12%}', $minified->getContent());
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/test/php/Filters/CSS/Composite/FilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\CSS\Composite;
 4 | 
 5 | use Kibo\Phast\ValueObjects\Resource;
 6 | use Kibo\Phast\ValueObjects\URL;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class FilterTest extends TestCase {
10 |     /**
11 |      * @var Filter
12 |      */
13 |     private $filter;
14 | 
15 |     public function setUp(): void {
16 |         parent::setUp();
17 |         $this->filter = new Filter();
18 |     }
19 | 
20 |     public function testRemoveComments() {
21 |         $css = '/* a comment here */ selector {rule: /* comment in a weird place*/ value}';
22 |         $resource = Resource::makeWithContent(URL::fromString('http://phast.test'), $css);
23 |         $filtered = $this->filter->apply($resource, []);
24 |         $this->assertEquals(' selector {rule:  value}', $filtered->getContent());
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/test/php/Filters/CSS/FontSwap/FilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\CSS\FontSwap;
 4 | 
 5 | use Kibo\Phast\PhastTestCase;
 6 | use Kibo\Phast\ValueObjects\Resource;
 7 | use Kibo\Phast\ValueObjects\URL;
 8 | 
 9 | class FilterTest extends PhastTestCase {
10 |     /**
11 |      * @var Filter
12 |      */
13 |     private $filter;
14 | 
15 |     public function setUp(): void {
16 |         parent::setUp();
17 |         $this->filter = new Filter();
18 |     }
19 | 
20 |     public function testAddingSwap() {
21 |         $css = "@font-face {}\n@font-face{ font-family: \"Something\";} .else{color: red;}";
22 |         $expected = "@font-face {font-display:swap;}\n@font-face{font-display:swap; font-family: \"Something\";} .else{color: red;}";
23 |         $resource = Resource::makeWithContent(URL::fromString(self::BASE_URL), $css);
24 |         $actual = $this->filter->apply($resource, []);
25 |         $this->assertEquals($expected, $actual->getContent());
26 |     }
27 | 
28 |     public function swapExceptionsData() {
29 |         yield ['f o n t a w e s o m e', false];
30 |         yield ['times new roman', true];
31 |         yield ['GeNeRaTePrEsS', false];
32 |     }
33 | 
34 |     /** @dataProvider swapExceptionsData */
35 |     public function testSwapExceptions($fontFamily, $shouldSwap) {
36 |         $css = "@font-face{font-family:\"$fontFamily\"}";
37 |         $resource = Resource::makeWithContent(URL::fromString(self::BASE_URL), $css);
38 |         $actual = $this->filter->apply($resource, [])->getContent();
39 |         if ($shouldSwap) {
40 |             $this->assertStringContainsString('font-display:swap', $actual);
41 |         } else {
42 |             $this->assertStringContainsString('font-display:block', $actual);
43 |         }
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/test/php/Filters/CSS/ImportsStripper/FilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\CSS\ImportsStripper;
 4 | 
 5 | use Kibo\Phast\ValueObjects\Resource;
 6 | use Kibo\Phast\ValueObjects\URL;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class FilterTest extends TestCase {
10 |     private $css = '
11 | @import url("fineprint.css") print
12 | ;
13 | @import url("bluish.css") projection, tv;
14 | @import \'custom.css\';
15 | @import url("chrome://communicator/skin/");
16 | @import "common.css" screen, projection;
17 | @import url(\'landscape.css\') screen and (orientation:landscape);
18 | 
19 | selector { rule: value }
20 | ';
21 | 
22 |     public function testStrippingImports() {
23 |         $result = (new Filter())
24 |             ->apply($this->makeResource(), ['strip-imports' => 1])
25 |             ->getContent();
26 | 
27 |         $this->assertStringNotContainsString('@import \'custom.css\';', $result);
28 |         $this->assertStringNotContainsString('@import url("chrome://communicator/skin/");', $result);
29 |         $this->assertStringContainsString('@import url("bluish.css") projection, tv', $result);
30 |         $this->assertStringContainsString('@import "common.css" screen, projection;', $result);
31 |         $this->assertStringContainsString("@import url('landscape.css') screen and (orientation:landscape)", $result);
32 |     }
33 | 
34 |     public function testNotStrippingWhenNotRequired() {
35 |         $result = (new Filter())
36 |             ->apply($this->makeResource(), [])
37 |             ->getContent();
38 |         $this->assertEquals($this->css, $result);
39 |     }
40 | 
41 |     public function testCacheSalt() {
42 |         $filter = new Filter();
43 |         $resource = $this->makeResource();
44 |         $this->assertNotEquals(
45 |             $filter->getCacheSalt($resource, []),
46 |             $filter->getCacheSalt($resource, ['strip-imports' => 1])
47 |         );
48 |     }
49 | 
50 |     private function makeResource() {
51 |         return Resource::makeWithContent(URL::fromString('http://phast.test'), $this->css);
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/test/php/Filters/HTML/BaseURLSetter/FilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML\BaseURLSetter;
 4 | 
 5 | use Kibo\Phast\Filters\HTML\HTMLFilterTestCase;
 6 | use Kibo\Phast\Filters\HTML\HTMLPageContext;
 7 | use Kibo\Phast\Filters\HTML\HTMLStreamFilter;
 8 | use Kibo\Phast\Parsing\HTML\HTMLStreamElements\Tag;
 9 | 
10 | class FilterTest extends HTMLFilterTestCase {
11 |     public function testBaseURLSetting() {
12 |         $checkPoint1 = $this->makeMarkedElement('meta');
13 |         $checkPoint1->setAttribute('data-expected-base', self::BASE_URL);
14 |         $this->head->appendChild($checkPoint1);
15 | 
16 |         $baseWithTarget = $this->makeMarkedElement('base');
17 |         $baseWithTarget->setAttribute('target', '_self');
18 |         $this->head->appendChild($baseWithTarget);
19 | 
20 |         $checkPoint2 = $this->makeMarkedElement('meta');
21 |         $checkPoint2->setAttribute('data-expected-base', self::BASE_URL);
22 |         $this->head->appendChild($checkPoint2);
23 | 
24 |         $baseWithHref = $this->makeMarkedElement('base');
25 |         $baseWithHref->setAttribute('href', '/dir/');
26 |         $this->head->appendChild($baseWithHref);
27 | 
28 |         $checkPoint3 = $this->makeMarkedElement('meta');
29 |         $checkPoint3->setAttribute('data-expected-base', self::BASE_URL . '/dir/');
30 |         $this->head->appendChild($checkPoint3);
31 | 
32 |         $this->filter = $this->createMock(HTMLStreamFilter::class);
33 |         $this->filter->expects($this->once())
34 |             ->method('transformElements')
35 |             ->willReturnCallback(function (\Traversable $elements, HTMLPageContext $context) {
36 |                 /** @var Tag $element */
37 |                 foreach ($elements as $element) {
38 |                     if ($element instanceof Tag && $element->hasAttribute('data-expected-base')) {
39 |                         $this->assertEquals(
40 |                             $element->getAttribute('data-expected-base'),
41 |                             $context->getBaseUrl()
42 |                         );
43 |                     }
44 |                     yield $element;
45 |                 }
46 |             });
47 | 
48 |         $this->applyFilter();
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/test/php/Filters/HTML/CommentsRemoval/FilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML\CommentsRemoval;
 4 | 
 5 | use Kibo\Phast\Filters\HTML\HTMLFilterTestCase;
 6 | 
 7 | class FilterTest extends HTMLFilterTestCase {
 8 |     public function setUp(): void {
 9 |         parent::setUp();
10 |         $this->filter = new Filter();
11 |     }
12 | 
13 |     public function testCommentsRemoval() {
14 |         $html = '<html><head><!-- Comment here --></head><body><!-- another here--></body></html>';
15 |         $actual = $this->applyFilter($html, true);
16 |         $expected = '<html><head></head><body></body></html>';
17 |         $this->assertStringStartsWith($expected, $actual);
18 |     }
19 | 
20 |     public function testLeavingMSConditionals() {
21 |         $html = '<html><head><!--[if IE]>somethinf here<![endif]--></head><body></body></html>';
22 |         $actual = $this->applyFilter($html, true);
23 |         $this->assertStringStartsWith($html, $actual);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/test/php/Filters/HTML/DelayedIFrameLoading/FilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML\DelayedIFrameLoading;
 4 | 
 5 | use Kibo\Phast\Filters\HTML\HTMLFilterTestCase;
 6 | 
 7 | class FilterTest extends HTMLFilterTestCase {
 8 |     public function setUp(): void {
 9 |         parent::setUp();
10 |         $this->filter = new Filter();
11 |     }
12 | 
13 |     public function testRewriting() {
14 |         $iframe = $this->makeMarkedElement('iframe');
15 |         $iframe->setAttribute('src', 'http://example.com');
16 |         $this->body->appendChild($iframe);
17 | 
18 |         $this->applyFilter();
19 | 
20 |         $iframe = $this->getMatchingElement($iframe);
21 | 
22 |         $this->assertEquals('lazy', $iframe->getAttribute('loading'));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/test/php/Filters/HTML/ImagesOptimizationService/CSS/FilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\HTML\ImagesOptimizationService\CSS;
 4 | 
 5 | use Kibo\Phast\Filters\HTML\HTMLFilterTestCase;
 6 | use Kibo\Phast\Filters\HTML\ImagesOptimizationService\ImageURLRewriter;
 7 | 
 8 | class FilterTest extends HTMLFilterTestCase {
 9 |     /**
10 |      * @var \PHPUnit_Framework_MockObject_MockObject
11 |      */
12 |     private $rewriterMock;
13 | 
14 |     public function setUp(): void {
15 |         parent::setUp();
16 |         $this->rewriterMock = $this->createMock(ImageURLRewriter::class);
17 |         $this->rewriterMock->method('rewriteStyle')
18 |             ->willReturn('rewritten-style');
19 |         $this->filter = new Filter($this->rewriterMock);
20 |     }
21 | 
22 |     public function testRewritingInAttributes() {
23 |         $div = $this->makeMarkedElement('div');
24 |         $div->setAttribute('style', 'the-original-style');
25 |         $this->body->appendChild($div);
26 | 
27 |         $this->applyFilter();
28 | 
29 |         $div = $this->getMatchingElement($div);
30 |         $this->assertEquals('rewritten-style', $div->getAttribute('style'));
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/test/php/Filters/HTML/Minify/FilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Filters\HTML\Minify;
 3 | 
 4 | use Kibo\Phast\Filters\HTML\HTMLFilterTestCase;
 5 | 
 6 | class FilterTest extends HTMLFilterTestCase {
 7 |     public function setUp(): void {
 8 |         parent::setUp();
 9 |         $this->filter = new Filter();
10 |     }
11 | 
12 |     public function testMinify() {
13 |         $html = '
14 |             <html>
15 |                 <head>
16 |                     <title>Hello,  World!</title>
17 |                 </head>
18 |                 <body>
19 |                     <h1>
20 |                         Here
21 |                         we
22 |                         go!
23 |                     </h1>
24 |                     <textarea>  And  some  more  </TEXTAREA>
25 |                     Minify  this
26 |                     <pre>  This is <b>v  e  r  y</b> cool  </pre>
27 |                 </body>
28 |             </html>
29 |         ';
30 |         $actual = $this->applyFilter($html, true);
31 |         $expected = "\n<html>\n<head>\n<title>Hello, World!</title>\n</head>\n<body>\n<h1>\nHere\nwe\ngo!\n</h1>\n<textarea>  And  some  more  </TEXTAREA>\nMinify this\n<pre>  This is <b>v  e  r  y</b> cool  </pre>\n</body>\n</html>";
32 |         $this->assertStringStartsWith($expected, $actual);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/test/php/Filters/HTML/MinifyScripts/FilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Filters\HTML\MinifyScripts;
 3 | 
 4 | use Kibo\Phast\Cache\Sqlite\Cache;
 5 | use Kibo\Phast\Filters\HTML\HTMLFilterTestCase;
 6 | 
 7 | class FilterTest extends HTMLFilterTestCase {
 8 |     public function setUp(): void {
 9 |         parent::setUp();
10 |         $cache = $this->createMock(Cache::class);
11 |         $cache->method('get')->will($this->returnCallback(function ($k, $cb) {
12 |             return $cb();
13 |         }));
14 |         $this->filter = new Filter($cache);
15 |     }
16 | 
17 |     public function testMinifyScripts() {
18 |         $html = '
19 |             <script type=json>
20 |                 {
21 |                     "hello": "w\u00f6rld",
22 |                     "a/b": "<\/script>"
23 |                 }
24 |             </script>
25 |             <script>{ nope }</script>
26 |             <script><!--
27 |             { yah }
28 |             --></script>
29 |         ';
30 |         $actual = $this->applyFilter($html, true);
31 |         $this->assertStringContainsString('<script type=json>{"hello":"wörld","a/b":"<\/script>"}</script>', $actual);
32 |         $this->assertStringContainsString('<script>{nope}</script>', $actual);
33 |         $this->assertStringContainsString('<script>{yah}</script>', $actual);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/test/php/Filters/JavaScript/Minification/JSMinifierFilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Filters\JavaScript\Minification;
 4 | 
 5 | use Kibo\Phast\PhastTestCase;
 6 | use Kibo\Phast\ValueObjects\Resource;
 7 | use Kibo\Phast\ValueObjects\URL;
 8 | 
 9 | class JSMinifierFilterTest extends PhastTestCase {
10 |     public function testGetCacheSalt() {
11 |         $filter1 = new JSMinifierFilter(false);
12 |         $filter2 = new JSMinifierFilter(true);
13 |         $resource = Resource::makeWithContent(URL::fromString(self::BASE_URL), 'the-content');
14 |         $this->assertNotEquals($filter1->getCacheSalt($resource, []), $filter2->getCacheSalt($resource, []));
15 |     }
16 | 
17 |     public function testControlCharacters() {
18 |         $filter = new JSMinifierFilter(true);
19 |         $resource = Resource::makeWithContent(URL::fromString(self::BASE_URL), " alert( '\x13' ); ");
20 |         $result = $filter->apply($resource, []);
21 |         $this->assertEquals("alert('\x13');", $result->getContent());
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/test/php/Filters/Text/Decode/FilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\Filters\Text\Decode;
 3 | 
 4 | use Kibo\Phast\ValueObjects\Resource;
 5 | use Kibo\Phast\ValueObjects\URL;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class FilterTest extends TestCase {
 9 |     /** @dataProvider decodeData */
10 |     public function testDecode($input) {
11 |         $result = (new Filter())
12 |             ->apply(Resource::makeWithContent(URL::fromString(''), $input))
13 |             ->getContent();
14 | 
15 |         $this->assertEquals($result, 'Hello, World!');
16 |     }
17 | 
18 |     public function decodeData() {
19 |         yield ['Hello, World!'];
20 |         yield ["\xef\xbb\xbfHello, World!"];
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/test/php/HTTP/CURLClientTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\HTTP;
 4 | 
 5 | use Kibo\Phast\ValueObjects\URL;
 6 | 
 7 | class CURLClientTest extends \PHPUnit\Framework\TestCase {
 8 |     public function setUp(): void {
 9 |         parent::setUp();
10 |         if (!function_exists('curl_init')) {
11 |             $this->markTestSkipped('cURL is missing');
12 |         }
13 |     }
14 | 
15 |     public function testGet() {
16 |         $client = new CURLClient();
17 |         $result = $client->get(URL::fromString('http://whatismyip.akamai.com/'));
18 |         $this->assertEquals(200, $result->getCode());
19 |         $this->assertMatchesRegularExpression('/^\d+\.\d+\.\d+\.\d+/', $result->getContent());
20 |         $this->assertArraySubset(['Content-Type' => 'text/html'], $result->getHeaders());
21 |     }
22 | 
23 |     public function testPost() {
24 |         $client = new CURLClient();
25 |         $data = str_repeat('x', 5e6);
26 |         $result = $client->post(URL::fromString('http://optimize.phast.io/?service=images'), $data);
27 |         $this->assertStringNotContainsString('HTTP/', $result->getContent());
28 |         $this->assertNotEmpty($result->getHeaders());
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/test/php/HTTP/DefaultConfigurationTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Kibo\Phast\HTTP;
 3 | 
 4 | use Kibo\Phast\Environment\Configuration;
 5 | use Kibo\Phast\ValueObjects\URL;
 6 | 
 7 | class DefaultConfigurationTest extends \PHPUnit\Framework\TestCase {
 8 |     public function testRetrieveURL() {
 9 |         $clientFactory = new ClientFactory();
10 |         $config = Configuration::fromDefaults()->toArray();
11 |         $client = $clientFactory->make($config);
12 |         $url = URL::fromString('https://1.1.1.1/');
13 |         if (!function_exists('curl_init')) {
14 |             $this->expectException(Exceptions\NetworkError::class);
15 |         }
16 |         $response = $client->get($url);
17 |         $this->assertStringContainsString('<html', $response->getContent());
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/test/php/HTTP/RequestTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\HTTP;
 4 | 
 5 | class RequestTest extends \PHPUnit\Framework\TestCase {
 6 |     /** @dataProvider pathInfoData */
 7 |     public function testPathInfo($env) {
 8 |         $req = Request::fromArray([], $env, []);
 9 |         $this->assertEquals('/test', $req->getPathInfo());
10 |     }
11 | 
12 |     /** @dataProvider negativePathInfoData */
13 |     public function testNegativePathInfo($env) {
14 |         $req = Request::fromArray([], $env, []);
15 |         $this->assertSame(null, $req->getPathInfo());
16 |     }
17 | 
18 |     public function pathInfoData() {
19 |         yield [['PATH_INFO' => '/test']];
20 |         yield [['REQUEST_URI' => '/some/php/path.php/test']];
21 |     }
22 | 
23 |     public function negativePathInfoData() {
24 |         yield [['REQUEST_URI' => '/some.php']];
25 |     }
26 | 
27 |     /** @dataProvider documentRootData */
28 |     public function testDocumentRoot($env, $expectedDocumentRoot) {
29 |         $req = Request::fromArray([], $env, []);
30 |         $this->assertEquals($expectedDocumentRoot, $req->getDocumentRoot());
31 |     }
32 | 
33 |     public function documentRootData() {
34 |         yield [
35 |             [
36 |                 'DOCUMENT_ROOT' => '/var/www',
37 |             ],
38 |             '/var/www',
39 |         ];
40 | 
41 |         yield [
42 |             [
43 |                 'DOCUMENT_ROOT' => '/var/www',
44 |                 'SCRIPT_FILENAME' => '/var/www/subdomain/index.php',
45 |                 'SCRIPT_NAME' => '/index.php',
46 |             ],
47 |             '/var/www/subdomain',
48 |         ];
49 | 
50 |         yield [
51 |             [
52 |                 'DOCUMENT_ROOT' => '/var/www',
53 |                 'SCRIPT_FILENAME' => '/var/www/subdomain/index.php',
54 |                 'SCRIPT_NAME' => '/mismatch.php',
55 |             ],
56 |             '/var/www',
57 |         ];
58 | 
59 |         yield [
60 |             [
61 |                 'DOCUMENT_ROOT' => 'C:\\var\\www',
62 |                 'SCRIPT_FILENAME' => 'C:\\var\\www\\subdomain\\index.php',
63 |                 'SCRIPT_NAME' => '/index.php',
64 |             ],
65 |             'C:/var/www/subdomain',
66 |         ];
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/test/php/Logging/LogWriters/BaseLogWriterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Logging\LogWriters;
 4 | 
 5 | use Kibo\Phast\Logging\LogEntry;
 6 | use Kibo\Phast\Logging\LogLevel;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class BaseLogWriterTest extends TestCase {
10 |     public function testLogMasking() {
11 |         $levels = 0;
12 |         $writer = $this->getMockForAbstractClass(BaseLogWriter::class);
13 |         $writer->expects($this->exactly(2))
14 |             ->method('doWriteEntry')
15 |             ->willReturnCallback(function (LogEntry $entry) use (&$levels) {
16 |                 $levels |= $entry->getLevel();
17 |             });
18 |         $mask = LogLevel::INFO | LogLevel::ERROR;
19 |         $writer->setLevelMask($mask);
20 |         for ($level = LogLevel::DEBUG; $level <= LogLevel::EMERGENCY; $level = $level << 1) {
21 |             $writer->writeEntry(new LogEntry($level, '', []));
22 |         }
23 |         $this->assertEquals($mask, $levels);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/test/php/Logging/LogWriters/Composite/WriterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Logging\LogWriters\Composite;
 4 | 
 5 | use Kibo\Phast\Logging\LogEntry;
 6 | use Kibo\Phast\Logging\LogLevel;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class WriterTest extends TestCase {
10 |     public function testCallingOthers() {
11 |         $message = new LogEntry(LogLevel::ERROR, '', []);
12 |         $writer = new Writer();
13 |         for ($i = 0; $i < 10; $i++) {
14 |             $otherWriter = $this->createMock(Writer::class);
15 |             $otherWriter->expects($this->once())
16 |                 ->method('writeEntry')
17 |                 ->with($message);
18 |             $writer->addWriter($otherWriter);
19 |         }
20 |         $writer->writeEntry($message);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/test/php/Logging/LogWriters/JSONLFile/WriterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Logging\LogWriters\JSONLFile;
 4 | 
 5 | use Kibo\Phast\Logging\LogEntry;
 6 | use Kibo\Phast\Logging\LogLevel;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class WriterTest extends TestCase {
10 |     /**
11 |      * @dataProvider getWriteMessageTestData
12 |      */
13 |     public function testWriteMessage($suffix) {
14 |         $dir = sys_get_temp_dir() . '/phast-test';
15 | 
16 |         $fileSuffix = preg_replace('/[^0-9A-Za-z_-]/', '', (string) $suffix);
17 |         if (!empty($fileSuffix)) {
18 |             $fileSuffix = '-' . $fileSuffix;
19 |         }
20 |         $filename = $dir . '/log' . $fileSuffix . '.jsonl';
21 | 
22 |         @unlink($filename);
23 | 
24 |         $writer = new Writer($dir, $suffix);
25 |         $message = new LogEntry(LogLevel::DEBUG, 'The message', ['key' => 'value']);
26 |         $writer->writeEntry($message);
27 | 
28 |         $written = file_get_contents($filename);
29 |         $this->assertStringEndsWith("\n", $written);
30 |         $decoded = json_decode(trim($written), true);
31 |         $this->assertEquals(LogLevel::DEBUG, $decoded['level']);
32 |         $this->assertEquals('The message', $decoded['message']);
33 |         $this->assertEquals(['key' => 'value'], $decoded['context']);
34 |     }
35 | 
36 |     public function getWriteMessageTestData() {
37 |         return [[null], ['123'], ['../../123zxcZXC-_']];
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/test/php/PhastTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | 
 7 | abstract class PhastTestCase extends TestCase {
 8 |     const BASE_URL = 'http://phast.test';
 9 | }
10 | 


--------------------------------------------------------------------------------
/test/php/Retrievers/PostDataRetrieverTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Retrievers;
 4 | 
 5 | use Kibo\Phast\Common\ObjectifiedFunctions;
 6 | use Kibo\Phast\PhastTestCase;
 7 | use Kibo\Phast\ValueObjects\URL;
 8 | 
 9 | class PostDataRetrieverTest extends PhastTestCase {
10 |     public function testRetriever() {
11 |         $funcs =  new ObjectifiedFunctions();
12 | 
13 |         $openedFile = null;
14 |         $funcs->file_get_contents = function ($file) use (&$openedFile) {
15 |             $openedFile = $file;
16 |             return 'the-content';
17 |         };
18 | 
19 |         $retriever = new PostDataRetriever($funcs);
20 |         $url = URL::fromString(self::BASE_URL);
21 |         $actualContent = $retriever->retrieve($url);
22 |         $actualSalt = $retriever->getCacheSalt($url);
23 | 
24 |         $this->assertEquals('the-content', $actualContent);
25 |         $this->assertNotEmpty($actualSalt);
26 |         $this->assertEquals('php://input', $openedFile);
27 | 
28 |         $openedFile = false;
29 |         $this->assertEquals($actualContent, $retriever->retrieve($url));
30 |         $this->assertEquals($actualSalt, $retriever->getCacheSalt($url));
31 |         $this->assertFalse($openedFile);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/test/php/Services/Bundler/BundlerParamsParserTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\Services\Bundler;
 4 | 
 5 | use Kibo\Phast\PhastTestCase;
 6 | use Kibo\Phast\Services\ServiceRequest;
 7 | 
 8 | class BundlerParamsParserTest extends PhastTestCase {
 9 |     public function testGroupsParsing() {
10 |         $params = ['a_0' => 'a0', 'a_1' => 'a1', 't_0' => 't0', 't_1' => 't1', 'ignored' => 'none'];
11 |         $request = (new ServiceRequest())->withParams($params);
12 | 
13 |         $expected = [['a' => 'a0', 't' => 't0'], ['a' => 'a1', 't' => 't1']];
14 |         $actual = (new BundlerParamsParser())->parse($request);
15 |         $this->assertEquals($expected, $actual);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/test/php/ValueObjects/PhastJavaScriptTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kibo\Phast\ValueObjects;
 4 | 
 5 | use Kibo\Phast\Common\ObjectifiedFunctions;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class PhastJavaScriptTest extends TestCase {
 9 |     public function testFromFile() {
10 |         $funcs = new ObjectifiedFunctions();
11 |         $filename = 'the-test';
12 |         $script = 'var q = 123';
13 |         $funcs->file_get_contents = function ($name) use ($filename, $script) {
14 |             $this->assertEquals($filename, $name);
15 |             return $script;
16 |         };
17 |         $js = PhastJavaScript::fromFile($filename, $funcs);
18 |         $this->assertEquals($filename, $js->getFilename());
19 |         $this->assertEquals('var q=123', $js->getContents());
20 |         $this->assertEquals(substr(base64_encode(md5($script, true)), 0, 16), $js->getCacheSalt());
21 |     }
22 | 
23 |     public function testFromString() {
24 |         $js = PhastJavaScript::fromString('abc.js', 'var q = 123');
25 |         $this->assertEquals('abc.js', $js->getFilename());
26 |         $this->assertEquals('var q = 123', $js->getContents());
27 |         $this->assertEquals(substr(base64_encode(md5('var q = 123', true)), 0, 16), $js->getCacheSalt());
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/test/php/build.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | spl_autoload_register(function ($class) {
 4 |     $namespaces = [
 5 |         'Kibo\\Phast' => 'test/php',
 6 |     ];
 7 |     $parts = explode('\\', $class);
 8 |     foreach ($namespaces as $ns => $dir) {
 9 |         $nsParts = explode('\\', $ns);
10 |         if ($nsParts != array_slice($parts, 0, sizeof($nsParts))) {
11 |             continue;
12 |         }
13 |         $path = $dir . '/' . implode('/', array_slice($parts, sizeof($nsParts))) . '.php';
14 |         if (file_exists($path)) {
15 |             require $path;
16 |         }
17 |     }
18 | });
19 | 
20 | spl_autoload_register(function ($class) {
21 |     $namespaces = [
22 |         'PHPUnit' => 'vendor/phpunit/phpunit/src',
23 |     ];
24 |     $parts = explode('_', $class);
25 |     foreach ($namespaces as $ns => $dir) {
26 |         $nsParts = explode('_', $ns);
27 |         if ($nsParts != array_slice($parts, 0, sizeof($nsParts))) {
28 |             continue;
29 |         }
30 |         $path = $dir . '/' . implode('/', array_slice($parts, sizeof($nsParts))) . '.php';
31 |         if (file_exists($path)) {
32 |             require $path;
33 |         }
34 |     }
35 | });
36 | 
37 | require_once __DIR__ . '/../../build/phast.php';
38 | 


--------------------------------------------------------------------------------
/test/test-app/css/.htaccess:
--------------------------------------------------------------------------------
1 | Deny from all
2 | 


--------------------------------------------------------------------------------
/test/test-app/css/styles.css:
--------------------------------------------------------------------------------
 1 | @import "styles2.css" projection;
 2 | @import "styles2.css";
 3 | body {
 4 |     background: black;
 5 |     color: navajowhite;
 6 |     font-family: 'VT323', monospace;
 7 |     background-image: url(../images/batman.jpg);
 8 | }
 9 | .my-class {
10 |     background: red;
11 | }
12 | .some-other-class {
13 |     background: yellow;
14 |     color: black;
15 | }
16 | 


--------------------------------------------------------------------------------
/test/test-app/css/styles2.css:
--------------------------------------------------------------------------------
1 | @import "styles.css";
2 | body {
3 |     background: red;
4 | }
5 | 


--------------------------------------------------------------------------------
/test/test-app/images/.htaccess:
--------------------------------------------------------------------------------
1 | Deny from all
2 | 


--------------------------------------------------------------------------------
/test/test-app/images/basset.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kiboit/phast/96a50e2fcd71c6db72ac451e1f10d9c92f7f6b6a/test/test-app/images/basset.png


--------------------------------------------------------------------------------
/test/test-app/images/basset@2x.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kiboit/phast/96a50e2fcd71c6db72ac451e1f10d9c92f7f6b6a/test/test-app/images/basset@2x.png


--------------------------------------------------------------------------------
/test/test-app/images/batman.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kiboit/phast/96a50e2fcd71c6db72ac451e1f10d9c92f7f6b6a/test/test-app/images/batman.jpg


--------------------------------------------------------------------------------
/test/test-app/images/batman@2x.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kiboit/phast/96a50e2fcd71c6db72ac451e1f10d9c92f7f6b6a/test/test-app/images/batman@2x.jpg


--------------------------------------------------------------------------------
/test/test-app/images/python.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kiboit/phast/96a50e2fcd71c6db72ac451e1f10d9c92f7f6b6a/test/test-app/images/python.png


--------------------------------------------------------------------------------
/test/test-app/js/.htaccess:
--------------------------------------------------------------------------------
1 | Deny from all
2 | 


--------------------------------------------------------------------------------
/test/test-app/js/deferred.js:
--------------------------------------------------------------------------------
1 | console.log("Deferred loaded");
2 | 


--------------------------------------------------------------------------------
/test/test-app/js/injected.js:
--------------------------------------------------------------------------------
1 | console.log("Injected script loaded");
2 | 


--------------------------------------------------------------------------------
/test/test-app/js/main.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | /*
 3 |  comment that we shouldn't see
 4 |  */
 5 | /*!
 6 |  * some license here
 7 |  * some license here
 8 |  */
 9 | var a;
10 | /*
11 |  comment that we shouldn't see
12 |  */
13 | console.log("Main JS Loaded");
14 | 
15 | console.log("Main minification");
16 | 
17 | var something = "yolo";
18 | 
19 | var injectedScript = document.createElement("script");
20 | injectedScript.src = "js/injected.js";
21 | document.body.appendChild(injectedScript);
22 | 


--------------------------------------------------------------------------------
/test/test-app/phast.php:
--------------------------------------------------------------------------------
1 | <?php
2 | require __DIR__ . '/../../build/phast.php';
3 | \Kibo\Phast\PhastServices::serve(function () {
4 |     return require __DIR__ . '/test-config.php';
5 | });
6 | 


--------------------------------------------------------------------------------
/test/test-app/test-config.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | return [
 3 |     'documents' => [
 4 |         'filters' => [
 5 |             Kibo\Phast\Filters\HTML\ScriptsProxyService\Filter::class => [
 6 |                 'match' => [
 7 |                     '~https?://ajax\.googleapis\.com/~',
 8 |                 ],
 9 |             ],
10 |         ],
11 |     ],
12 | ];
13 | 


--------------------------------------------------------------------------------
/yarn.lock:
--------------------------------------------------------------------------------
 1 | # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
 2 | # yarn lockfile v1
 3 | 
 4 | 
 5 | prettier@^2.3.2:
 6 |   version "2.6.0"
 7 |   resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.6.0.tgz#12f8f504c4d8ddb76475f441337542fa799207d4"
 8 |   integrity sha512-m2FgJibYrBGGgQXNzfd0PuDGShJgRavjUoRCw1mZERIWVSXF0iLzLm+aOqTAbLnC3n6JzUhAA8uZnFVghHJ86A==
 9 | 
10 | uglify-js@^3.6.0:
11 |   version "3.15.3"
12 |   resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.15.3.tgz#9aa82ca22419ba4c0137642ba0df800cb06e0471"
13 |   integrity sha512-6iCVm2omGJbsu3JWac+p6kUiOpg3wFO2f8lIXjfEb8RrmLjzog1wTPMmwKB7swfzzqxj9YM+sGUM++u1qN4qJg==
14 | 


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