Comments out a group/class related spec.

@param  string  $message Description message.
@param  Closure $closure A test case closure.

@return
555709
public function xdescribe($message, $closure, $timeout = null)
    {
        return $this->_block->describe($message, $closure, $timeout, 'exclude');
    }
491612
public function resolveClosure(Closure $closure, array $args = [])
    {
        $closureRef = new ReflectionFunction($closure);
        $dependencies = $this->getMethodDependencies($closureRef, $args);

        return $closureRef->invokeArgs($dependencies);
    }
1131745
public function group(Closure $closure): self
    {
        $expression = new Expression();
        $closure($expression);
        return $this->addExpression('group', $expression);
    }
741782
public function resolveClosure(\Closure $closure)
    {
        $reflection = new \ReflectionFunction($closure);

        $dependencies = $reflection->getParameters();
        $instances = $this->resolveDependencies($dependencies); // Actually resolve the dependencies
        $o = $reflection->invokeArgs($instances);

        return $o;
    }
533630
public function protect(\Closure $closure)
    {
        try {
            $result = null;
            $circuitOpenException = null;

            if ($this->isClosed($this->circuit) || $this->isHalfOpen($this->circuit)) {
                $result = $closure();
                $this->success($this->circuit);
            } elseif ($this->isOpen($this->circuit)) {
                $circuitOpenException = new CircuitOpenException();
            }
        } catch (\Exception $e) {
            if (!in_array(get_class($e), $this->config['allowed_exceptions'])) {
                $this->failure($this->circuit);
            }

            if (!$this->config['ignore_exceptions']) {
                if (!in_array(get_class($e), $this->config['exclude_exceptions'])) {
                    $result = $e;
                }
            }
        }

        // Throw circuit exception when it is opened
        if (null !== $circuitOpenException) {
            throw $circuitOpenException;
        }

        //Throw closure exception
        if ($result instanceof \Exception) {
            throw $result;
        }

        return $result;
    }
204081
public static function group(string $prefix, Closure $closure, $middleware = [])
    {
        $prefix = trim($prefix, self::SEPARATOR);

        //Prepend prefixes
        if ($prefix) {
            self::$prefixGroupStack[] = $prefix;
        }

        //Add group middleware
        if ($middleware) {
            self::$middlewareGroupStack[] = $middleware;
        }

        //Call group closure
        $closure();

        //Remove prefix
        if ($prefix) {
            array_pop(self::$prefixGroupStack);
        }

        //Remove current group middleware from the list
        if ($middleware) {
            array_pop(self::$middlewareGroupStack);
        }
    }
908108
public function where($label, \Closure $builder)
    {
        $this->input = $this->value;

        $condition = [$builder->bindTo($this)];

        return $this->joinGroup($label, $condition);
    }
387080
protected function cacheResults($class, $method, $key, $closure)
    {
        $key = $class.'@'.$method.'.'.$key;

        if (method_exists(app()->make('cache')->getStore(), 'tags')) {
            return app()->make('cache')->tags($this->tag)->remember($key, 60, $closure);
        }

        return call_user_func($closure);
    }
162006
public function group(string $groupName, \Closure $callback) {
        $this->currentGroupName = $groupName;

        $this->isGroupe = TRUE;
        $this->isGroupeMiddlewares = FALSE;
        $callback($this);
        $this->isGroupeMiddlewares = TRUE;
        $this->currentGroupName = NULL;

        return $this;
    }
1313099
public function addClosure(string $key, Closure $closure): ClosureResolver
    {
        $this->closures[$key] = $closure;

        return $this;
    }
948051
public static function group(array $attributes, Closure $closure)
    {
        $hash = uniqid('prop_');
        //Add options
        if (isset($attributes['prefix'])) {
            static::$groupsProps['prefix'][$hash] = $attributes['prefix'];
        }
        if (isset($attributes['namespace'])) {
            static::$groupsProps['namespace'][$hash] = $attributes['namespace'];
        }
        if (isset($attributes['name'])) {
            static::$groupsProps['name'][$hash] = $attributes['name'];
        }
        if (isset($attributes['middlewares']) || isset($attributes['middleware'])) {
            static::$groupsProps['middleware'][$hash] = isset($attributes['middleware']) ?
                (array)$attributes['middleware'] :
                (array)$attributes['middlewares'];
        }
        //Run closure
        $closure();
        //Remove options
        unset(static::$groupsProps['prefix'][$hash]);
        unset(static::$groupsProps['namespace'][$hash]);
        unset(static::$groupsProps['name'][$hash]);
        unset(static::$groupsProps['middleware'][$hash]);
    }
150771
public function newNestedInstance(Closure $closure = null)
    {
        $query = $this->newInstance()->nested();

        if ($closure) {
            call_user_func($closure, $query);
        }

        return $query;
    }
959863
public function share(Closure $closure)
    {
        return function($container) use ($closure)
        {
            // We'll simply declare a static variable within the Closures and if it has
            // not been set we will execute the given Closures to resolve this value
            // and return it back to these consumers of the method as an instance.
            static $object;

            if (is_null($object)) {
                $object = $closure($container);
            }

            return $object;
        };
    }
1279441
public function handle(Closure $closure)
    {
        $result = \call_user_func($closure, $this->getMessage(), [$this, 'fail'], [$this, 'alert']);

        $attributes = [
            'result_code' => is_null($this->alert) && is_null($this->fail) ? static::SUCCESS : static::FAIL,
            'err_code_des' => $this->alert,
        ];

        if (is_null($this->alert) && is_string($result)) {
            $attributes += [
                'appid' => $this->app['config']->app_id,
                'mch_id' => $this->app['config']->mch_id,
                'nonce_str' => uniqid(),
                'prepay_id' => $result,
            ];
        }

        return $this->respondWith($attributes, true)->toResponse();
    }
660900
private function generateCallback(Closure $callback): Closure
    {
        return function ($match) use ($callback) {
            if ($match[1] == '[' && $match[6] == ']') {
                return substr($match[0], 1, -1);
            }

            $content = isset($match[5]) ? $match[5] : null;
            $atts = isset($match[3]) ? $this->parseAttributes($match[3]) : [];

            return $callback($match[2], $content, $atts);
        };
    }
958051
public function aggregate(\Closure $closure)
    {
        $builder = new AggregationBuilder($this->query);

        $closure($builder);

        return $this;
    }
297658
public function onText($regexp, \Closure $handler)
    {
        $this->managers[] = new Manager(function (Event $event) use ($regexp) {
            return (
                $event instanceof \Viber\Api\Event\Message
                && $event->getMessage() instanceof \Viber\Api\Message\Text
                && preg_match($regexp, $event->getMessage()->getText())
            );
        }, $handler);

        return $this;
    }