Cocoanetics / DTCoreText / 180 / 1

//  DTCSSStylesheet.m

//  Created by Oliver Drobnik on 9/5/11.

//  Copyright (c) 2011 Drobnik.com. All rights reserved.

//

#import "DTCSSStylesheet.h"

#import "DTCSSListStyle.h"

#import "DTHTMLElement.h"

#import "NSScanner+HTML.h"

#import "NSString+CSS.h"

#import "NSString+HTML.h"

// external symbols generated via custom build rule and xxd

extern unsigned char default_css[];

extern unsigned int default_css_len;

@implementation DTCSSStylesheet

{

        NSMutableDictionary *_styles;

        NSMutableDictionary *_orderedSelectorWeights;

        NSMutableArray *_orderedSelectors;

}

#pragma mark Creating Stylesheets

+ (DTCSSStylesheet *)defaultStyleSheet

{

        static DTCSSStylesheet *defaultDTCSSStylesheet = nil;

        if (defaultDTCSSStylesheet)

        {

                return defaultDTCSSStylesheet;

        }

        @synchronized(self)

        {

                if (!defaultDTCSSStylesheet)

                {

                        // get the data from the external symbol

                        NSData *data = [NSData dataWithBytes:default_css length:default_css_len];

                        NSString *cssString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];

                        defaultDTCSSStylesheet = [[DTCSSStylesheet alloc] initWithStyleBlock:cssString];

                }

        }

        return defaultDTCSSStylesheet;

}

- (id)initWithStyleBlock:(NSString *)css

{

        self = [super init];

        if (self)

        {

                _styles        = [[NSMutableDictionary alloc] init];

                _orderedSelectorWeights = [[NSMutableDictionary alloc] init];

                _orderedSelectors = [[NSMutableArray alloc] init];

                [self parseStyleBlock:css];

        }

        return self;

}

- (id)initWithStylesheet:(DTCSSStylesheet *)stylesheet

{

        self = [super init];

        if (self)

        {

                _styles        = [[NSMutableDictionary alloc] init];

                _orderedSelectorWeights = [[NSMutableDictionary alloc] init];

                _orderedSelectors = [[NSMutableArray alloc] init];

                [self mergeStylesheet:stylesheet];

        }

        return self;

}

- (NSString *)description

{

        return [_styles description];

}

#pragma mark Working with Style Blocks

- (void)_uncompressShorthands:(NSMutableDictionary *)styles

