mirror of
https://github.com/material-components/material-components-ios.git
synced 2026-01-09 07:11:20 +08:00
113 lines
3.2 KiB
Python
Executable File
113 lines
3.2 KiB
Python
Executable File
#!/usr/bin/env python
|
|
#
|
|
# Copyright 2016-present the Material Components for iOS authors. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
from __future__ import print_function # Print as function not keyword.
|
|
|
|
import argparse
|
|
import re
|
|
import string
|
|
import sys
|
|
|
|
def create_arg_parser():
|
|
"""Create a command-line argument parser."""
|
|
description='Convert a name between conventions.'
|
|
parser = argparse.ArgumentParser(description=description)
|
|
parser.add_argument('-c', '--check', action='store_true',
|
|
help='exit with a status of 0 if the name matches mode.')
|
|
parser.add_argument('-p', '--print', action='store_true',
|
|
help='print the mode and exit.')
|
|
parser.add_argument('-m', '--mode',
|
|
choices=['camel', 'hyphen', 'period', 'underscore'],
|
|
help=('the mode to convert to: '
|
|
'FooBar, foo-bar, foo.bar, foo_bar'))
|
|
parser.add_argument('name', help='the name to convert (in any mode)')
|
|
return parser
|
|
|
|
|
|
def detect_mode(name):
|
|
"""Detect the mode of a name."""
|
|
if '-' in name:
|
|
return 'hyphen'
|
|
elif '.' in name:
|
|
return 'period'
|
|
elif '_' in name:
|
|
return 'underscore'
|
|
else:
|
|
return 'camel'
|
|
|
|
|
|
def split_name(name, mode):
|
|
"""Split a name into its pieces based on mode."""
|
|
if mode == 'hyphen':
|
|
return string.split(name, '-')
|
|
elif mode == 'period':
|
|
return string.split(name, '.')
|
|
elif mode == 'underscore':
|
|
return string.split(name, '_')
|
|
else:
|
|
return camel_split(name)
|
|
|
|
|
|
def camel_split(name):
|
|
"""Split a camel case name into pieces.
|
|
|
|
For example, 'fooBarBazX' should become ['foo', 'Bar', 'Baz, 'X']."""
|
|
pieces = []
|
|
index = 0
|
|
# Find transitions between lowercase and uppercase, or the same and the
|
|
# beginning/end of the string.
|
|
regex = r'([a-z]|\A)([A-Z]+|\Z)'
|
|
for i in re.finditer(regex, name):
|
|
if i.end(1) > 0:
|
|
pieces.append(name[index:i.end(1)])
|
|
index = i.start(2)
|
|
if index < len(name):
|
|
pieces.append(name[index:])
|
|
return pieces
|
|
|
|
|
|
def convert_name_to_mode(name, cur_mode, mode):
|
|
"""Convert a name from cur_mode to mode."""
|
|
pieces = split_name(name, cur_mode)
|
|
if mode == 'hyphen':
|
|
return '-'.join(pieces).lower()
|
|
elif mode == 'period':
|
|
return '.'.join(pieces).lower()
|
|
elif mode == 'underscore':
|
|
return '_'.join(pieces).lower()
|
|
else:
|
|
return ''.join([s.capitalize() for s in pieces])
|
|
|
|
|
|
def main():
|
|
parser = create_arg_parser()
|
|
args = parser.parse_args()
|
|
|
|
cur_mode = detect_mode(args.name)
|
|
exit_status = 0
|
|
if args.print:
|
|
print(cur_mode)
|
|
elif args.check:
|
|
exit_status = 0 if cur_mode == args.mode else 1
|
|
else:
|
|
print(convert_name_to_mode(args.name, cur_mode, args.mode))
|
|
|
|
sys.exit(exit_status)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|