def test_clean_class_set(self): # Covers all invalid cases: first char, allowed chars, last char, and underscores. valid_classes = { 'color-hfff', 'font-color-hsla-120-60p-70p-0_3', 'padding-5_2rem', 'height-24_48p', 'padding-7_3-8_5-9_7-10_2', } invalid_classes = { '', ' ', '*b', 'bg-color__blue', 'height-m_px', 'lighter-1$', 'margin-2_rem', 'padding-@1px-2px-1px-2px', 'width-_2', 'bold-', 'green_', 'font-color-#000', } expected_removed = { ' (May not be None or "".)', ' (Only a-z allowed for first character of class.)', '*b (Only a-z allowed for first character of class.)', 'bg-color__blue (Invalid underscore usage in class.)', 'height-m_px (Invalid underscore usage in class.)', 'lighter-1$ (Only a-z, 0-9, "_", and "-" are allowed in class name.)', 'margin-2_rem (Invalid underscore usage in class.)', 'padding-@1px-2px-1px-2px (Only a-z, 0-9, "_", and "-" are allowed in class name.)', 'width-_2 (Invalid underscore usage in class.)', 'bold- (Only a-z and 0-9 allowed for last character of class.)', 'green_ (Only a-z and 0-9 allowed for last character of class.)', 'font-color-#000 (Only a-z, 0-9, "_", and "-" are allowed in class name.)', } class_parser = ClassPropertyParser(class_set=set()) # Prevents the implicit call in __init__() class_parser.class_set = valid_classes.union(invalid_classes) # Mix valid and invalid classes class_parser.clean_class_set() self.assertEqual(class_parser.class_set, valid_classes) # Only valid classes should remain. self.assertTrue(class_parser.removed_class_set == expected_removed, msg=expected_removed)
def test_get_property_priority_not_important(self): expected_property_priority = '' class_set = {'font-weight-bold', 'font-weight-700', 'bold', 'normal'} class_parser = ClassPropertyParser(class_set=class_set) for css_class in class_parser.class_set: property_priority = class_parser.get_property_priority(css_class=css_class) self.assertEquals(property_priority, expected_property_priority)
def test_underscores_valid_is_false(self): invalid_classes = { '_bold', 'lighter-1_', 'width-_2', 'margin-2_rem', 'height-m_px', 'bg-color__blue', '-_2', '2_rem', 'm_px', '__', '_35', '42_', '-7_2', '5_4-', ' _ ', ' _3_2', '8_9_ ', '6_4 _ ', } class_parser = ClassPropertyParser(class_set=set()) for css_class in invalid_classes: self.assertFalse(class_parser.underscores_valid(css_class=css_class), msg=css_class)
def test_strip_priority_designator(self): important = 'p-10-i' not_important = 'p-10' expected_value = 'p-10' class_parser = ClassPropertyParser(class_set=set()) value = class_parser.strip_priority_designator(css_class=important) # important self.assertEquals(value, expected_value) value = class_parser.strip_priority_designator(css_class=not_important) # not important self.assertEquals(value, expected_value)
def test_get_property_value_invalid_patterns(self): property_name = 'color' encoded_property_values = ['bold-50', '5u5', 'b1-a5-c1p-e5', '5pxrem', '1ap-10xp-3qp-1mp3', 'p12px'] expected_values = ['bold 50', '5u5', 'b1 a5 c1% e5', '5pxrem', '1a% 10x% 3q% 1mp3', 'p12px'] for i, value in enumerate(encoded_property_values): css_class = property_name + '-' + value class_parser = ClassPropertyParser(class_set={css_class}) property_value = class_parser.get_property_value(property_name=property_name, encoded_property_value=value) self.assertEquals(property_value, expected_values[i])
def test_get_property_name_by_alias(self): class_alias_set = {'bold', 'bolder', 'lighter', 'fweight-200', 'f-weight-100', 'fw-bold', 'font-w-900'} expected_property_name = 'font-weight' class_parser = ClassPropertyParser(class_set=set()) class_list = list(class_alias_set) for css_class in class_list: property_name = class_parser.get_property_name(css_class=css_class) self.assertEquals(property_name, expected_property_name, msg=css_class)
def test_get_property_name_non_matching(self): non_matching = ['not-a-property-', 'a-font-not-'] expected_property_name = '' expected_empty_set = set() class_parser = ClassPropertyParser(class_set=set()) for css_class in non_matching: property_name = class_parser.get_property_name(css_class=css_class) self.assertEquals(property_name, expected_property_name) self.assertEquals(class_parser.class_set, expected_empty_set)
def test_get_property_name_by_identical_name_valid(self): valid_identical_set = {'font-weight-bold', 'font-weight-700'} expected_property_name = 'font-weight' class_parser = ClassPropertyParser(class_set=valid_identical_set) class_list = list(class_parser.class_set) for i, css_class in enumerate(class_list): property_name = class_parser.get_property_name(css_class=css_class) self.assertEquals(property_name, expected_property_name)
def test_strip_property_name_not_matching(self): property_name = 'font-weight' encoded_property_value = 'bold' css_class = 'bold' class_parser = ClassPropertyParser(class_set=set()) encoded_property_value = class_parser.strip_property_name( property_name=property_name, css_class=encoded_property_value ) self.assertEquals(encoded_property_value, css_class)
def test_get_property_value_valid_patterns(self): property_name = 'color' encoded_property_values = ['green', 'h0ff48f', 'hfff', 'rgba-255-0-0-0_5', 'hsla-120-60p-70p-0_3'] expected_property_values = ['green', '#0ff48f', '#fff', 'rgba(255, 0, 0, 0.5)', 'hsla(120, 60%, 70%, 0.3)'] for i, value in enumerate(encoded_property_values): css_class = property_name + '-' + value class_parser = ClassPropertyParser(class_set={css_class}) property_value = class_parser.get_property_value(property_name=property_name, encoded_property_value=value) self.assertEquals(property_value, expected_property_values[i]) self.assertEquals(class_parser.class_set, {css_class})
def test_strip_property_abbreviation_not_matching(self): property_name = 'font-weight' css_class = 'bold' expected_encoded_property_value = 'bold' class_parser = ClassPropertyParser(class_set=set()) css_class = class_parser.strip_property_abbreviation( property_name=property_name, css_class=css_class ) self.assertEquals(css_class, expected_encoded_property_value)
def test_alias_is_abbreviation(self): expected_true = ['fw-', 'p-', 'h-', 'w-'] expected_false = ['fw', 'p', 'height', 'width'] class_parser = ClassPropertyParser(class_set=set()) for _true in expected_true: self.assertTrue(class_parser.alias_is_abbreviation(_true), msg=_true) for _false in expected_false: self.assertFalse(class_parser.alias_is_abbreviation(_false), msg=_false)
def test_get_property_name_by_identical_name_invalid(self): invalid_identical_set = [ 'font-weight', 'font-weight-', 'afont-weight-', '-font-weight', 'font%weight', 'fw-', '700' ] expected_property_name = '' expected_empty_set = set() class_parser = ClassPropertyParser(class_set=set()) for css_class in invalid_identical_set: property_name = class_parser.get_property_name(css_class=css_class) self.assertEquals(property_name, expected_property_name) self.assertEquals(class_parser.class_set, expected_empty_set, msg=class_parser.class_set)
def test_get_encoded_property_value(self): # 'fw-bold-i' --> 'bold' [abbreviated font-weight property_name] # 'padding-1-10-10-5-i' --> '1-10-10-5' [standard property_name] # 'height-7_25rem-i' --> '7_25rem' [contains underscores] property_names = ['font-weight', 'padding', 'height'] css_classes = ['fw-bold-i', 'padding-1-10-10-5-i', 'height-7_25rem-i'] expected_encoded_property_values = ['bold', '1-10-10-5', '7_25rem'] class_parser = ClassPropertyParser(class_set=set()) for i, css_class in enumerate(css_classes): encoded_property_value = class_parser.get_encoded_property_value( property_name=property_names[i], css_class=css_class ) self.assertEquals(encoded_property_value, expected_encoded_property_values[i], msg=property_names)
def get_file_data_from_content(src_file_name, src_file_content): """Use this to gather data for file, given its content. Will raise a jsparser.ParsingError if the syntax is incorrect""" visitor_handler = JSFileVisitorHandler(src_file_content) line_parser = LineParser() visitor_handler.add_visitor(line_parser) function_parser = FunctionParser() visitor_handler.add_visitor(function_parser) variable_parser = VariableParser() visitor_handler.add_visitor(variable_parser) class_property_parser = ClassPropertyParser() visitor_handler.add_visitor(class_property_parser) visitor_handler.visit() src_file_functions = function_parser.functions src_file_variables = variable_parser.variables src_file_class_properties = class_property_parser.properties src_file_lines = line_parser.file_lines # Trick to give the right FileLines to each function # The thing is now we only parse lines once, not once for the file and then once per function # So, we have to give the total lines to each function to make it simple for reviewers then to # get lines for a function. # Therefore, the FileLines can accept an "start/stop" argument to know where to look in the lines # FIXME: this shouldn't be handled here though for function in src_file_functions: function.lines = FileLines(src_file_lines.all_lines, function.start_pos, function.end_pos) return FileData(src_file_name, src_file_content, src_file_lines, src_file_functions, src_file_variables, src_file_class_properties)
def test_class_set_to_lowercase(self): original_class_set = {'ThE', 'the', 'THE', 't2HE'} expected_class_set = {'the', 'the', 'the', 't2he'} class_parser = ClassPropertyParser(class_set=original_class_set) class_parser.class_set_to_lowercase() self.assertEquals(class_parser.class_set, expected_class_set)
def test_underscores_valid_is_true(self): valid_classes = {'6_3', 'padding-5_2rem', 'height-24_48p', '1_2-5_75-1_2-5_75', 'n5_25cm', } class_parser = ClassPropertyParser(class_set=valid_classes) for css_class in class_parser.class_set: self.assertTrue(class_parser.underscores_valid(css_class=css_class), msg=css_class)
def test_get_property_abbreviations(self): expected_abbreviations = ['fweight-', 'f-weight-', 'fw-', 'font-w-'] property_name = 'font-weight' class_parser = ClassPropertyParser(class_set=set()) abbreviations = class_parser.get_property_abbreviations(property_name=property_name) self.assertEquals(set(abbreviations), set(expected_abbreviations))
def test_is_important(self): expected_true = 'p-10-i' expected_false = 'height-50' class_parser = ClassPropertyParser(class_set=set()) self.assertTrue(class_parser.is_important(css_class=expected_true)) self.assertFalse(class_parser.is_important(css_class=expected_false))