{

        // list-style shorthand

        NSString *shortHand = [[styles objectForKey:@"list-style"] lowercaseString];

        if (shortHand)

        {

                [styles removeObjectForKey:@"list-style"];

                if ([shortHand isEqualToString:@"inherit"])

                {

                        [styles setObject:@"inherit" forKey:@"list-style-type"];

                        [styles setObject:@"inherit" forKey:@"list-style-position"];

                        return;

                }

                NSArray *components = [shortHand componentsSeparatedByCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];

                BOOL typeWasSet = NO;

                BOOL positionWasSet = NO;

                DTCSSListStyleType listStyleType = DTCSSListStyleTypeNone;

                DTCSSListStylePosition listStylePosition = DTCSSListStylePositionInherit;

                for (NSString *oneComponent in components)

                {

                        if ([oneComponent hasPrefix:@"url"])

                        {

                                // list-style-image

                                NSScanner *scanner = [NSScanner scannerWithString:oneComponent];

                                if ([scanner scanCSSURL:NULL])

                                {

                                        [styles setObject:oneComponent forKey:@"list-style-image"];

                                        continue;

                                }

                        }

                        if (!typeWasSet)

                        {

                                // check if valid type

                                listStyleType = [DTCSSListStyle listStyleTypeFromString:oneComponent];

                                if (listStyleType != DTCSSListStyleTypeInvalid)

                                {

                                        [styles setObject:oneComponent forKey:@"list-style-type"];

                                        typeWasSet = YES;

                                        continue;

                                }

                        }

                        if (!positionWasSet)

                        {

                                // check if valid position

                                listStylePosition = [DTCSSListStyle listStylePositionFromString:oneComponent];

                                if (listStylePosition != DTCSSListStylePositionInvalid)

                                {

                                        [styles setObject:oneComponent forKey:@"list-style-position"];

                                        positionWasSet = YES;

                                        continue;

                                }

                        }

                }

        }

        // font shorthand, see http://www.w3.org/TR/CSS21/fonts.html#font-shorthand

        shortHand = [styles objectForKey:@"font"];

        if (shortHand)

        {

                NSString *fontStyle = @"normal";

                NSArray *validFontStyles = [NSArray arrayWithObjects:@"italic", @"oblique", nil];

                NSString *fontVariant = @"normal";

                NSArray *validFontVariants = [NSArray arrayWithObjects:@"small-caps", nil];

                BOOL fontVariantSet = NO;

                NSString *fontWeight = @"normal";

                NSArray *validFontWeights = [NSArray arrayWithObjects:@"bold", @"bolder", @"lighter", @"100", @"200", @"300", @"400", @"500", @"600", @"700", @"800", @"900", nil];

                BOOL fontWeightSet = NO;

                NSString *fontSize = @"normal";

                NSArray *validFontSizes = [NSArray arrayWithObjects:@"xx-small", @"x-small", @"small", @"medium", @"large", @"x-large", @"xx-large", @"larger", @"smaller", nil];

                BOOL fontSizeSet = NO;

                NSArray *suffixesToIgnore = [NSArray arrayWithObjects:@"caption", @"icon", @"menu", @"message-box", @"small-caption", @"status-bar", @"inherit", nil];

                NSString *lineHeight = @"normal";

                NSMutableString *fontFamily = [NSMutableString string];

                NSArray *components = [shortHand componentsSeparatedByCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];

                for (NSString *oneComponent in components)

                {

                        // try font size keywords

                        if ([validFontSizes containsObject:oneComponent])

                        {

                                fontSize = oneComponent;

                                fontSizeSet = YES;

                                continue;

                        }

                        NSInteger slashIndex = [oneComponent rangeOfString:@"/"].location;

                        if (slashIndex != NSNotFound)

                        {

                                // font-size / line-height

                                fontSize = [oneComponent substringToIndex:slashIndex-1];

                                fontSizeSet = YES;

                                lineHeight = [oneComponent substringFromIndex:slashIndex+1];

                                continue;

                        }

                        else

                        {

                                // length

                                if ([oneComponent hasSuffix:@"%"] || [oneComponent hasSuffix:@"em"] || [oneComponent hasSuffix:@"px"] || [oneComponent hasSuffix:@"pt"])

                                {

                                        fontSize = oneComponent;

                                        fontSizeSet = YES;

                                        continue;

                                }

                        }

                        if (fontSizeSet)

                        {

                                if ([suffixesToIgnore containsObject:oneComponent])

                                {

                                        break;

                                }

                                // assume that this is part of font family

                                if ([fontFamily length])

                                {

                                        [fontFamily appendString:@" "];

                                }

                                [fontFamily appendString:oneComponent];

                        }

                        else

                        {

                                if (!fontWeightSet && [validFontStyles containsObject:oneComponent])

                                {

                                        fontStyle = oneComponent;

                                }

                                else if (!fontVariantSet && [validFontVariants containsObject:oneComponent])

                                {

                                        fontVariant = oneComponent;

                                        fontVariantSet = YES;

                                }

                                else if (!fontWeightSet && [validFontWeights containsObject:oneComponent])

                                {

                                        fontWeight = oneComponent;

                                        fontWeightSet = YES;

                                }

                        }

                }

                [styles removeObjectForKey:@"font"];

                // size and family are mandatory, without them this is invalid

                if ([fontSize length] && [fontFamily length])

                {

                        [styles setObject:fontStyle forKey:@"font-style"];

                        [styles setObject:fontWeight forKey:@"font-weight"];

                        [styles setObject:fontVariant forKey:@"font-variant"];

                        [styles setObject:fontSize forKey:@"font-size"];

                        [styles setObject:lineHeight forKey:@"line-height"];

                        [styles setObject:fontFamily forKey:@"font-family"];

                }

        }

        shortHand = [styles objectForKey:@"margin"];

        if (shortHand)

        {

                NSArray *parts = [shortHand componentsSeparatedByString:@" "];

                NSString *topMargin;

                NSString *rightMargin;

                NSString *bottomMargin;

                NSString *leftMargin;

                if ([parts count] == 4)

                {

                        topMargin = [parts objectAtIndex:0];

                        rightMargin = [parts objectAtIndex:1];

                        bottomMargin = [parts objectAtIndex:2];

                        leftMargin = [parts objectAtIndex:3];

                }

                else if ([parts count] == 3)

                {

                        topMargin = [parts objectAtIndex:0];

                        rightMargin = [parts objectAtIndex:1];

                        bottomMargin = [parts objectAtIndex:2];

                        leftMargin = [parts objectAtIndex:1];

                }

                else if ([parts count] == 2)

                {

                        topMargin = [parts objectAtIndex:0];

                        rightMargin = [parts objectAtIndex:1];

                        bottomMargin = [parts objectAtIndex:0];

                        leftMargin = [parts objectAtIndex:1];

                }

                else

                {

                        NSString *onlyValue = [parts objectAtIndex:0];

                        topMargin = onlyValue;

                        rightMargin = onlyValue;

                        bottomMargin = onlyValue;

                        leftMargin = onlyValue;

                }

                // only apply the ones where there is no previous direct setting

                if (![styles objectForKey:@"margin-top"])

                {

                        [styles setObject:topMargin forKey:@"margin-top"];

                }

                if (![styles objectForKey:@"margin-right"])

                {

                        [styles setObject:rightMargin forKey:@"margin-right"];

                }

                if (![styles objectForKey:@"margin-bottom"])

                {

                        [styles setObject:bottomMargin forKey:@"margin-bottom"];

                }

                if (![styles objectForKey:@"margin-left"])

                {

                        [styles setObject:leftMargin forKey:@"margin-left"];

                }

                // remove the shorthand

                [styles removeObjectForKey:@"margin"];

        }

        shortHand = [styles objectForKey:@"padding"];

        if (shortHand)

        {

                NSArray *parts = [shortHand componentsSeparatedByString:@" "];

                NSString *topPadding;

                NSString *rightPadding;

                NSString *bottomPadding;

                NSString *leftPadding;

                if ([parts count] == 4)

                {

                        topPadding = [parts objectAtIndex:0];

                        rightPadding = [parts objectAtIndex:1];

                        bottomPadding = [parts objectAtIndex:2];

                        leftPadding = [parts objectAtIndex:3];

                }

                else if ([parts count] == 3)

                {

                        topPadding = [parts objectAtIndex:0];

                        rightPadding = [parts objectAtIndex:1];

                        bottomPadding = [parts objectAtIndex:2];

                        leftPadding = [parts objectAtIndex:1];

                }

                else if ([parts count] == 2)

                {

                        topPadding = [parts objectAtIndex:0];

                        rightPadding = [parts objectAtIndex:1];

                        bottomPadding = [parts objectAtIndex:0];

                        leftPadding = [parts objectAtIndex:1];

                }

                else

                {

                        NSString *onlyValue = [parts objectAtIndex:0];

                        topPadding = onlyValue;

                        rightPadding = onlyValue;

                        bottomPadding = onlyValue;

                        leftPadding = onlyValue;

                }

                // only apply the ones where there is no previous direct setting

                if (![styles objectForKey:@"padding-top"])

                {

                        [styles setObject:topPadding forKey:@"padding-top"];

                }

                if (![styles objectForKey:@"padding-right"])

                {

                        [styles setObject:rightPadding forKey:@"padding-right"];

                }

                if (![styles objectForKey:@"padding-bottom"])

                {

                        [styles setObject:bottomPadding forKey:@"padding-bottom"];

                }

                if (![styles objectForKey:@"padding-left"])

                {

                        [styles setObject:leftPadding forKey:@"padding-left"];

                }

                // remove the shorthand

                [styles removeObjectForKey:@"padding"];

        }

}

