Camelize a string.

@static

@param string $property

@return string
432303
public static function camelize($property)
    {
        $callback = function ($matches) {
            if ($matches[1] === '.') {
                return '_'.strtoupper($matches[2]);
            }

            return strtoupper($matches[2]);
        };

        return ucfirst(preg_replace_callback('/([_\ .])(.)/', $callback, $property));
    }
1357478
protected static function camelizeObject($source)
    {
        $destination = new ArrayObject([], ArrayObject::ARRAY_AS_PROPS);
        foreach ($source as $key => $value) {
            if (ctype_upper($key)) {
                $key = strtolower($key);
            }
            $key = Str::camel($key);
            $destination->$key = is_scalar($value) ? $value : self::camelizeObject($value);
        }
        return $destination;
    }
219444
public static function camelize($word)
    {
        if (preg_match_all('/\/(.?)/', $word, $got)) {
            foreach ($got[1] as $k => $v)
                $got[1][$k] = '::'.strtoupper($v);

            $word = str_replace($got[0], $got[1], $word);
        }
        return str_replace(' ', '', ucwords(preg_replace('/[^A-Z^a-z^0-9^:]+/', ' ', $word)));
    }
451893
function camelize(obj) {
    if (!obj || typeof obj === 'string') return obj
    if (Array.isArray(obj)) return obj.map(camelize)
    if (typeof obj === 'object') {
      return Object.keys(obj).reduce(function(camelizedObj, k) {
        camelizedObj[camel(k)] = camelize(obj[k])
        return camelizedObj
      }, {})
    }
    return obj
  }
1033737
public function &get($property)
    {
        if (!strlen((string)$property)) {
            throw new InvalidArgumentException('Cannot get an empty property');
        }

        $value = null;
        $method = static::_accessor($property, 'get');

        if (isset($this->_properties[$property])) {
            $value =& $this->_properties[$property];
        }

        if ($method) {
            $result = $this->{$method}($value);

            return $result;
        }

        return $value;
    }
299138
public function &__get($property)
    {
        $get[ $property ] = false;

        if (services()->has($property)) {
            $get[ $property ] = services()->get($property);
        }

        return $get[ $property ];
    }
307081
public function translateAndEscapeProperty(AbstractRenderable $element, string $property): string
    {
        return $this->escape($this->translateProperty($element, $property));
    }
1206639
public function setProperty($property)
    {
        if (!$this->fromExpression && !RestParams::hasPrefix($property)) {
            $property = "o.$property";
        }

        $this->property = $property;

        return $this;
    }
255071
public function camelize($base)
    {
        $callback = create_function('$c', 'return strtoupper($c[1]);');

        if (!is_array($base)) {
            return preg_replace_callback('/_([a-z])/', $callback, $base);
        }

        foreach ($base as $key => $val) {
            unset($base[$key]);
            $newKey = preg_replace_callback('/_([a-z])/', $callback, $key);
            $base[$newKey] = $val;
        }

        return $base;
    }
142633
final protected static function get_property_error_message($property) {
        $properties = static::properties_definition();
        if (!isset($properties[$property]['message'])) {
            return new lang_string('invaliddata', 'error');
        }
        return $properties[$property]['message'];
    }
1254383
function Get($key, $property) {
		$key = strtolower($key);
		$property = strtolower($property);

		list($tag, $subtag) = explode(':', $key);
		list($tag, $class) = explode('.', $tag);
		list($tag, $id) = explode('#', $tag);
		$result = '';
		foreach($this->css as $_tag => $value) {
			list($_tag, $_subtag) = explode(':', $_tag);
			list($_tag, $_class) = explode('.', $_tag);
			list($_tag, $_id) = explode('#', $_tag);

			$tagmatch = (strcmp($tag, $_tag) == 0) | (strlen($_tag) == 0);
			$subtagmatch = (strcmp($subtag, $_subtag) == 0) | (strlen($_subtag) == 0);
			$classmatch = (strcmp($class, $_class) == 0) | (strlen($_class) == 0);
			$idmatch = (strcmp($id, $_id) == 0);

			if($tagmatch & $subtagmatch & $classmatch & $idmatch) {
		    	$temp = $_tag;
				if((strlen($temp) > 0) & (strlen($_class) > 0)) {
					$temp .= '.' . $_class;
				} elseif(strlen($temp) == 0) {
					$temp = '.' . $_class;
				}
				if((strlen($temp) > 0) & (strlen($_subtag) > 0)) {
					$temp .= ':' . $_subtag;
				} elseif(strlen($temp) == 0) {
					$temp = ':' . $_subtag;
				}
				if(isset($this->css[$temp][$property])) {
					$result = $this->css[$temp][$property];
				}
			}
		}
		return $result;
	}
1013317
public static function generatePropertyMethod(string $prefix, string $property): string
    {
        return strtolower($prefix).ucfirst(self::normalizeProperty($property));
    }
1076807
public function removeStyle($property)
    {
        // get string or array of style tags added
        $st = $this->template->get('style');

        // if no style, do nothing
        if (!$st) {
            return $this;
        }

        // if only one style, then put it in array
        if (!is_array($st)) {
            $st = array($st);
        }

        // remove all styles and set back the ones which don't match property
        $this->template->del('style');
        foreach ($st as $k => $rule) {
            if (strpos($rule, ';'.$property.':') === false) {
                $this->template->append('style', $rule);
            }
        }

        return $this;
    }
158866
function camelize(str) {
  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, (letter, index) => {
    return index === 0 ? letter.toLowerCase() : letter.toUpperCase()
  }).replace(/[\s\-_]+/g, '')
}
747954
public static function camelize($str)
    {
        if (strpos($str, '_') !== false) {
            if (PHP_VERSION_ID >= 50516) {
                //http://php.net/manual/en/function.ucwords.php
                return str_replace('_', '', ucwords($str, '_'));
            } else {
                $parts = explode('_', $str);
                foreach ($parts as $k => $v) {
                    $parts[$k] = ucfirst($v);
                }

                return implode('', $parts);
            }
        } else {
            return ucfirst($str);
        }
    }
606485
public static function camelize($name)
    {
        if (!isset(self::$camelizeCache[$name])) {
            $camelizedName = ucwords(str_replace('_', ' ', $name));
            $camelizedName = str_replace(' ', '', $camelizedName);

            self::$camelizeCache[$name] = $camelizedName;
            if (!isset(self::$underscoreCache[$camelizedName])) {
                self::$underscoreCache[$camelizedName] = $name;
            }
        }

        return self::$camelizeCache[$name];
    }
482078
public static function camelizeAction($string)
    {
        $string = str_ireplace("-", "_", $string);
        $string = str_ireplace("_", " ", $string);
        $string = str_ireplace(" ", "", lcfirst(ucwords($string)));

        return $string;
    }