includes/htmlform/fields/HTMLTextField.php

   1 <?php
   2
   3 /**
   4  * <input> field.
   5  *
   6  * Besides the parameters recognized by HTMLFormField, the following are
   7  * recognized:
   8  *   autocomplete - HTML autocomplete value (a boolean for on/off or a string according to
   9  *     https://html.spec.whatwg.org/multipage/forms.html#autofill )
  10  */
  11 class HTMLTextField extends HTMLFormField {
  12         protected $mPlaceholder = '';
  13
  14         /** @var bool HTML autocomplete attribute */
  15         protected $autocomplete;
  16
  17         /**
  18          * @param array $params
  19          *   - type: HTML textfield type
  20          *   - size: field size in characters (defaults to 45)
  21          *   - placeholder/placeholder-message: set HTML placeholder attribute
  22          *   - spellcheck: set HTML spellcheck attribute
  23          *   - persistent: upon unsuccessful requests, retain the value (defaults to true, except
  24          *     for password fields)
  25          */
  26         public function __construct( $params ) {
  27                 if ( isset( $params['autocomplete'] ) && is_bool( $params['autocomplete'] ) ) {
  28                         $params['autocomplete'] = $params['autocomplete'] ? 'on' : 'off';
  29                 }
  30
  31                 parent::__construct( $params );
  32
  33                 if ( isset( $params['placeholder-message'] ) ) {
  34                         $this->mPlaceholder = $this->getMessage( $params['placeholder-message'] )->parse();
  35                 } elseif ( isset( $params['placeholder'] ) ) {
  36                         $this->mPlaceholder = $params['placeholder'];
  37                 }
  38         }
  39
  40         public function getSize() {
  41                 return isset( $this->mParams['size'] ) ? $this->mParams['size'] : 45;
  42         }
  43
  44         public function getSpellCheck() {
  45                 $val = isset( $this->mParams['spellcheck'] ) ? $this->mParams['spellcheck'] : null;
  46                 if ( is_bool( $val ) ) {
  47                         // "spellcheck" attribute literally requires "true" or "false" to work.
  48                         return $val === true ? 'true' : 'false';
  49                 }
  50                 return null;
  51         }
  52
  53         public function isPersistent() {
  54                 if ( isset( $this->mParams['persistent'] ) ) {
  55                         return $this->mParams['persistent'];
  56                 }
  57                 // don't put passwords into the HTML body, they could get cached or otherwise leaked
  58                 return !( isset( $this->mParams['type'] ) && $this->mParams['type'] === 'password' );
  59         }
  60
  61         public function getInputHTML( $value ) {
  62                 if ( !$this->isPersistent() ) {
  63                         $value = '';
  64                 }
  65
  66                 $attribs = [
  67                                 'id' => $this->mID,
  68                                 'name' => $this->mName,
  69                                 'size' => $this->getSize(),
  70                                 'value' => $value,
  71                                 'dir' => $this->mDir,
  72                                 'spellcheck' => $this->getSpellCheck(),
  73                         ] + $this->getTooltipAndAccessKey() + $this->getDataAttribs();
  74
  75                 if ( $this->mClass !== '' ) {
  76                         $attribs['class'] = $this->mClass;
  77                 }
  78                 if ( $this->mPlaceholder !== '' ) {
  79                         $attribs['placeholder'] = $this->mPlaceholder;
  80                 }
  81
  82                 # @todo Enforce pattern, step, required, readonly on the server side as
  83                 # well
  84                 $allowedParams = [
  85                         'type',
  86                         'min',
  87                         'max',
  88                         'pattern',
  89                         'title',
  90                         'step',
  91                         'list',
  92                         'maxlength',
  93                         'tabindex',
  94                         'disabled',
  95                         'required',
  96                         'autofocus',
  97                         'multiple',
  98                         'readonly',
  99                         'autocomplete',
 100                 ];
 101
 102                 $attribs += $this->getAttributes( $allowedParams );
 103
 104                 # Extract 'type'
 105                 $type = $this->getType( $attribs );
 106                 return Html::input( $this->mName, $value, $type, $attribs );
 107         }
 108
 109         protected function getType( &$attribs ) {
 110                 $type = isset( $attribs['type'] ) ? $attribs['type'] : 'text';
 111                 unset( $attribs['type'] );
 112
 113                 # Implement tiny differences between some field variants
 114                 # here, rather than creating a new class for each one which
 115                 # is essentially just a clone of this one.
 116                 if ( isset( $this->mParams['type'] ) ) {
 117                         switch ( $this->mParams['type'] ) {
 118                                 case 'int':
 119                                         $type = 'number';
 120                                         break;
 121                                 case 'float':
 122                                         $type = 'number';
 123                                         $attribs['step'] = 'any';
 124                                         break;
 125                                 # Pass through
 126                                 case 'email':
 127                                 case 'password':
 128                                 case 'file':
 129                                 case 'url':
 130                                         $type = $this->mParams['type'];
 131                                         break;
 132                         }
 133                 }
 134
 135                 return $type;
 136         }
 137
 138         public function getInputOOUI( $value ) {
 139                 if ( !$this->isPersistent() ) {
 140                         $value = '';
 141                 }
 142
 143                 $attribs = $this->getTooltipAndAccessKey();
 144
 145                 if ( $this->mClass !== '' ) {
 146                         $attribs['classes'] = [ $this->mClass ];
 147                 }
 148                 if ( $this->mPlaceholder !== '' ) {
 149                         $attribs['placeholder'] = $this->mPlaceholder;
 150                 }
 151
 152                 # @todo Enforce pattern, step, required, readonly on the server side as
 153                 # well
 154                 $allowedParams = [
 155                         'autofocus',
 156                         'autosize',
 157                         'disabled',
 158                         'flags',
 159                         'indicator',
 160                         'maxlength',
 161                         'readonly',
 162                         'required',
 163                         'tabindex',
 164                         'type',
 165                         'autocomplete',
 166                 ];
 167
 168                 $attribs += OOUI\Element::configFromHtmlAttributes(
 169                         $this->getAttributes( $allowedParams )
 170                 );
 171
 172                 // FIXME T150983 downgrade autocomplete
 173                 if ( isset( $attribs['autocomplete'] ) ) {
 174                         if ( $attribs['autocomplete'] === 'on' ) {
 175                                 $attribs['autocomplete'] = true;
 176                         } elseif ( $attribs['autocomplete'] === 'off' ) {
 177                                 $attribs['autocomplete'] = false;
 178                         } else {
 179                                 unset( $attribs['autocomplete'] );
 180                         }
 181                 }
 182
 183                 $type = $this->getType( $attribs );
 184
 185                 return $this->getInputWidget( [
 186                         'id' => $this->mID,
 187                         'name' => $this->mName,
 188                         'value' => $value,
 189                         'type' => $type,
 190                         'dir' => $this->mDir,
 191                 ] + $attribs );
 192         }
 193
 194         protected function getInputWidget( $params ) {
 195                 return new OOUI\TextInputWidget( $params );
 196         }
 197
 198         /**
 199          * Returns an array of data-* attributes to add to the field.
 200          *
 201          * @return array
 202          */
 203         protected function getDataAttribs() {
 204                 return [];
 205         }
 206 }