- (void)_addStyleRule:(NSString *)rule withSelector:(NSString*)selectors

{

        NSArray *split = [selectors componentsSeparatedByString:@","];

        for (NSString *selector in split)

        {

                NSString *cleanSelector = [selector stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];

                NSMutableDictionary *ruleDictionary = [[rule dictionaryOfCSSStyles] mutableCopy];

                // remove !important, we're ignoring these

                for (NSString *oneKey in [ruleDictionary allKeys])

                {

                        id value = [ruleDictionary objectForKey:oneKey];

                        if ([value isKindOfClass:[NSString class]])

                        {

                                NSRange rangeOfImportant = [value rangeOfString:@"!important" options:NSCaseInsensitiveSearch];

                                if (rangeOfImportant.location != NSNotFound)

                                {

                                        value = [value stringByReplacingCharactersInRange:rangeOfImportant withString:@""];

                                        value = [value stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];

                                        [ruleDictionary setObject:value forKey:oneKey];

                                }

                        } else if ([value isKindOfClass:[NSArray class]])

                        {

                                NSMutableArray *newVal;

                                for (NSUInteger i = 0; i < [value count]; ++i)

                                {

                                        NSString *s = [value objectAtIndex:i];

                                        NSRange rangeOfImportant = [s rangeOfString:@"!important" options:NSCaseInsensitiveSearch];

                                        if (rangeOfImportant.location != NSNotFound)

                                        {

                                                s = [s stringByReplacingCharactersInRange:rangeOfImportant withString:@""];

                                                s = [s stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];

                                                if (!newVal)

                                                {

                                                        if ([value isKindOfClass:[NSMutableArray class]])

                                                        {

                                                                newVal = value;

                                                        } else

                                                        {

                                                                newVal = [value mutableCopy];

                                                        }

                                                }

                                                newVal[i] = s;

                                        }

                                }

                                if (newVal)

                                {

                                        [ruleDictionary setObject:newVal forKey:oneKey];

                                }

                        }

                }

                // need to uncompress because otherwise we might get shorthands and non-shorthands together

                [self _uncompressShorthands:ruleDictionary];

                // check if there is a pseudo selector

                NSRange colonRange = [cleanSelector rangeOfString:@":"];

                NSString *pseudoSelector = nil;

                if (colonRange.length==1)

                {

                        pseudoSelector = [cleanSelector substringFromIndex:colonRange.location+1];

                        cleanSelector = [cleanSelector substringToIndex:colonRange.location];

                        // prefix all rules with the pseudo-selector

                        for (NSString *oneRuleKey in [ruleDictionary allKeys])

                        {

                                id value = [ruleDictionary objectForKey:oneRuleKey];

                                // prefix key with the pseudo selector

                                NSString *prefixedKey = [NSString stringWithFormat:@"%@:%@", pseudoSelector, oneRuleKey];

                                [ruleDictionary setObject:value forKey:prefixedKey];

                                [ruleDictionary removeObjectForKey:oneRuleKey];

                        }

                }

                NSDictionary *existingRulesForSelector = [_styles objectForKey:cleanSelector];

                if (existingRulesForSelector)

                {

                        // substitute new rules over old ones

                        NSMutableDictionary *tmpDict = [existingRulesForSelector mutableCopy];

                        // append new rules

                        [tmpDict addEntriesFromDictionary:ruleDictionary];

                        // save it

                        [self _addStyles:tmpDict withSelector:cleanSelector];

                }

                else

                {

                        [self _addStyles:ruleDictionary withSelector:cleanSelector];

                }

        }

}

