protected function createApplicationContainer()
{
$this->app = new \TestContainer();
$this->app->singleton('config', function () {
return new \Illuminate\Config\Repository();
});
$this->registerConfigure();
$eventServiceProvider = new \Illuminate\Encryption\EncryptionServiceProvider($this->app);
$eventServiceProvider->register();
$eventServiceProvider = new \Illuminate\Events\EventServiceProvider($this->app);
$eventServiceProvider->register();
$queueProvider = new \Illuminate\Queue\QueueServiceProvider($this->app);
$queueProvider->register();
$sessionProvider = new \Illuminate\Session\SessionServiceProvider($this->app);
$sessionProvider->register();
$this->registerDatabase();
$this->registerCache();
$couchbaseProvider = new \Ytake\LaravelCouchbase\CouchbaseServiceProvider($this->app);
$couchbaseProvider->register();
$couchbaseProvider->boot();
$this->app->bind(\Illuminate\Container\Container::class, function () {
return $this->app;
});
(new \Illuminate\Events\EventServiceProvider($this->app))->register();
\Illuminate\Container\Container::setInstance($this->app);
}
public function __construct(array $attributes)
{
$this->encrypter = new Encrypter('088409730f085dd15e8e3a7d429dd185', 'AES-256-CBC');
$app = new Container();
$app->singleton('app', 'Illuminate\\Container\\Container');
$app->singleton('config', 'Illuminate\\Config\\Repository');
$app['config']->set('elocrypt.prefix', '__ELOCRYPT__:');
Facade::setFacadeApplication($app);
parent::__construct($attributes);
}
/**
* {@inheritdoc}
*/
protected function setUp()
{
parent::setUp();
$app = new Container();
$app->singleton('app', 'Illuminate\\Config\\Repository');
$app->singleton('config', 'Illuminate\\Config\\Repository');
Facade::setFacadeApplication($app);
$app['app']->set('aliases.Config', Illuminate\Support\Facades\Config::class);
$api_key = empty(getenv('YANDEX_API_KEY')) ? include_once 'yandex.api.key.php' : getenv('YANDEX_API_KEY');
$app['config']->set('services.yandex-translate.key', $api_key);
$this->translate = new Translate();
}
/**
* @param Configuration $configuration
* @return void
*/
public function initialize(Configuration $configuration)
{
// start up the service locator
$this->container = new Container();
foreach ($this->default_components as $k => $v) {
if ($k == 'parser.login' and $configuration->getRetsVersion()->isAtLeast1_8()) {
$v = '\\PHRETS\\Parsers\\Login\\OneEight';
}
$this->container->singleton($k, function () use($v) {
return new $v();
});
}
}
/**
* Set up required container bindings.
*
* @param Container $app
*/
public function boot(Container $app)
{
$app->singleton('files', Filesystem::class);
$app->singleton('events', function ($app) {
return new Dispatcher($app);
});
$app->bind(Builder::class, function ($app) {
return new Builder($app, $app['config']['build.pipeline']);
});
$app->bind(Factory::class, function ($app) {
$engineResolver = $app->make(EngineResolver::class);
$viewFinder = $app->make(FileViewFinder::class, [$app['files'], [$app['config']['source.directory']]]);
return new Factory($engineResolver, $viewFinder, $app['events']);
});
$this->bindAliasesForPipeline($app);
}
/**
* Register the view finder implementation.
*
* @return void
*/
public function registerViewFinder()
{
$me = $this;
$this->container->singleton('view.finder', function ($app) use($me) {
$paths = $me->viewPaths;
return new FileViewFinder($app['files'], $paths);
});
}
/**
* Bind the Warkham classes to the Container
*
* @param Container $app
*
* @return Container
*/
public function bindWarkhamClasses(Container $app)
{
$app->singleton('warkham', function ($app) {
$methodDispatcher = array('Warkham\\Fields\\', Warkham::FIELDSPACE);
$methodDispatcher = new MethodDispatcher($app, $methodDispatcher);
return new Warkham($app, $methodDispatcher);
});
return $app;
}
/**
* @param bool $cache
*/
public function __construct($cache)
{
$this->filesystem = new Filesystem();
$this->moduleContainer = new Container();
$this->cache = !$cache;
$container = AppFactory::getInstance()->getContainer();
$container['cache'] = function () {
$cacheContainer = new Container();
$cacheContainer->singleton('files', function () {
return new Filesystem();
});
$cacheContainer->singleton('config', function () {
return AppFactory::getInstance()->getContainer()->config['cache'];
});
return new CacheManager($cacheContainer);
};
$this->cacheManager = $container->get('cache');
}
/**
* Build a new Form instance
*
* @param UrlGenerator $url
*/
public function __construct(Container $app, $url, Populator $populator)
{
$this->app = $app;
$this->url = $url;
$this->populator = $populator;
$this->app->singleton('former.form.framework', function ($app) {
return clone $app['former.framework'];
});
}
/**
* Ensure the base event and file bindings are present. Required for binding anything else.
*
* @param Container $app
* @return void
*/
public function ensureIlluminateBase(Container $app = null)
{
if (!$app->bound('events')) {
$app->singleton('events', $this->illuminateClasses['events']);
$app['events']->fire('booting');
}
if (!$app->bound('files')) {
$app->bindIf('files', $this->illuminateClasses['files']);
}
}
/**
* @test
*/
public function it_should_not_auto_inject_dependencies_from_local_container_into_services_from_parent_container()
{
$this->local->singleton(Helper::class, function () {
return new Helper(uniqid());
});
$this->parent->singleton(Service::class, function (Container $c) {
return $c->build(Service::class);
});
$this->setExpectedException(BindingResolutionException::class);
$this->local->make(Service::class);
}
protected function createApplicationContainer()
{
$this->app = new \Illuminate\Container\Container();
$this->app->singleton('config', function () {
return new \Illuminate\Config\Repository();
});
$this->app->instance('log', $log = new \Illuminate\Log\Writer(new \Monolog\Logger('testing')));
$this->app->instance('Psr\\Log\\LoggerInterface', $log = new \Illuminate\Log\Writer(new \Monolog\Logger('testing')));
$this->registerConfigure();
$this->registerDatabase();
$this->registerCache();
$annotationConfiguration = new \Ytake\LaravelAspect\AnnotationConfiguration($this->app['config']->get('ytake-laravel-aop.annotation'));
$annotationConfiguration->ignoredAnnotations();
$this->app->singleton('aspect.manager', function ($app) {
return new \Ytake\LaravelAspect\AspectManager($app);
});
$this->app->bind(\Illuminate\Container\Container::class, function () {
return $this->app;
});
\Illuminate\Container\Container::setInstance($this->app);
}
/**
* Register the view environment.
*
* @return Illuminate\View\Factory
*/
protected function registerFactory()
{
$this->container->singleton('view', function ($container) {
// Next we need to grab the engine resolver instance that will be used by the
// environment. The resolver will be used by an environment to get each of
// the various engine implementations such as plain PHP or Blade engine.
$resolver = $container['view.engine.resolver'];
$finder = $container['view.finder'];
$env = new Factory($resolver, $finder, $container['events']);
// We will also set the container instance on this view environment since the
// view composers may be classes registered in the container, which allows
// for great testable, flexible composers for the application developer.
$env->setContainer($container);
$env->share('app', $container);
return $env;
});
}
/**
* Run the build command.
*
* @return bool
*/
protected function build()
{
$container = new Container();
$container->singleton('files', Filesystem::class);
$container->bind(Factory::class, function ($app) {
return new Factory($app->make(EngineResolver::class), new FileViewFinder($app['files'], ['test/source']), new Dispatcher($app));
});
$container->afterResolving(function (Factory $factory, $app) {
$factory->addExtension('php', 'php', function () {
return new PhpEngine();
});
$factory->addExtension('blade.php', 'blade', function () use($app) {
return new CompilerEngine(new BladeCompiler($app['files'], vfsStream::url('test/.cache')));
});
});
$builder = new Builder($container, [Skip::class . ':_*', Compile::class]);
return $builder->build(vfsStream::url('test/source'), vfsStream::url('test/build'));
}
/**
* Add a singleton definition to the container.
* Not sure if generally required, but this call quietly wraps non-callable $concrete
* implementations with an anonymous function. (i.e.: Simplifies illuminate/container call.)
*
* @param string|array $abstract
* @param mixed $concrete
*
* @return void
*/
public function singleton($abstract, $concrete = NULL)
{
$alias = NULL;
if (is_array($abstract)) {
$alias = $abstract[0];
$abstract = $abstract[1];
# register the alias because the alias is provided
static::$container->alias($abstract, $alias);
}
if (!is_callable($concrete)) {
static::$container->singleton($abstract, function () use($concrete) {
return $concrete;
});
}
if (is_callable($concrete)) {
static::$container->singleton($abstract, $concrete);
}
}
public function test_queue_with_synchronous_driver_and_in_memory_pubsub_fires_event_with_expected_return_value()
{
$pubsub = new InMemoryPubSub();
$container = new Container();
$container->singleton(IlluminateQueueHandler::class, function () use($pubsub) {
return new IlluminateQueueHandler($pubsub, new Serializer());
});
$driver = new SyncQueue();
$driver->setContainer($container);
$called = false;
$pubsub->on('kyew:task:random-task-id', function ($publishedValue) use(&$called) {
$this->assertEquals('foo!bar!', $publishedValue);
$called = true;
});
$queue = new IlluminateQueue($driver, new Serializer());
$queue->push('random-task-id', function () {
return 'foo!bar!';
});
$this->assertTrue($called);
}
public static function setUpBeforeClass()
{
$container = new Container();
$container->bind('config', function () {
return Mockery::mock('Config', function ($mock) {
$mock->shouldReceive('get')->andReturnUsing(function ($key) {
if ($key == 'database.mongodb.default') {
return array('host' => 'localhost', 'port' => 27017, 'database' => 'mongovel_tests');
}
if ($key == 'profiling.mongo') {
return false;
}
});
});
});
$container->singleton('mongoveldb', function () {
return new DB();
});
Mongovel::setContainer($container);
self::$db = Mongovel::getContainer()->make('mongoveldb');
}
/**
* Bind Former classes to the container
*
* @param Container $app
*
* @return Container
*/
public function bindFormer(Container $app)
{
// Add config namespace
$app['config']->package('anahkiasen/former', __DIR__ . '/../config');
// Get framework to use
$framework = $app['config']->get('former::framework');
$frameworkClass = '\\Former\\Framework\\' . $framework;
$app->bind('former.framework', function ($app) use($frameworkClass) {
return new $frameworkClass($app);
});
$app->singleton('former.populator', function ($app) {
return new Populator();
});
$app->singleton('former', function ($app) {
return new Former($app, new MethodDispatcher($app, Former::FIELDSPACE));
});
Helpers::setApp($app);
return $app;
}
public function testCanUserOtherContainers()
{
$container = new IlluminateContainer();
$container->singleton('foobar', function () {
return 'foobar';
});
$glue = new Glue(new Configuration(), $container);
$this->assertEquals('foobar', $glue->getContainer()->get('foobar'));
}
/**
* Bind an adapter to the container
*
* @param string $name
*/
protected function bindAdapter($name)
{
$alias = static::CONTAINER_ADAPTER_PREFIX . $name;
$this->container->singleton($alias, $this->list[$name]);
}
/**
* Bind Former classes to the container
*
* @param Container $app
*
* @return Container
*/
public function bindFormer(Container $app)
{
// Add config namespace
$app['config']->package('anahkiasen/former', __DIR__ . '/../config');
$app->bind('former.framework', function ($app) {
return $app['former']->getFrameworkInstance($app['config']->get('former::framework'));
});
$app->singleton('former.populator', function ($app) {
return new Populator();
});
$app->singleton('former.dispatcher', function ($app) {
return new MethodDispatcher($app, Former::FIELDSPACE);
});
$app->singleton('former', function ($app) {
return new Former($app, $app->make('former.dispatcher'));
});
Helpers::setApp($app);
return $app;
}
public function it_should_able_register_singleton_instance_to_container(Container $container)
{
$container->singleton('Test', 'Test')->shouldBeCalled();
$this->singleton('Test', 'Test');
}
/**
* Bind Former classes to the container.
*
* @param Container $app
*
* @return Container
*/
public function bindFormer(Container $app)
{
$framework = $app['config']->get('former.framework');
$app->bind('former.framework', function ($app) {
return $app['former']->getFrameworkInstance($app['config']->get('former.framework'));
});
$app->singleton('former.populator', function ($app) {
return new \Former\Populator();
});
$app->singleton('former.dispatcher', function ($app) {
return new \Former\MethodDispatcher($app, \Former\Former::FIELDSPACE);
});
$app->singleton('former', function ($app) {
return new \Former\Former($app, $app->make('former.dispatcher'));
});
$app->alias('former', 'Former\\Former');
\Former\Helpers::setApp($app);
return $app;
}
/**
* Register a shared binding in the container.
*
* @param string|array $abstract
* @param callable|string|null $concrete
*/
public function singleton($abstract, $concrete = null)
{
$this->delegate->singleton($abstract, $concrete);
}
/**
* Bind the Rocketeer classes to the Container
*
* @param Container $app
*
* @return Container
*/
public function bindClasses(Container $app)
{
$app->singleton('rocketeer.rocketeer', function ($app) {
return new Rocketeer($app);
});
$app->bind('rocketeer.releases', function ($app) {
return new ReleasesManager($app);
});
$app->bind('rocketeer.server', function ($app) {
$filename = $app['rocketeer.rocketeer']->getApplicationName();
$filename = $filename === '{application_name}' ? 'deployments' : $filename;
return new Server($app, $filename);
});
$app->bind('rocketeer.bash', function ($app) {
return new Bash($app);
});
$app->singleton('rocketeer.queue', function ($app) {
return new TasksQueue($app);
});
$app->singleton('rocketeer.tasks', function ($app) {
return new TasksHandler($app);
});
$app->singleton('rocketeer.logs', function ($app) {
return new LogsHandler($app);
});
$app->singleton('rocketeer.console', function () {
return new Console\Console('Rocketeer', Rocketeer::VERSION);
});
$app['rocketeer.console']->setLaravel($app);
$app['rocketeer.rocketeer']->syncConnectionCredentials();
return $app;
}
ini_set('error_reporting', E_ALL);
require_once __DIR__ . '/vendor/autoload.php';
use Illuminate\Container\Container;
use Illuminate\Support\Facades\App;
use Illuminate\Support\Facades\Facade;
use Illuminate\Database\Capsule\Manager as DB;
use Illuminate\Events\Dispatcher;
use Psr\Log\LoggerInterface;
use Monolog\Logger;
use Monolog\Handler\ErrorLogHandler;
use Jvelo\Datatext\Cli\Cli;
$capsule = new DB();
$capsule->addConnection(['driver' => 'pgsql', 'host' => 'localhost', 'database' => 'datatext', 'username' => 'jerome', 'password' => '', 'charset' => 'utf8', 'prefix' => '', 'schema' => 'public']);
$container = new Container();
$container->singleton("db", function () use($capsule) {
return $capsule->getDatabaseManager();
});
$container->singleton("datatext.user_provider", '\\Jvelo\\Datatext\\ConstantAdminUserProvider');
$container->singleton("datatext.shortcodes", '\\Jvelo\\Datatext\\Shortcodes\\Shortcodes');
$container->singleton("datatext.assets_manager", '\\Jvelo\\Datatext\\Assets\\DefaultAssets');
$container->singleton("datatext.api.pages", '\\Jvelo\\Datatext\\Api\\Pages');
Facade::setFacadeApplication($container);
$capsule->setEventDispatcher(new Dispatcher($container));
$capsule->setAsGlobal();
$capsule->bootEloquent();
$container->bind('CreatePageAndObjectTables', '\\CreatePageAndObjectTables');
$container->bind('Schema', '\\Illuminate\\Database\\Schema\\Builder');
$container->singleton('app', function () use($container) {
return $container;
});
$cli = new Cli();
/**
* Bind the Acetone classes to the Container
*
* @param Container $app
*
* @return Container
*/
public function bindClasses(Container $app)
{
$app->singleton('acetone.acetone', function ($app) {
return new Acetone($app);
});
return $app;
}
/**
* Bind Form classes to the container
*
* @param Container $app
*
* @return Container
*/
public function bindForm(Container $app)
{
// Add config namespace
$configPath = __DIR__ . '/../config/form.php';
$this->mergeConfigFrom($configPath, 'form');
$this->publishes([$configPath => $app['path.config'] . '/form.php']);
$framework = $app['config']->get('form.framework');
$app->bind('form.framework', function ($app) {
return $app['form']->getFrameworkInstance($app['config']->get('form.framework'));
});
$app->singleton('form.populator', function ($app) {
return new Populator();
});
$app->singleton('form.dispatcher', function ($app) {
return new MethodDispatcher($app, Form::FIELDSPACE);
});
$app->singleton('form', function ($app) {
return new Form($app, $app->make('form.dispatcher'));
});
$app->alias('form', 'Form\\Form');
Helpers::setApp($app);
return $app;
}
/**
* Bind the ActiveResource classes to the Container
*
* @param Container $app
*
* @return Container
*/
public function bindClasses(Container $app)
{
$app->singleton('trucker.urls', function ($app) {
return new Url\UrlGenerator($app);
});
$app->singleton('trucker.config-manager', function ($app) {
return new Support\ConfigManager($app);
});
$app->bind('trucker.instance-finder', function ($app) {
return new Finders\InstanceFinder($app);
});
$app->bind('trucker.collection-finder', function ($app) {
return new Finders\CollectionFinder($app);
});
$app->bind('trucker.response', function ($app) {
return new Responses\Response($app);
});
$app->bind('trucker.model', function ($app) {
return new Resource\Model();
});
//Factories
$app->bind('trucker.conditions', function ($app) {
return new Factories\QueryConditionFactory($app);
});
$app->bind('trucker.transporter', function ($app) {
return new Factories\ApiTransporterFactory($app);
});
$app->bind('trucker.order', function ($app) {
return new Factories\QueryResultOrderFactory($app);
});
$app->bind('trucker.interpreter', function ($app) {
return new Factories\ResponseInterpreterFactory($app);
});
$app->bind('trucker.error-handler', function ($app) {
return new Factories\ErrorHandlerFactory($app);
});
$app->bind('trucker.request-factory', function ($app) {
return new Factories\RequestFactory($app);
});
$app->bind('trucker.auth', function ($app) {
return new Factories\AuthFactory($app);
});
return $app;
}
/**
* Register a shared binding in the container.
*
* @param string|array $abstract
* @param \Closure|string|null $concrete
*/
public function singleton($abstract, $concrete = null)
{
$this->container->singleton($abstract, $concrete);
}
