PHP str_is函数代码示例

 /**
  * Handle the command.
  *
  * @return array
  */
 public function handle()
 {
     $options = [];
     $group = null;
     foreach (explode("\n", $this->options) as $option) {
         // Find option [groups]
         if (starts_with($option, '[')) {
             $group = trans(substr(trim($option), 1, -1));
             $options[$group] = [];
             continue;
         }
         // Split on the first ":"
         if (str_is('*:*', $option)) {
             $option = explode(':', $option, 2);
         } else {
             $option = [$option, $option];
         }
         $key = ltrim(trim(array_shift($option)));
         $value = ltrim(trim($option ? array_shift($option) : $key));
         if ($group) {
             $options[$group][$key] = $value;
         } else {
             $options[$key] = $value;
         }
     }
     return $options;
 }

 /**
  * Obtain the user information from GitHub.
  *
  * @return Response
  */
 public function login_callback($provider)
 {
     switch (strtolower($provider)) {
         case 'facebook':
         case 'twitter':
             $user_sso = Socialite::driver(strtolower($provider))->user();
             if (str_is(strtolower($provider), 'facebook')) {
                 $result = $this->dispatch(new CreateMemberFromFacebook($user_sso));
             } else {
                 $result = $this->dispatch(new CreateMemberFromTwitter($user_sso));
             }
             if ($result['status'] == 'success') {
                 Auth::login($result['data']['data']);
                 if ($result['data']['data']->is_complete) {
                     if (Session::has('redirect')) {
                         $redirect = Session::get('redirect', route('web.home'));
                         Session::remove('redirect');
                         return redirect()->to($redirect);
                     } else {
                         return redirect()->route('web.home');
                     }
                 } else {
                     return redirect()->route('web.me.profile.complete');
                 }
             } else {
                 return redirect()->route('web.login')->withErrors($result['data']['message']);
             }
             break;
         default:
             App::abort(404);
             break;
     }
 }

 /**
  * Get current state.
  *
  * @return boolean 
  */
 public function is()
 {
     $this->routes = array();
     foreach (func_get_args() as $param) {
         if (!is_array($param)) {
             $this->routes[] = $param;
             continue;
         }
         foreach ($param as $p) {
             $this->routes[] = $p;
         }
     }
     $this->request = Request::path();
     $this->parseRoutes();
     foreach ($this->routes as $route) {
         if (!Request::is($route)) {
             continue;
         }
         foreach ($this->bad_routes as $bad_route) {
             if (str_is($bad_route, $this->request)) {
                 return false;
             }
         }
         return true;
     }
     return false;
 }

 function __construct()
 {
     ////////
     // Me //
     ////////
     $this->me = null;
     ///////////////////
     // Init Template //
     ///////////////////
     $this->version = env('WEB_VERSION', 'default');
     $this->layout = view($this->version . '.templates.html');
     //////////////
     // Init API //
     //////////////
     $this->api_url = $this->layout->api_url = env('API_URL', 'http://capcusapi');
     $this->api = new \GuzzleHttp\Client(['base_url' => $this->api_url]);
     ////////////////
     // Init Alert //
     ////////////////
     foreach (Session::all() as $k => $v) {
         if (str_is('_alert_*', $k)) {
             $this->layout->{$k} = $v;
         }
     }
 }

 function post_login()
 {
     $input = request()->input();
     ///////////////////////
     // Validate remotely //
     ///////////////////////
     $data['email'] = $input['username'];
     $data['password'] = $input['password'];
     $data['grant_type'] = 'password';
     $data['key'] = env('CAPCUS_API_KEY', 'qwerty123');
     $data['secret'] = env('CAPCUS_API_SECRET', 'qwerty123');
     $api_response = json_decode($this->api->post($this->api_url . '/authorized/client', ['form_params' => $data])->getBody());
     //////////////
     // redirect //
     //////////////
     if (str_is('success', $api_response->status)) {
         foreach ($api_response->data->whoami->auths as $key => $value) {
             if (str_is('cms', $value->app)) {
                 Session::put('access_token', $api_response->data->access_token);
                 Session::put('refresh_token', $api_response->data->refresh_token);
                 Session::put('expired_at', $api_response->data->expired_at);
                 Session::put('me', $api_response->data->whoami);
                 Session::put('auth_cms', $value->roles);
                 return redirect()->intended(route('dashboard'));
             }
         }
     }
     return redirect()->back()->withErrors(new MessageBag(['auth' => "Unauthorized Access"]));
 }

 /**
  * Dynamically access the user's attributes.
  *
  * @param  string  $key
  * @return mixed
  */
 public function __get($key)
 {
     if (str_is($key, 'id')) {
         return (string) $this->attributes['_id'];
     }
     return $this->attributes[$key];
 }

 /**
  * Detect the application's current environment.
  *
  * @param  array|string $environments
  *
  * @return string
  */
 public function detectEnvironment($environments)
 {
     $args = isset($_SERVER['argv']) ? $_SERVER['argv'] : null;
     if (php_sapi_name() == 'cli' && !is_null($value = $this->getEnvironmentArgument($args))) {
         //running in console and env param is set
         return $this['env'] = head(array_slice(explode('=', $value), 1));
     } else {
         //running as the web app
         if ($environments instanceof Closure) {
             // If the given environment is just a Closure, we will defer the environment check
             // to the Closure the developer has provided, which allows them to totally swap
             // the webs environment detection logic with their own custom Closure's code.
             return $this['env'] = call_user_func($environments);
         } elseif (is_array($environments)) {
             foreach ($environments as $environment => $hosts) {
                 // To determine the current environment, we'll simply iterate through the possible
                 // environments and look for the host that matches the host for this request we
                 // are currently processing here, then return back these environment's names.
                 foreach ((array) $hosts as $host) {
                     if (str_is($host, gethostname())) {
                         return $this['env'] = $environment;
                     }
                 }
             }
         } elseif (is_string($environments)) {
             return $this['env'] = $environments;
         }
     }
     return $this['env'] = 'production';
 }

 public function updated($model)
 {
     if (!str_is($model->{$model->getPathField()}, $model->getOriginal($model->getPathField()))) {
         foreach ($model->children as $x) {
             $x->save();
         }
     }
 }

 public function __call($method, $parameters)
 {
     if (str_is('show*', $method)) {
         $alias = mb_strtolower(substr($method, 4));
         return $this->pageCreateView($this->context, $alias);
     }
     throw new BadMethodCallException("Method [{$method}] does not exist.");
 }

 public function testStrIs()
 {
     $this->assertTrue(str_is('*.dev', 'localhost.dev'));
     $this->assertTrue(str_is('a', 'a'));
     $this->assertTrue(str_is('*dev*', 'localhost.dev'));
     $this->assertFalse(str_is('*something', 'foobar'));
     $this->assertFalse(str_is('foo', 'bar'));
 }

 public function allowRules($rule)
 {
     $allow = array_first($this->getRules(), function ($index, $instance) use($rule) {
         if (str_is($instance, $rule)) {
             return true;
         }
     });
     return $allow !== null;
 }

 /**
  * @param $incoming
  * @param $target
  * @return bool
  */
 protected function checkPattern($incoming, $target)
 {
     if ($this->{$target} !== '*') {
         if (!str_is($this->{$target}, $incoming) && !str_is($incoming, $this->{$target})) {
             return false;
         }
     }
     return true;
 }

 /**
  * Determine whether the given item is currently active.
  * @param  array   $item
  * @param  string  $url
  * @return bool
  */
 protected function isActiveItem(array $item, $url)
 {
     foreach ($item['active'] as $active) {
         if (str_is($active, $url)) {
             return true;
         }
     }
     return false;
 }

 /**
  * Normalize button input.
  *
  * @param TreeBuilder $builder
  */
 public function normalize(TreeBuilder $builder)
 {
     $buttons = $builder->getButtons();
     foreach ($buttons as $key => &$button) {
         /*
          * If the button is a string then use
          * it as the button parameter.
          */
         if (is_string($button)) {
             $button = ['button' => $button];
         }
         /*
          * If the key is a string and the button
          * is an array without a button param then
          * move the key into the button as that param.
          */
         if (!is_integer($key) && !isset($button['button'])) {
             $button['button'] = $key;
         }
         /*
          * Make sure some default parameters exist.
          */
         $button['attributes'] = array_get($button, 'attributes', []);
         /*
          * Move the HREF if any to the attributes.
          */
         if (isset($button['href'])) {
             array_set($button['attributes'], 'href', array_pull($button, 'href'));
         }
         /*
          * Move the target if any to the attributes.
          */
         if (isset($button['target'])) {
             array_set($button['attributes'], 'target', array_pull($button, 'target'));
         }
         /*
          * Move all data-* keys
          * to attributes.
          */
         foreach ($button as $attribute => $value) {
             if (str_is('data-*', $attribute)) {
                 array_set($button, 'attributes.' . $attribute, array_pull($button, $attribute));
             }
         }
         /*
          * Make sure the HREF is absolute.
          */
         if (isset($button['attributes']['href']) && is_string($button['attributes']['href']) && !starts_with($button['attributes']['href'], 'http')) {
             $button['attributes']['href'] = url($button['attributes']['href']);
         }
         /*
          * Use small buttons for trees.
          */
         $button['size'] = array_get($button, 'size', 'xs');
     }
     $builder->setButtons($buttons);
 }

 function getImageGalleryAttribute()
 {
     foreach ($this->images as $image) {
         if (str_is('gallery*', strtolower($image->name))) {
             $galleries[] = $image;
         }
     }
     return $galleries;
 }