- (void)parseStyleBlock:(NSString*)css

{

        NSUInteger braceLevel = 0, braceMarker = 0;

        NSString* selector;

        NSUInteger length = [css length];

        for (NSUInteger i = 0; i < length; i++)

        {

                unichar c = [css characterAtIndex:i];

                if (c == '/')

                {

                        i++;

                        if (i < length)

                        {

                                c = [css characterAtIndex:i];

                                if (c == '*')

                                {

                                        // skip comment until closing /

                                        for (; i < length; i++)

                                        {

                                                if ([css characterAtIndex:i] == '/')

                                                {

                                                        break;

                                                }

                                        }

                                        if (i < length)

                                        {

                                                braceMarker = i+1;

                                                continue;

                                        }

                                        else

                                        {

                                                // end of string

                                                return;

                                        }

                                }

                                else

                                {

                                        // not a comment

                                        i--;

                                }

                        }

                }

                // An opening brace! It could be the start of a new rule, or it could be a nested brace.

                if (c == '{')

                {

                        // If we start a new rule...

                        if (braceLevel == 0)

                        {

                                // Grab the selector and clean up extraneous spaces (we'll process it in a moment)

                                selector = [css substringWithRange:NSMakeRange(braceMarker, i-braceMarker)];

                                NSArray *selectorParts = [selector componentsSeparatedByString:@" "];

                                NSMutableArray *cleanSelectorParts = [NSMutableArray array];

                                for (NSString *partialSelector in selectorParts)

                                {

                                        if (partialSelector.length)

                                        {

                                                [cleanSelectorParts addObject:partialSelector];

                                        }

                                }

                                selector = [cleanSelectorParts componentsJoinedByString:@" "];

                                // And mark our position so we can grab the rule's CSS when it is closed

                                braceMarker = i + 1;

                        }

                        // Increase the brace level.

                        braceLevel += 1;

                }

                // A closing brace!

                else if (c == '}')

                {

                        // If we finished a rule...

                        if (braceLevel == 1)

                        {

                                NSString *rule = [css substringWithRange:NSMakeRange(braceMarker, i-braceMarker)];

                                [self _addStyleRule:rule withSelector: selector];

                                braceMarker = i + 1;

                        }

                        braceLevel = MAX(braceLevel-1, 0ul);

                }

        }

}

