001    /*
002     * Licensed under the Apache License, Version 2.0 (the "License");
003     * you may not use this file except in compliance with the License.
004     * You may obtain a copy of the License at
005     *
006     * http://www.apache.org/licenses/LICENSE-2.0
007     *
008     * Unless required by applicable law or agreed to in writing, software
009     * distributed under the License is distributed on an "AS IS" BASIS,
010     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
011     * See the License for the specific language governing permissions and
012     * limitations under the License.
013     * 
014     * See the NOTICE file distributed with this work for additional
015     * information regarding copyright ownership.
016     */
017    
018    package com.osbcp.cssparser;
019    
020    import java.util.ArrayList;
021    import java.util.Iterator;
022    import java.util.List;
023    
024    /**
025     * Represents a CSS rule.
026     * 
027     * @author <a href="mailto:christoffer@christoffer.me">Christoffer Pettersson</a>
028     */
029    
030    public final class Rule {
031    
032            private List<Selector> selectors;
033            private List<PropertyValue> propertyValues;
034    
035            /**
036             * Creates a rule with a single selector.
037             * 
038             * @param selector A selector that the rule should initial with.
039             */
040    
041            public Rule(final Selector selector) {
042                    this();
043                    this.selectors.add(selector);
044            }
045    
046            /**
047             * Creates an empty rule.
048             */
049    
050            public Rule() {
051                    this(new ArrayList<Selector>());
052            }
053    
054            /**
055             * Creates a new rule based on a list of selectors.
056             * 
057             * @param selectors A list of selectors that the rule should initial with.
058             */
059    
060            public Rule(final List<Selector> selectors) {
061                    this.selectors = selectors;
062                    this.propertyValues = new ArrayList<PropertyValue>();
063            }
064    
065            @Override
066            public String toString() {
067    
068                    StringBuilder out = new StringBuilder();
069    
070                    //                      for (String selectorString : selectors) {
071                    //
072                    //                              out.append(selectorString + ",");
073                    //              out.append(implode(selectors) + " {\n");
074                    //
075                    //                      }
076    
077                    out.append(implode(selectors) + " {\n");
078                    for (PropertyValue propertyValue : propertyValues) {
079                            out.append("\t" + propertyValue + ";\n");
080                    }
081                    out.append("}\n");
082    
083                    return out.toString();
084            }
085    
086            /**
087             * Adds a property value to the rule.
088             * 
089             * @param propertyValue The property value that should be attached.
090             */
091    
092            public void addPropertyValue(final PropertyValue propertyValue) {
093                    propertyValues.add(propertyValue);
094            }
095    
096            /**
097             * Returns a list of all property values attached to the rule.
098             * 
099             * @return A list of all property values attached to the rule.
100             */
101    
102            public List<PropertyValue> getPropertyValues() {
103                    return propertyValues;
104            }
105    
106            /**
107             * Returns a list of all selectors attached to the rule.
108             * 
109             * @return A list of all selectors attached to the rule.
110             */
111    
112            public List<Selector> getSelectors() {
113                    return selectors;
114            }
115    
116            /**
117             * Adds a list of selectors to the existing list of selectors.
118             * 
119             * @param selectors A list of selectors that should be appended.
120             */
121    
122            public void addSelectors(final List<Selector> selectors) {
123                    this.selectors.addAll(selectors);
124            }
125    
126            //
127            //      @Override
128            //      public boolean equals(final Object object) {
129            //
130            //              if (object instanceof Rule) {
131            //
132            //                      Rule target = (Rule) object;
133            //
134            //                      return target.name.equalsIgnoreCase(name);
135            //
136            //              }
137            //
138            //              return false;
139            //
140            //      }
141            //
142            //      @Override
143            //      public int hashCode() {
144            //              return toString().hashCode();
145            //      }
146    
147            /**
148             * Implodes the list of selectors into a pretty String.
149             * 
150             * @param values A list of selectors.
151             * @return A fancy String.
152             */
153    
154            private String implode(final List<Selector> values) {
155    
156                    StringBuilder sb = new StringBuilder();
157    
158                    Iterator<Selector> iterator = values.iterator();
159    
160                    while (iterator.hasNext()) {
161    
162                            Selector selector = iterator.next();
163    
164                            sb.append(selector.toString());
165    
166                            if (iterator.hasNext()) {
167                                    sb.append(", ");
168                            }
169    
170                    }
171    
172                    return sb.toString();
173    
174            }
175    
176            /**
177             * Removes a property value from the rule.
178             * 
179             * @param propertyValue The property value that should be removed.
180             */
181    
182            public void removePropertyValue(final PropertyValue propertyValue) {
183                    propertyValues.remove(propertyValue);
184            }
185    
186            /**
187             * Adds a selector to the rule.
188             * 
189             * @param selector The selector that should be attached to the rule.
190             */
191    
192            public void addSelector(final Selector selector) {
193                    selectors.add(selector);
194            }
195    
196            /**
197             * Removes a selector from the rule.
198             * 
199             * @param selector The selector that should be removed from the rule.
200             */
201    
202            public void removeSelector(final Selector selector) {
203                    selectors.remove(selector);
204            }
205    
206    }