- (void)mergeStylesheet:(DTCSSStylesheet *)stylesheet

{

        NSArray *otherStylesheetStyleKeys = stylesheet.orderedSelectors;

        for (NSString *oneKey in otherStylesheetStyleKeys)

        {

                NSDictionary *existingStyles = [_styles objectForKey:oneKey];

                NSDictionary *stylesToMerge = [[stylesheet styles] objectForKey:oneKey];

                if (existingStyles)

                {

                        NSMutableDictionary *mutableStyles = [existingStyles mutableCopy];

                        for (NSString *oneStyleKey in stylesToMerge)

                        {

                                NSString *mergingStyleString = [stylesToMerge objectForKey:oneStyleKey];

                                [mutableStyles setObject:mergingStyleString forKey:oneStyleKey];

                        }

                        [self _addStyles:mutableStyles withSelector:oneKey];

                }

                else

                {

                        // nothing to worry

                        [self _addStyles:stylesToMerge withSelector:oneKey];

                }

        }

}

- (void)_addStyles:(NSDictionary *)styles withSelector:(NSString *)selector {

        [_styles setObject:styles forKey:selector];

        if (![_orderedSelectors containsObject:selector])

        {

                [_orderedSelectors addObject:selector];

                _orderedSelectorWeights[selector] = @([self weightForSelector:selector]);

        }

}

#pragma mark Accessing Style Information

- (NSDictionary *)mergedStyleDictionaryForElement:(DTHTMLElement *)element matchedSelectors:(NSSet **)matchedSelectors

{

        // We are going to combine all the relevant styles for this tag.

        // (Note that when styles are applied, the later styles take precedence,

        //  so the order in which we grab them matters!)

        NSLog(@"%@", element);

        NSMutableDictionary *tmpDict = [NSMutableDictionary dictionary];

        // Get based on element

        NSDictionary *byTagName = [self.styles objectForKey:element.name];

        if (byTagName)

        {

                [tmpDict addEntriesFromDictionary:byTagName];

        }

    // Get based on class(es)

        NSString *classString = [element.attributes objectForKey:@"class"];

        NSArray *classes = [classString componentsSeparatedByString:@" "];

        // Cascaded selectors with more than one part are sorted by specificity

        NSMutableArray *matchingCascadingSelectors = [self matchingComplexCascadingSelectorsForElement:element];

        [matchingCascadingSelectors sortUsingComparator:^NSComparisonResult(NSString *selector1, NSString *selector2)

         {

                 NSInteger weightForSelector1 = [_orderedSelectorWeights[selector1] integerValue];

                 NSInteger weightForSelector2 = [_orderedSelectorWeights[selector2] integerValue];

                 if (weightForSelector1 == weightForSelector2)

                 {

                         weightForSelector1 += [_orderedSelectors indexOfObject:selector1];

                         weightForSelector2 += [_orderedSelectors indexOfObject:selector2];

                 }

                 if (weightForSelector1 > weightForSelector2)

                 {

                         return (NSComparisonResult)NSOrderedDescending;

                 }

                 if (weightForSelector1 < weightForSelector2)

                 {

                         return (NSComparisonResult)NSOrderedAscending;

                 }

                 return (NSComparisonResult)NSOrderedSame;

         }];

        NSMutableSet *tmpMatchedSelectors;

        if (matchedSelectors)

        {

                tmpMatchedSelectors = [NSMutableSet set];

        }

        // Apply complex cascading selectors first, then apply most specific selectors

        for (NSString *cascadingSelector in matchingCascadingSelectors)

        {

                NSDictionary *byCascadingSelector = [_styles objectForKey:cascadingSelector];

                [tmpDict addEntriesFromDictionary:byCascadingSelector];

                [tmpMatchedSelectors addObject:cascadingSelector];

        }

        // Applied the parameter element's classes last

        for (NSString *class in classes)

        {

                NSString *classRule = [NSString stringWithFormat:@".%@", class];

                NSDictionary *byClass = [_styles objectForKey: classRule];

                if (byClass)

                {

                        [tmpDict addEntriesFromDictionary:byClass];

                        [tmpMatchedSelectors addObject:class];

                }

                NSString *classAndTagRule = [NSString stringWithFormat:@"%@.%@", element.name, class];

                NSDictionary *byClassAndName = [_styles objectForKey:classAndTagRule];

                if (byClassAndName)

                {

                        [tmpDict addEntriesFromDictionary:byClassAndName];

                        [tmpMatchedSelectors addObject:classAndTagRule];

                }

        }

        // Get based on id

        NSString *idRule = [NSString stringWithFormat:@"#%@", [element.attributes objectForKey:@"id"]];

        NSDictionary *byID = [_styles objectForKey:idRule];

        if (byID)

        {

                [tmpDict addEntriesFromDictionary:byID];

                [tmpMatchedSelectors addObject:idRule];

        }

        // Get tag's local style attribute

        NSString *styleString = [element.attributes objectForKey:@"style"];

        if ([styleString length])

        {

                NSMutableDictionary *localStyles = [[styleString dictionaryOfCSSStyles] mutableCopy];

                // need to uncompress because otherwise we might get shorthands and non-shorthands together

                [self _uncompressShorthands:localStyles];

                [tmpDict addEntriesFromDictionary:localStyles];

        }

        if ([tmpDict count])

        {

                if (matchedSelectors && [tmpMatchedSelectors count])

                {

                        *matchedSelectors = [tmpMatchedSelectors copy];

                }

                return tmpDict;

        }

        else

        {

                return nil;

        }

}

- (NSDictionary *)styles

{

        return _styles;

}

- (NSArray *)orderedSelectors

{

        return _orderedSelectors;

}

// This looks for cascaded selectors with more than one part to them

- (NSMutableArray *)matchingComplexCascadingSelectorsForElement:(DTHTMLElement *)element

{

        __block NSMutableArray *matchedSelectors = [NSMutableArray array];

        for (NSString *selector in _orderedSelectors)

        {

                NSArray *selectorParts = [selector componentsSeparatedByString:@" "];

                // We only process the selector if our selector has more than 1 part to it (e.g. ".foo" would be skipped and ".foo .bar" would not)

                if (selectorParts.count < 2)

                {

                        continue;

                }

                DTHTMLElement *nextElement = element;

                // Walking up the hierarchy so start at the right side of the selector and work to the left

                // Aside: Manual for loop here is faster than for in with reverseObjectEnumerator

                for (NSUInteger j = selectorParts.count; j-- > 0;)

                {

                        NSString *selectorPart = selectorParts[j];

                        BOOL matched = NO;

                        if (selectorPart.length)

                        {

                                while (nextElement != nil)

                                {

                                        DTHTMLElement *currentElement = nextElement;

                                        //This must be set to advance here, above all of the breaks, so the loop properly advances.

                                        nextElement = currentElement.parentElement;

                                        if ([selectorPart characterAtIndex:0] == '#')

                                        {

                                                // If we're at an id and it doesn't match the current element then the style doesn't apply

                                                NSString *currentElementId = [currentElement.attributes objectForKey:@"id"];

                                                if (currentElementId && [[selectorPart substringFromIndex:1] isEqualToString:currentElementId])

                                                {

                                                        matched = YES;

                                                        break;

                                                }

                                        } else if ([selectorPart characterAtIndex:0] == '.')

                                        {

                                                NSString *currentElementClassesString = [currentElement.attributes objectForKey:@"class"];

                                                NSArray *currentElementClasses = [currentElementClassesString componentsSeparatedByString:@" "];

                                                for (NSString *currentElementClass in currentElementClasses)

                                                {

                                                        if ([currentElementClass isEqualToString:[selectorPart substringFromIndex:1]])

                                                        {

                                                                matched = YES;

                                                                break;

                                                        }

                                                }

                                                if (matched)

                                                {

                                                        break;

                                                }

                                        } else if ([selectorPart isEqualToString:currentElement.name] && (selectorParts.count > 1))

                                        {

                                                // This condition depends on the "if (selectorParts.count < 2)" conditional above. If that's removed, we must make sure selectorParts

                                                // contains > 1 item for this to be matched (we want the element name alone to be matched last).

                                                matched = YES;

                                                break;

                                        }

                                        // break if the right most portion of the selector doesn't match the target element

                                        if (!matched && ([currentElement isEqual:element])) {

                                                break;

                                        }

                                }

                        }

                        if (!matched)

                        {

                                break;

                        }

                        //Only match if we really are on the last part of the selector and all other parts have matched so far

                        if (j == 0)

                        {

                                if (matched && ![matchedSelectors containsObject:selector])

                                {

                                        [matchedSelectors addObject:selector];

                                }

                        }

                }

        }

        return matchedSelectors;

}

// This computes the specificity for a given selector

- (NSUInteger)weightForSelector:(NSString *)selector {

        if ((selector == nil) || (selector.length == 0))

        {

                return 0;

        }

        NSUInteger weight = 0;

        NSArray *selectorParts = [selector componentsSeparatedByString:@" "];

        for (NSString *selectorPart in selectorParts)

        {

                if ([selectorPart characterAtIndex:0] == '#')

                {

                        weight += 100;

                } else if ([selectorPart characterAtIndex:0] == '.')

                {

                        weight += 10;

                } else {

                        weight += 1;

                }

        }

        return weight;

}

#pragma mark NSCopying

- (id)copyWithZone:(NSZone *)zone

{

        DTCSSStylesheet *newStylesheet = [[DTCSSStylesheet allocWithZone:zone] initWithStylesheet:self];

        return newStylesheet;

}

@end