Initial add of ClientBundle. Patch by: bobv Review by: jgw, rjrjr, ecc git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@5083 8db76d5a-ed1c-0410-87a9-c151d255dfc7
diff --git a/common.ant.xml b/common.ant.xml index 2e2c78a..8a65f84 100755 --- a/common.ant.xml +++ b/common.ant.xml
@@ -174,6 +174,8 @@ <pathelement location="${gwt.dev.staging.jar}" /> <pathelement location="${gwt.tools.lib}/junit/junit-3.8.1.jar" /> <pathelement location="${gwt.tools.lib}/selenium/selenium-java-client-driver.jar" /> + <pathelement location="${gwt.tools.lib}/w3c/sac/sac-1.3.jar" /> + <pathelement location="${gwt.tools.lib}/w3c/flute/flute-1.3.jar" /> <extraclasspaths /> </classpath>
diff --git a/dev/core/src/com/google/gwt/core/ext/Generator.java b/dev/core/src/com/google/gwt/core/ext/Generator.java index 1e5e470..524dddb 100644 --- a/dev/core/src/com/google/gwt/core/ext/Generator.java +++ b/dev/core/src/com/google/gwt/core/ext/Generator.java
@@ -31,6 +31,7 @@ int extra = 0; for (int in = 0, n = unescaped.length(); in < n; ++in) { switch (unescaped.charAt(in)) { + case '\0': case '\n': case '\r': case '\"': @@ -49,6 +50,10 @@ for (int in = 0, out = 0, n = oldChars.length; in < n; ++in, ++out) { char c = oldChars[in]; switch (c) { + case '\0': + newChars[out++] = '\\'; + c = '0'; + break; case '\n': newChars[out++] = '\\'; c = 'n';
diff --git a/eclipse/user/.classpath b/eclipse/user/.classpath index 60629c2..3f063b0 100644 --- a/eclipse/user/.classpath +++ b/eclipse/user/.classpath
@@ -8,6 +8,8 @@ <classpathentry exported="true" kind="var" path="GWT_TOOLS/lib/junit/junit-3.8.1.jar" sourcepath="/GWT_TOOLS/lib/junit/junit-3.8.1-src.zip"/> <classpathentry exported="true" kind="var" path="GWT_TOOLS/lib/tomcat/servlet-api-2.5.jar"/> <classpathentry kind="var" path="GWT_TOOLS/lib/selenium/selenium-java-client-driver.jar"/> + <classpathentry kind="var" path="GWT_TOOLS/lib/w3c/sac/sac-1.3.jar"/> + <classpathentry kind="var" path="GWT_TOOLS/lib/w3c/flute/flute-1.3.jar"/> <classpathentry combineaccessrules="false" kind="src" path="/gwt-dev-windows"/> <classpathentry kind="output" path="bin"/> </classpath>
diff --git a/user/build.xml b/user/build.xml index 196959a..2ff72cb 100755 --- a/user/build.xml +++ b/user/build.xml
@@ -35,6 +35,8 @@ <pathelement location="${gwt.tools.lib}/junit/junit-3.8.1.jar" /> <pathelement location="${gwt.tools.lib}/jfreechart/jfreechart-1.0.3.jar" /> <pathelement location="${gwt.tools.lib}/selenium/selenium-java-client-driver.jar" /> + <pathelement location="${gwt.tools.lib}/w3c/sac/sac-1.3.jar" /> + <pathelement location="${gwt.tools.lib}/w3c/flute/flute-1.3.jar" /> <pathelement location="${gwt.dev.jar}" /> </classpath> </gwt.javac> @@ -73,6 +75,8 @@ <fileset dir="super" excludes="**/package.html" /> <fileset dir="${javac.out}" /> <zipfileset src="${gwt.tools.lib}/tomcat/servlet-api-2.5.jar" /> + <zipfileset src="${gwt.tools.lib}/w3c/sac/sac-1.3.jar" /> + <zipfileset src="${gwt.tools.lib}/w3c/flute/flute-1.3.jar" /> </gwt.jar> </target>
diff --git a/user/src/com/google/gwt/resources/Resources.gwt.xml b/user/src/com/google/gwt/resources/Resources.gwt.xml new file mode 100644 index 0000000..482d555 --- /dev/null +++ b/user/src/com/google/gwt/resources/Resources.gwt.xml
@@ -0,0 +1,75 @@ +<!-- --> +<!-- Copyright 2008 Google Inc. --> +<!-- Licensed under the Apache License, Version 2.0 (the "License"); you --> +<!-- may not use this file except in compliance with the License. You may --> +<!-- 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. License for the specific language governing permissions and --> +<!-- limitations under the License. --> + +<!-- ClientBundle supports renaming files with strong names at compile time --> +<module> + <!-- Pull in the necessary base support, including user.agent detection --> + <inherits name="com.google.gwt.core.Core" /> + <!-- Used by ExternalTextResource --> + <inherits name="com.google.gwt.http.HTTP" /> + + <!-- This acts as a switch to disable the use of data: URLs --> + <define-property name="ClientBundle.enableInlining" values="true,false" /> + <set-property name="ClientBundle.enableInlining" value="true" /> + + <!-- Specify the default behavior --> + <generate-with + class="com.google.gwt.resources.rebind.context.StaticClientBundleGenerator"> + + <!-- We have to specify on which types to execute the Generator --> + <when-type-assignable + class="com.google.gwt.resources.client.ClientBundle" /> + </generate-with> + + <!-- Last-matches wins, so this will selectively override the previous rule --> + <generate-with + class="com.google.gwt.resources.rebind.context.InlineClientBundleGenerator"> + + <!-- We have a number of conditions that must be satisfied --> + <all> + <!-- Is inlining enabled? --> + <when-property-is name="ClientBundle.enableInlining" value="true" /> + + <!-- Again, it's necessary to specify which types the generator runs on --> + <when-type-assignable + class="com.google.gwt.resources.client.ClientBundle" /> + + <!-- Only some browsers support RFC 2397 data: URLs --> + <any> + <when-property-is name="user.agent" value="safari" /> + <when-property-is name="user.agent" value="opera" /> + <when-property-is name="user.agent" value="gecko" /> + <when-property-is name="user.agent" value="gecko1_8" /> + </any> + </all> + </generate-with> + + <!-- This can be used to disable the use of strongly-named files --> + <set-configuration-property name="ClientBundle.enableRenaming" value="true" /> + + <!-- This allows merging of CSS rules to be disabled. --> + <set-configuration-property name="CssResource.mergeEnabled" value="true" /> + + <!-- This forces all CssResource accessor functions to have the @Strict --> + <!-- annotation. This is intended primarily for application developers and --> + <!-- the library test code. --> + <set-configuration-property name="CssResource.strictAccessors" value="false" /> + + <!-- This allows the developer to use shorter obfuscated class names. --> + <!-- Is is valid to extend this property to use a custom name. --> + <set-configuration-property name="CssResource.obfuscationPrefix" value="default" /> + + <!-- This can be used to make CssResource produce human-readable CSS --> + <set-configuration-property name="CssResource.style" value="obf" /> +</module>
diff --git a/user/src/com/google/gwt/resources/client/ClientBundle.java b/user/src/com/google/gwt/resources/client/ClientBundle.java new file mode 100644 index 0000000..a25cba5 --- /dev/null +++ b/user/src/com/google/gwt/resources/client/ClientBundle.java
@@ -0,0 +1,42 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +import com.google.gwt.resources.ext.ResourceGeneratorType; +import com.google.gwt.resources.rg.BundleResourceGenerator; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +/** + * The use of this interface is similar to that of ImageBundle. Declare + * no-argument functions that return subclasses of {@link ResourcePrototype}, + * which are annotated with {@link ClientBundle.Source} annotations specifying + * the classpath location of the resource to include in the output. At runtime, + * the functions will return an object that can be used to access the data in + * the original resource. + */ +@ResourceGeneratorType(BundleResourceGenerator.class) +public interface ClientBundle { + /** + * Specifies the classpath location of the resource or resources associated + * with the {@link ResourcePrototype}. + */ + @Target(ElementType.METHOD) + public @interface Source { + String[] value(); + } +}
diff --git a/user/src/com/google/gwt/resources/client/ClientBundleWithLookup.java b/user/src/com/google/gwt/resources/client/ClientBundleWithLookup.java new file mode 100644 index 0000000..90a7b6e --- /dev/null +++ b/user/src/com/google/gwt/resources/client/ClientBundleWithLookup.java
@@ -0,0 +1,39 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +/** + * This is an extension of ClientBundle that allows for name-based lookup of + * resources. Note that the use of the methods defined within this interface + * will prevent the compiler from pruning any of the resources declared in the + * ClientBundle. + */ +public interface ClientBundleWithLookup extends ClientBundle { + + /** + * Find a resource by the name of the function in which it is declared. + * + * @param name the name of the desired resource + * @return the resource, or <code>null</code> if no such resource is defined. + */ + ResourcePrototype getResource(String name); + + /** + * A convenience method to iterate over all ResourcePrototypes contained in + * the ClientBundle. + */ + ResourcePrototype[] getResources(); +}
diff --git a/user/src/com/google/gwt/resources/client/CssResource.java b/user/src/com/google/gwt/resources/client/CssResource.java new file mode 100644 index 0000000..a133977 --- /dev/null +++ b/user/src/com/google/gwt/resources/client/CssResource.java
@@ -0,0 +1,254 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +import com.google.gwt.resources.ext.ResourceGeneratorType; +import com.google.gwt.resources.rg.CssResourceGenerator; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +/** + * Aggregates and minifies CSS stylesheets. A CssResource represents a regular + * CSS file with GWT-specific at-rules. + * <p> + * Currently-supported accessor functions: + * + * <ul> + * <li>{@code String someClassName();} will allow the css class + * <code>.someClassName</code> to be obfuscated at runtime. The function will + * return the obfuscated class name.</li> + * <li>{@code <primitive numeric type> someDefName();} will allow access to the + * values defined by {@literal @def} rules within the CSS file. The defined + * value must be a raw number, a CSS length, or a percentage value. + * </ul> + * + * <p> + * Currently-supported rules: + * + * <ul> + * <li>{@code @def NAME replacement-expression; .myClass background: NAME;} + * Define a static constant. The replacement expression may be any CSS that + * would be valid in a property value context. A {@code @def} may refer to + * previously-defined rules, but no forward-references will be honored.</li> + * <li>{@code @eval NAME Java-expression; .myClass background: NAME;} Define a + * constant based on a Java expression.</li> + * <li><code>{@literal @if} [!]property list of values {ruleBlock}</code> Include or + * exclude CSS rules based on the value of a deferred-binding property. Also + * {@code @elif} and {@code @else} follow the same pattern.<br/> + * This might look like {@code @if user.agent ie6 safari ...}.</li> + * <li><code>{@literal @if} (Java-expression) {ruleBlock}</code> Include or exclude + * CSS rules based on a boolean Java expression.</li> + * <li><code>{@literal @noflip} { rules }</code> will suppress the automatic + * right-to-left transformation applied to the CSS when the module is compiled + * for an RTL language.</li> + * <li> + * <code>{@literal @}sprite .any .selector {gwt-image: "imageResourceFunction";}</code> + * . The appearance, size, and height of the sprite will be affected by any + * {@link ImageResource.ImageOptions} annotations present on the related + * {@link ImageResource} accessor function. Additional properties may be + * specified in the rule block.</li> + * <li>{@code @url NAME siblingDataResource; .myClass background: NAME + * repeat-x;} Use a {@link DataResource} to generate a <code>url('...'}</code> value.</li> + * </ul> + * + * <p> + * Currently-supported CSS functions: + * + * <ul> + * <li>{@code literal("expression")} substitutes a property value that does not + * conform to CSS2 parsing rules. The escape sequences {@code \"} and {@code \\} + * will be replaced with {@code "} and {@code \} respectively. + * <li>{@code value("bundleFunction.someFunction[.other[...]]" [, "suffix"])} + * substitute the value of a sequence of named zero-arg function invocations. An + * optional suffix will be appended to the return value of the function. The + * first name is resolved relative to the bundle interface passed to + * {@link com.google.gwt.core.client.GWT#create(Class)}. An example: + * + * <pre> + * .bordersTheSizeOfAnImage { + * border-left: value('leftBorderImageResource.getWidth', 'px') solid blue; + * } + * </pre> + * </li> + * </ul> + * + * @see <a + * href="http://code.google.com/p/google-web-toolkit-incubator/wiki/CssResource" + * >CssResource design doc</a> + */ +@ResourceGeneratorType(CssResourceGenerator.class) +public interface CssResource extends ResourcePrototype { + /** + * The original CSS class name specified in the resource. This allows CSS + * classes that do not correspond to Java identifiers to be mapped onto + * obfuscated class accessors. + * + * <pre> + * .some-non-java-ident { background: blue; } + * + * interface MyCssResource extends CssResource { + * {@literal @}ClassName("some-non-java-ident") + * String classAccessor(); + * } + * </pre> + */ + @Documented + @Target(ElementType.METHOD) + public @interface ClassName { + String value(); + } + + /** + * Makes class selectors from other CssResource types available in the raw + * source of a CssResource. String accessor methods can be referred to using + * the value of the imported type's {@link ImportedWithPrefix} value. + * <p> + * This is an example of creating a descendant selector with two unrelated + * types: + * + * <pre> + *{@literal @ImportedWithPrefix}("some-prefix") + * interface ToImport extends CssResource { + * String widget(); + * } + * + *{@literal @ImportedWithPrefix}("other-import") + * interface OtherImport extends CssResource { + * String widget(); + * } + * + * interface Resources extends ClientBundle { + * {@literal @Import}(value = {ToImport.class, OtherImport.class}) + * {@literal @Source}("my.css") + * CssResource usesImports(); + * } + * + * my.css: + * // Now I can refer to these classes defined elsewhere with no + * // fear of name collisions + * .some-prefix-widget .other-import-widget {...} + * </pre> + * + * If the imported CssResource type is lacking an {@link ImportedWithPrefix} + * annotation, the simple name of the type will be used instead. In the above + * example, without the annotation on <code>ToImport</code>, the class + * selector would have been <code>.ToImport-widget</code>. Notice also that + * both interfaces defined a method called <code>widget()</code>, which would + * prevent meaningful composition of the original interfaces. + * <p> + * It is an error to import multiple classes with the same prefix into one + * CssResource. + */ + @Documented + @Target(ElementType.METHOD) + public @interface Import { + Class<? extends CssResource>[] value(); + } + + /** + * Specifies the string prefix to use when one CssResource is imported into + * the scope of another CssResource. + * + * @see Import + */ + @Documented + @Target(ElementType.TYPE) + public @interface ImportedWithPrefix { + String value(); + } + + /** + * Indicates that the String accessor methods defined in a CssResource will + * return the same values across all implementations of that type. + * <p> + * This is an example of "stateful" class selectors being used: + * + * <pre> + *{@literal @Shared} + * interface FocusCss extends CssResource { + * String focused(); + * String unfocused(); + * } + * + * interface PanelCss extends CssResource, FocusCss { + * String widget(); + * } + * + * interface InputCss extends CssResource, FocusCss { + * String widget(); + * } + * + * input.css: + * *.focused .widget {border: thin solid blue;} + * + * Application.java: + * myPanel.add(myInputWidget); + * myPanel.addStyleName(instanceOfPanelCss.focused()); + * </pre> + * + * Because the <code>FocusCss</code> interface is tagged with {@code @Shared}, + * the <code>focused()</code> method on the instance of <code>PanelCss</code> + * will match the <code>.focused</code> parent selector in + * <code>input.css</code>. + * <p> + * The effect of inheriting an {@code Shared} interface can be replicated by + * use use of the {@link Import} annotation (e.g. {@code .FocusCss-focused + * .widget}), however the use of state-bearing descendant selectors is common + * enough to warrant an easier use-case. + */ + @Documented + @Target(ElementType.TYPE) + public @interface Shared { + } + + /** + * The presence of this annotation on a CssResource accessor method indicates + * that any class selectors that do not correspond with a String accessor + * method in the return type should trigger a compilation error. In the normal + * case, any unobfuscatable class selectors will be emitted as-is. This + * annotation ensures that the resource does not contribute any unobfuscated + * class selectors into the global CSS namespace and is recommended as the + * default for library-provided CssResource instances. + * <p> + * Given these interfaces: + * + * <pre> + * interface MyCss extends CssResource { + * String someClass(); + * } + * + * interface MyBundle extends ClientBundle { + * {@literal @Source("my.css")} + * {@literal @Strict} + * MyCss css(); + * } + * </pre> + * + * the source CSS will fail to compile if it does not contain exactly the one + * class selector defined in the MyCss type. + */ + @Documented + @Target(ElementType.METHOD) + public @interface Strict { + } + + /** + * Provides the contents of the CssResource. + */ + String getText(); +}
diff --git a/user/src/com/google/gwt/resources/client/DataResource.java b/user/src/com/google/gwt/resources/client/DataResource.java new file mode 100644 index 0000000..fd3d2cb --- /dev/null +++ b/user/src/com/google/gwt/resources/client/DataResource.java
@@ -0,0 +1,31 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +import com.google.gwt.resources.ext.ResourceGeneratorType; +import com.google.gwt.resources.rg.DataResourceGenerator; + +/** + * A non-text resource. + */ +@ResourceGeneratorType(DataResourceGenerator.class) +public interface DataResource extends ResourcePrototype { + /** + * Retrieves a URL by which the contents of the resource can be obtained. This + * will be an absolute URL. + */ + String getUrl(); +}
diff --git a/user/src/com/google/gwt/resources/client/ExternalTextResource.java b/user/src/com/google/gwt/resources/client/ExternalTextResource.java new file mode 100644 index 0000000..0e5d4cb --- /dev/null +++ b/user/src/com/google/gwt/resources/client/ExternalTextResource.java
@@ -0,0 +1,30 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +import com.google.gwt.resources.ext.ResourceGeneratorType; +import com.google.gwt.resources.rg.ExternalTextResourceGenerator; + +/** + * Identical to {@link TextResource}, except the contents of the resource are + * not inlined into the compiled output. This is suitable for resources that are + * not required as part of program initialization. + */ +@ResourceGeneratorType(ExternalTextResourceGenerator.class) +public interface ExternalTextResource extends ResourcePrototype { + void getText(ResourceCallback<TextResource> callback) + throws ResourceException; +}
diff --git a/user/src/com/google/gwt/resources/client/GwtCreateResource.java b/user/src/com/google/gwt/resources/client/GwtCreateResource.java new file mode 100644 index 0000000..a13b32a --- /dev/null +++ b/user/src/com/google/gwt/resources/client/GwtCreateResource.java
@@ -0,0 +1,60 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +import com.google.gwt.resources.ext.ResourceGeneratorType; +import com.google.gwt.resources.rg.GwtCreateResourceGenerator; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +/** + * This resource type allows any class that can be instantiated via a call to + * {@link com.google.gwt.core.client.GWT#create(Class)} to be used within an + * ClientBundle. Example uses include the I18N support classes, RPC + * endpoints, or any type that supports default instantiation. If no + * {@link ClassType} annotation is present on the resource accessor method, the + * type parameter <code>T</code> will be used as the class literal passed to + * <code>GWT.create()</code>. + * + * @param <T> The type that should be returned from the + * <code>GWT.create()</code> call + */ +@ResourceGeneratorType(GwtCreateResourceGenerator.class) +public interface GwtCreateResource<T> extends ResourcePrototype { + /** + * This annotation can be applied to the resource getter method in order to + * call <code>GWT.create</code> with a class literal other than that of the + * return type parameterization. This annotation would be used with RPC + * endpoints: + * + * <pre>{@literal @ClassType}(Service.class) + * GwtCreateResource<ServiceAsync> rpc(); + * </pre> + */ + @Documented + @Target(ElementType.METHOD) + public @interface ClassType { + Class<?> value(); + } + + /** + * Invokes <code>GWT.create()</code>. Multiple invocations of this method will + * return different instances of the <code>T</code> type. + */ + T create(); +}
diff --git a/user/src/com/google/gwt/resources/client/ImageResource.java b/user/src/com/google/gwt/resources/client/ImageResource.java new file mode 100644 index 0000000..75c2572 --- /dev/null +++ b/user/src/com/google/gwt/resources/client/ImageResource.java
@@ -0,0 +1,106 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +import com.google.gwt.resources.ext.ResourceGeneratorType; +import com.google.gwt.resources.rg.ImageResourceGenerator; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +/** + * Provides access to image resources at runtime. + */ +@ResourceGeneratorType(ImageResourceGenerator.class) +public interface ImageResource extends ResourcePrototype { + + /** + * Specifies additional options to control how an image is bundled. + */ + @Documented + @Target(ElementType.METHOD) + public @interface ImageOptions { + /** + * This option affects the image bundling optimization to allow the image to + * be used with the {@link CssResource} {@code @sprite} rule where + * repetition of the image is desired. + * + * @see "CssResource documentation" + */ + RepeatStyle repeatStyle() default RepeatStyle.None; + + /** + * If <code>true</code>, the image will be flipped along the y-axis when + * {@link com.google.gwt.i18n.client.LocaleInfo#isRTL()} returns + * <code>true</code>. This is intended to be used by graphics that are + * sensitive to layout direction, such as arrows and disclosure indicators. + */ + boolean flipRtl() default false; + } + + /** + * Indicates that an ImageResource should be bundled in such a way as to + * support horizontal or vertical repetition. + */ + public enum RepeatStyle { + /** + * The image is not intended to be tiled. + */ + None, + + /** + * The image is intended to be tiled horizontally. + */ + Horizontal, + + /** + * The image is intended to be tiled vertically. + */ + Vertical, + + /** + * The image is intended to be tiled both horizontally and vertically. Note + * that this will prevent compositing of the particular image in most cases. + */ + Both + } + + /** + * Returns the height of the image. + */ + int getHeight(); + + /** + * Returns the horizontal position of the image within the composite image. + */ + int getLeft(); + + /** + * Returns the vertical position of the image within the composite image. + */ + int getTop(); + + /** + * Returns the URL for the composite image that contains the ImageResource. + */ + String getURL(); + + /** + * Returns the width of the image. + */ + int getWidth(); +}
diff --git a/user/src/com/google/gwt/resources/client/ResourceCallback.java b/user/src/com/google/gwt/resources/client/ResourceCallback.java new file mode 100644 index 0000000..a08e5fc --- /dev/null +++ b/user/src/com/google/gwt/resources/client/ResourceCallback.java
@@ -0,0 +1,35 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +/** + * A callback interface for asynchronous operations on resources. + * + * @param <R> the type of resource + */ +public interface ResourceCallback<R extends ResourcePrototype> { + /** + * Invoked if the asynchronous operation failed. + * @param e an exception describing the failure + */ + void onError(ResourceException e); + + /** + * Invoked if the asynchronous operation was successfully completed. + * @param resource the resource on which the operation was performed + */ + void onSuccess(R resource); +}
diff --git a/user/src/com/google/gwt/resources/client/ResourceException.java b/user/src/com/google/gwt/resources/client/ResourceException.java new file mode 100644 index 0000000..797632a --- /dev/null +++ b/user/src/com/google/gwt/resources/client/ResourceException.java
@@ -0,0 +1,41 @@ +/* + * Copyright 2007 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +/** + * Associates a {@link ResourcePrototype} with a program error. + */ +public class ResourceException extends Exception { + private final ResourcePrototype resource; + + public ResourceException(ResourcePrototype resource) { + this.resource = resource; + } + + public ResourceException(ResourcePrototype resource, String msg) { + super(msg); + this.resource = resource; + } + + public ResourceException(ResourcePrototype resource, String msg, Throwable t) { + super(msg, t); + this.resource = resource; + } + + public ResourcePrototype getResource() { + return resource; + } +}
diff --git a/user/src/com/google/gwt/resources/client/ResourcePrototype.java b/user/src/com/google/gwt/resources/client/ResourcePrototype.java new file mode 100644 index 0000000..81cc6e4 --- /dev/null +++ b/user/src/com/google/gwt/resources/client/ResourcePrototype.java
@@ -0,0 +1,30 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +/** + * The base interface all bundle resource types must extend. + */ +public interface ResourcePrototype { + /** + * Returns the name of the function within the ClientBundle used to create the + * ResourcePrototype. + * + * @return the name of the function within the ClientBundle used to create the + * ResourcePrototype + */ + String getName(); +}
diff --git a/user/src/com/google/gwt/resources/client/TextResource.java b/user/src/com/google/gwt/resources/client/TextResource.java new file mode 100644 index 0000000..69ee17a --- /dev/null +++ b/user/src/com/google/gwt/resources/client/TextResource.java
@@ -0,0 +1,28 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +import com.google.gwt.resources.ext.ResourceGeneratorType; +import com.google.gwt.resources.rg.TextResourceGenerator; + +/** + * A resource that contains text that should be incorporated into the compiled + * output. + */ +@ResourceGeneratorType(TextResourceGenerator.class) +public interface TextResource extends ResourcePrototype { + String getText(); +}
diff --git a/user/src/com/google/gwt/resources/client/TextResourceCallback.java b/user/src/com/google/gwt/resources/client/TextResourceCallback.java new file mode 100644 index 0000000..beac520 --- /dev/null +++ b/user/src/com/google/gwt/resources/client/TextResourceCallback.java
@@ -0,0 +1,24 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +/** + * A callback used when loading external text resources. + * @deprecated use {@link ResourceCallback} directly + */ +@Deprecated +public interface TextResourceCallback extends ResourceCallback<TextResource> { +}
diff --git a/user/src/com/google/gwt/resources/client/impl/ExternalTextResourcePrototype.java b/user/src/com/google/gwt/resources/client/impl/ExternalTextResourcePrototype.java new file mode 100644 index 0000000..c76ae01 --- /dev/null +++ b/user/src/com/google/gwt/resources/client/impl/ExternalTextResourcePrototype.java
@@ -0,0 +1,156 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client.impl; + +import com.google.gwt.core.client.JavaScriptObject; +import com.google.gwt.http.client.Request; +import com.google.gwt.http.client.RequestBuilder; +import com.google.gwt.http.client.RequestCallback; +import com.google.gwt.http.client.RequestException; +import com.google.gwt.http.client.Response; +import com.google.gwt.resources.client.ExternalTextResource; +import com.google.gwt.resources.client.ResourceCallback; +import com.google.gwt.resources.client.ResourceException; +import com.google.gwt.resources.client.TextResource; + +/** + * Implements external resource fetching of TextResources. + */ +public class ExternalTextResourcePrototype implements ExternalTextResource { + + /** + * Maps the HTTP callback onto the ResourceCallback. + */ + private class ETRCallback implements RequestCallback { + final ResourceCallback<TextResource> callback; + + public ETRCallback(ResourceCallback<TextResource> callback) { + this.callback = callback; + } + + public void onError(Request request, Throwable exception) { + callback.onError(new ResourceException( + ExternalTextResourcePrototype.this, + "Unable to retrieve external resource", exception)); + } + + public void onResponseReceived(Request request, final Response response) { + // Get the contents of the JSON bundle + String responseText = response.getText(); + + // Call eval() on the object. + JavaScriptObject jso = evalObject(responseText); + if (jso == null) { + callback.onError(new ResourceException( + ExternalTextResourcePrototype.this, "eval() returned null")); + return; + } + + // Populate the TextResponse cache array + for (int i = 0; i < cache.length; i++) { + final String resourceText = extractString(jso, i); + cache[i] = new TextResource() { + + public String getName() { + return name; + } + + public String getText() { + return resourceText; + } + + }; + } + + // Finish by invoking the callback + callback.onSuccess(cache[index]); + } + } + + /** + * Evaluate the JSON payload. The regular expression to validate the safety of + * the payload is taken from RFC 4627 (D. Crockford). + * + * @param data the raw JSON-encapsulated string bundle + * @return the evaluated JSON object, or <code>null</code> if there is an + * error. + */ + private static native JavaScriptObject evalObject(String data) /*-{ + var safe = !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test( + data.replace(/"(\\.|[^"\\])*"/g, ''))); + + if (!safe) { + return null; + } + + return eval('(' + data + ')') || null; + }-*/; + + /** + * Extract the specified String from a JavaScriptObject that is array-like. + * + * @param jso the JavaScriptObject returned from {@link #evalObject(String)} + * @param index the index of the string to extract + * @return the requested string, or <code>null</code> if it does not exist. + */ + private static native String extractString(JavaScriptObject jso, int index) /*-{ + return (jso.length > index) && jso[index] || null; + }-*/; + + /** + * This is a reference to an array nominally created in the IRB that contains + * the ExternalTextResource. It is intended to be shared between all instances + * of the ETR that have a common parent IRB. + */ + private final TextResource[] cache; + private final int index; + private final String name; + private final String url; + + public ExternalTextResourcePrototype(String name, String url, + TextResource[] cache, int index) { + this.name = name; + this.url = url; + this.cache = cache; + this.index = index; + } + + public String getName() { + return name; + } + + /** + * Possibly fire off an HTTPRequest for the text resource. + */ + public void getText(ResourceCallback<TextResource> callback) + throws ResourceException { + + // If we've already parsed the JSON bundle, short-circuit. + if (cache[index] != null) { + callback.onSuccess(cache[index]); + return; + } + + // Otherwise, fire an HTTP request. + RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, url); + try { + rb.sendRequest("", new ETRCallback(callback)); + } catch (RequestException e) { + throw new ResourceException(this, + "Unable to initiate request for external resource", e); + } + } +}
diff --git a/user/src/com/google/gwt/resources/client/impl/ImageResourcePrototype.java b/user/src/com/google/gwt/resources/client/impl/ImageResourcePrototype.java new file mode 100644 index 0000000..11bcd64 --- /dev/null +++ b/user/src/com/google/gwt/resources/client/impl/ImageResourcePrototype.java
@@ -0,0 +1,81 @@ +/* + * Copyright 2007 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client.impl; + +import com.google.gwt.resources.client.ImageResource; + +/** + * This is part of an implementation of the ImageBundle optimization implemented + * with ClientBundle. + */ +public class ImageResourcePrototype implements ImageResource { + + private final String name; + private final String url; + private final int left; + private final int top; + private final int width; + private final int height; + + public ImageResourcePrototype(String name, String url, int left, int top, + int width, int height) { + this.name = name; + this.left = left; + this.top = top; + this.height = height; + this.width = width; + this.url = url; + } + + /** + * Exists for testing purposes, not part of the ImageResource interface. + */ + public int getHeight() { + return height; + } + + /** + * Exists for testing purposes, not part of the ImageResource interface. + */ + public int getLeft() { + return left; + } + + public String getName() { + return name; + } + + /** + * Exists for testing purposes, not part of the ImageResource interface. + */ + public int getTop() { + return top; + } + + /** + * Exists for testing purposes, not part of the ImageResource interface. + */ + public String getURL() { + return url; + } + + /** + * Exists for testing purposes, not part of the ImageResource interface. + */ + public int getWidth() { + return width; + } +}
diff --git a/user/src/com/google/gwt/resources/css/CssGenerationVisitor.java b/user/src/com/google/gwt/resources/css/CssGenerationVisitor.java new file mode 100644 index 0000000..7fcfa95 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/CssGenerationVisitor.java
@@ -0,0 +1,296 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css; + +import com.google.gwt.dev.util.TextOutput; +import com.google.gwt.resources.css.ast.Context; +import com.google.gwt.resources.css.ast.CssDef; +import com.google.gwt.resources.css.ast.CssEval; +import com.google.gwt.resources.css.ast.CssIf; +import com.google.gwt.resources.css.ast.CssMediaRule; +import com.google.gwt.resources.css.ast.CssNoFlip; +import com.google.gwt.resources.css.ast.CssNode; +import com.google.gwt.resources.css.ast.CssPageRule; +import com.google.gwt.resources.css.ast.CssProperty; +import com.google.gwt.resources.css.ast.CssRule; +import com.google.gwt.resources.css.ast.CssSelector; +import com.google.gwt.resources.css.ast.CssSprite; +import com.google.gwt.resources.css.ast.CssUrl; +import com.google.gwt.resources.css.ast.CssVisitor; + +import java.util.ArrayList; +import java.util.List; +import java.util.SortedMap; +import java.util.TreeMap; + +/** + * Generates a static CSS template string and provides information on where to + * inject dynamic expressions. + */ +public class CssGenerationVisitor extends CssVisitor { + private final TextOutput out; + + private boolean needsOpenBrace; + + private boolean needsComma; + private final boolean substituteDots; + private final SortedMap<Integer, List<CssNode>> substitutionPositions = new TreeMap<Integer, List<CssNode>>(); + + /** + * Constructor. + * + * @param out the output hondler + */ + public CssGenerationVisitor(TextOutput out) { + this(out, false); + } + + /** + * Constructor for producing an abbreviated form of the template for use with + * {@link CssNode#toString()}. + * + * @param out the output handler + * @param substituteDots if <code>true</code> locations in the text output + * where expression substitutions would normally occur are replaced + * with a textual placeholder + */ + public CssGenerationVisitor(TextOutput out, boolean substituteDots) { + this.out = out; + this.substituteDots = substituteDots; + } + + @Override + public void endVisit(CssIf x, Context ctx) { + // Match up an explanatory comment + out.indentOut(); + out.printOpt("/* } */"); + out.newlineOpt(); + } + + @Override + public void endVisit(CssMediaRule x, Context ctx) { + out.indentOut(); + out.print("}"); + out.newline(); + } + + @Override + public void endVisit(CssNoFlip x, Context ctx) { + out.printOpt("/*} @noflip */"); + out.newlineOpt(); + } + + @Override + public void endVisit(CssPageRule x, Context ctx) { + out.indentOut(); + out.print("}"); + out.newline(); + } + + @Override + public void endVisit(CssRule x, Context ctx) { + if (!x.getProperties().isEmpty()) { + // Don't print empty rule blocks + closeBrace(); + } + } + + public SortedMap<Integer, List<CssNode>> getSubstitutionPositions() { + return substitutionPositions; + } + + @Override + public boolean visit(CssDef x, Context ctx) { + // These are not valid CSS + out.printOpt("/* CssDef */"); + out.newlineOpt(); + return false; + } + + @Override + public boolean visit(CssEval x, Context ctx) { + // These are not valid CSS + out.printOpt("/* CssEval */"); + out.newlineOpt(); + return false; + } + + @Override + public boolean visit(CssIf x, Context ctx) { + // Record where the contents of the if block should be inserted + StringBuilder expr = new StringBuilder("/* @if "); + if (x.getExpression() != null) { + expr.append(x.getExpression()).append(" "); + } else { + expr.append(x.getPropertyName()).append(" "); + for (String v : x.getPropertyValues()) { + expr.append(v).append(" "); + } + } + expr.append("{ */"); + out.printOpt(expr.toString()); + out.newlineOpt(); + out.indentIn(); + addSubstitition(x); + return false; + } + + @Override + public boolean visit(CssMediaRule x, Context ctx) { + out.print("@MEDIA"); + for (String m : x.getMedias()) { + out.print(" " + m); + } + spaceOpt(); + out.print("{"); + out.newlineOpt(); + out.indentIn(); + return true; + } + + @Override + public boolean visit(CssNoFlip x, Context ctx) { + out.printOpt("/*@noflip { */)"); + out.newlineOpt(); + return true; + } + + @Override + public boolean visit(CssPageRule x, Context ctx) { + out.print("@page"); + if (x.getPseudoPage() != null) { + out.print(" :"); + out.print(x.getPseudoPage()); + } + spaceOpt(); + out.print("{"); + out.newlineOpt(); + out.indentIn(); + return true; + } + + @Override + public boolean visit(CssProperty x, Context ctx) { + if (needsOpenBrace) { + openBrace(); + needsOpenBrace = false; + } + + out.print(x.getName()); + colon(); + addSubstitition(x); + + if (x.isImportant()) { + important(); + } + + semi(); + + return true; + } + + @Override + public boolean visit(CssRule x, Context ctx) { + if (x.getProperties().isEmpty()) { + // Don't print empty rule blocks + return false; + } + + needsOpenBrace = true; + needsComma = false; + return true; + } + + @Override + public boolean visit(CssSelector x, Context ctx) { + if (needsComma) { + comma(); + } + needsComma = true; + out.print(x.getSelector()); + return true; + } + + @Override + public boolean visit(CssSprite x, Context ctx) { + // These are not valid CSS + out.printOpt("/* CssSprite */"); + out.newlineOpt(); + addSubstitition(x); + return false; + } + + @Override + public boolean visit(CssUrl x, Context ctx) { + // These are not valid CSS + out.printOpt("/* CssUrl */"); + out.newlineOpt(); + return false; + } + + private void addSubstitition(CssNode node) { + if (substituteDots) { + out.printOpt("....."); + out.newlineOpt(); + } else { + int position = out.toString().length(); + if (substitutionPositions.containsKey(position)) { + substitutionPositions.get(position).add(node); + } else { + List<CssNode> nodes = new ArrayList<CssNode>(); + nodes.add(node); + substitutionPositions.put(position, nodes); + } + } + } + + private void closeBrace() { + out.indentOut(); + out.print('}'); + out.newline(); + } + + private void colon() { + spaceOpt(); + out.print(':'); + spaceOpt(); + } + + private void comma() { + out.print(','); + spaceOpt(); + } + + private void important() { + out.print(" !important"); + } + + private void openBrace() { + spaceOpt(); + out.print('{'); + out.newlineOpt(); + out.indentIn(); + } + + private void semi() { + out.print(';'); + out.newlineOpt(); + } + + private void spaceOpt() { + out.printOpt(' '); + } +}
diff --git a/user/src/com/google/gwt/resources/css/GenerateCssAst.java b/user/src/com/google/gwt/resources/css/GenerateCssAst.java new file mode 100644 index 0000000..c1a9f8a --- /dev/null +++ b/user/src/com/google/gwt/resources/css/GenerateCssAst.java
@@ -0,0 +1,1006 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css; + +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.resources.css.ast.CssDef; +import com.google.gwt.resources.css.ast.CssEval; +import com.google.gwt.resources.css.ast.CssIf; +import com.google.gwt.resources.css.ast.CssMediaRule; +import com.google.gwt.resources.css.ast.CssNoFlip; +import com.google.gwt.resources.css.ast.CssNode; +import com.google.gwt.resources.css.ast.CssPageRule; +import com.google.gwt.resources.css.ast.CssProperty; +import com.google.gwt.resources.css.ast.CssRule; +import com.google.gwt.resources.css.ast.CssSelector; +import com.google.gwt.resources.css.ast.CssSprite; +import com.google.gwt.resources.css.ast.CssStylesheet; +import com.google.gwt.resources.css.ast.CssUrl; +import com.google.gwt.resources.css.ast.HasNodes; +import com.google.gwt.resources.css.ast.HasProperties; +import com.google.gwt.resources.css.ast.CssProperty.DotPathValue; +import com.google.gwt.resources.css.ast.CssProperty.IdentValue; +import com.google.gwt.resources.css.ast.CssProperty.ListValue; +import com.google.gwt.resources.css.ast.CssProperty.NumberValue; +import com.google.gwt.resources.css.ast.CssProperty.StringValue; +import com.google.gwt.resources.css.ast.CssProperty.Value; + +import org.w3c.css.sac.AttributeCondition; +import org.w3c.css.sac.CSSException; +import org.w3c.css.sac.CSSParseException; +import org.w3c.css.sac.CharacterDataSelector; +import org.w3c.css.sac.CombinatorCondition; +import org.w3c.css.sac.Condition; +import org.w3c.css.sac.ConditionalSelector; +import org.w3c.css.sac.ContentCondition; +import org.w3c.css.sac.DescendantSelector; +import org.w3c.css.sac.DocumentHandler; +import org.w3c.css.sac.ElementSelector; +import org.w3c.css.sac.ErrorHandler; +import org.w3c.css.sac.InputSource; +import org.w3c.css.sac.LangCondition; +import org.w3c.css.sac.LexicalUnit; +import org.w3c.css.sac.NegativeCondition; +import org.w3c.css.sac.NegativeSelector; +import org.w3c.css.sac.PositionalCondition; +import org.w3c.css.sac.ProcessingInstructionSelector; +import org.w3c.css.sac.SACMediaList; +import org.w3c.css.sac.Selector; +import org.w3c.css.sac.SelectorList; +import org.w3c.css.sac.SiblingSelector; +import org.w3c.flute.parser.Parser; + +import java.io.IOException; +import java.io.StringReader; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.net.URISyntaxException; +import java.net.URL; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; +import java.util.Map; +import java.util.Stack; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * Generates a CssStylesheet from the contents of a URL. + */ +public class GenerateCssAst { + + /** + * Maps SAC CSSParseExceptions into a TreeLogger. All parsing errors will be + * recorded in a single TreeLogger branch, which will be created only if a + * loggable error message is emitted. + */ + private static class Errors implements ErrorHandler { + /** + * A flag that controls whether or not the exec method will fail. + */ + private boolean fatalErrorEncountered; + private TreeLogger logger; + private final TreeLogger parentLogger; + + /** + * Constructor. + * + * @param parentLogger the TreeLogger that should be branched to produce the + * CSS parsing messages. + */ + public Errors(TreeLogger parentLogger) { + this.parentLogger = parentLogger; + } + + public void error(CSSParseException exception) throws CSSException { + // TODO Since this indicates a loss of data, should this be a fatal error? + log(TreeLogger.WARN, exception); + } + + public void fatalError(CSSParseException exception) throws CSSException { + log(TreeLogger.ERROR, exception); + } + + public void log(TreeLogger.Type type, String message) { + log(type, message, null); + } + + public void log(TreeLogger.Type type, String message, Throwable t) { + fatalErrorEncountered |= type == TreeLogger.Type.ERROR; + if (parentLogger.isLoggable(type)) { + maybeBranch(); + logger.log(type, message, t); + } + } + + public void warning(CSSParseException exception) throws CSSException { + log(TreeLogger.DEBUG, exception); + } + + private void log(TreeLogger.Type type, CSSParseException e) { + log(type, "Line " + e.getLineNumber() + " column " + e.getColumnNumber() + + ": " + e.getMessage()); + } + + private void maybeBranch() { + if (logger == null) { + logger = parentLogger.branch(TreeLogger.INFO, + "The following problems were detected"); + } + } + } + + /** + * Maps the SAC model into our own CSS AST nodes. + */ + private static class GenerationHandler implements DocumentHandler { + /** + * The stylesheet that is being composed. + */ + private final CssStylesheet css = new CssStylesheet(); + + /** + * Accumulates CSS nodes as they are created. + */ + private final Stack<HasNodes> currentParent = new Stack<HasNodes>(); + + /** + * Accumulates CSS properties as they are seen. + */ + private HasProperties currentRule; + + /** + * Records references to {@code @def} rules. + */ + private final Map<String, CssDef> defs = new HashMap<String, CssDef>(); + + /** + * Used when parsing the contents of meta-styles. + */ + private final Errors errors; + + /** + * Used by {@link #startSelector(SelectorList)} to suppress the creation of + * new CssRules in favor of retaining {@link #currentRule}. + */ + private boolean nextSelectorCreatesRule = true; + + public GenerationHandler(Errors errors) { + this.errors = errors; + currentParent.push(css); + } + + public void comment(String text) throws CSSException { + // Ignore comments + // TODO Should comments be retained but not generally printed? + } + + public void endDocument(InputSource source) throws CSSException { + } + + public void endFontFace() throws CSSException { + } + + public void endMedia(SACMediaList media) throws CSSException { + currentParent.pop(); + } + + public void endPage(String name, String pseudoPage) throws CSSException { + } + + public void endSelector(SelectorList selectors) throws CSSException { + } + + /** + * Reflectively invoke a method named parseRule on this instance. + */ + public void ignorableAtRule(String atRule) throws CSSException { + String ruleName = atRule.substring(1, atRule.indexOf(" ")); + String methodName = "parse" + (Character.toUpperCase(ruleName.charAt(0))) + + ruleName.substring(1); + try { + Method parseMethod = getClass().getDeclaredMethod(methodName, + String.class); + parseMethod.invoke(this, atRule); + } catch (NoSuchMethodException e) { + errors.log(TreeLogger.WARN, "Ignoring @" + ruleName); + } catch (IllegalAccessException e) { + errors.log(TreeLogger.ERROR, "Unable to invoke parse method ", e); + } catch (InvocationTargetException e) { + if (e.getCause() instanceof CSSException) { + throw (CSSException) e.getCause(); + } + + errors.log(TreeLogger.ERROR, "Unable to invoke parse method ", e); + } + } + + public void importStyle(String uri, SACMediaList media, + String defaultNamespaceURI) throws CSSException { + } + + public void namespaceDeclaration(String prefix, String uri) + throws CSSException { + } + + public void property(String name, LexicalUnit value, boolean important) + throws CSSException { + List<Value> values = new ArrayList<Value>(); + if (value != null) { + extractValueOf(values, value); + } + currentRule.getProperties().add( + new CssProperty(escapeIdent(name), new ListValue(values), important)); + } + + public void startDocument(InputSource source) throws CSSException { + } + + public void startFontFace() throws CSSException { + } + + public void startMedia(SACMediaList media) throws CSSException { + CssMediaRule r = new CssMediaRule(); + for (int i = 0; i < media.getLength(); i++) { + r.getMedias().add(media.item(i)); + } + + pushParent(r); + } + + public void startPage(String name, String pseudoPage) throws CSSException { + CssPageRule r = new CssPageRule(); + // name appears to be unused in CSS2 + r.setPseudoPage(pseudoPage); + addNode(r); + currentRule = r; + } + + public void startSelector(SelectorList selectors) throws CSSException { + CssRule r; + + if (nextSelectorCreatesRule) { + r = new CssRule(); + addNode(r); + currentRule = r; + } else { + r = (CssRule) currentRule; + nextSelectorCreatesRule = true; + } + + for (int i = 0; i < selectors.getLength(); i++) { + r.getSelectors().add(new CssSelector(valueOf(selectors.item(i)))); + } + } + + void parseDef(String atRule) { + String value = atRule.substring(4, atRule.length()).trim(); + + InputSource s = new InputSource(); + s.setCharacterStream(new StringReader(value)); + Parser parser = new Parser(); + parser.setErrorHandler(errors); + + final List<Value> values = new ArrayList<Value>(); + parser.setDocumentHandler(new PropertyExtractor(values)); + + try { + String dummy = "* { prop : " + value + "}"; + parser.parseStyleSheet(new InputSource(new StringReader(dummy))); + } catch (IOException e) { + assert false : "Should never happen"; + } + + if (values.size() < 2) { + throw new CSSException(CSSException.SAC_SYNTAX_ERR, + "@def rules must specify an identifier and one or more values", + null); + } + + IdentValue defName = values.get(0).isIdentValue(); + + if (defName == null) { + throw new CSSException(CSSException.SAC_SYNTAX_ERR, + "First lexical unit must be an identifier", null); + } + + /* + * Replace any references to previously-seen @def constructs. We do + * expansion up-front to prevent the need for cycle-detection later. + */ + for (ListIterator<Value> it = values.listIterator(1); it.hasNext();) { + IdentValue maybeDefReference = it.next().isIdentValue(); + if (maybeDefReference != null) { + CssDef previousDef = defs.get(maybeDefReference.getIdent()); + if (previousDef != null) { + it.remove(); + for (Value previousValue : previousDef.getValues()) { + it.add(previousValue); + } + } + } + } + + CssDef def = new CssDef(defName.getIdent()); + def.getValues().addAll(values.subList(1, values.size())); + addNode(def); + + defs.put(defName.getIdent(), def); + } + + /** + * The elif nodes are processed as though they were {@code @if} nodes. The + * newly-generated CssIf node will be attached to the last CssIf in the + * if/else chain. + */ + void parseElif(String atRule) throws CSSException { + List<CssNode> nodes = currentParent.peek().getNodes(); + CssIf lastIf = findLastIfInChain(nodes); + + if (lastIf == null) { + throw new CSSException(CSSException.SAC_SYNTAX_ERR, + "@elif must immediately follow an @if or @elif", null); + } + + assert lastIf.getElseNodes().isEmpty(); + + // @elif -> lif (because parseIf strips the first three chars) + parseIf(atRule.substring(2)); + + // Fix up the structure by remove the newly-created node from the parent + // context and moving it to the end of the @if chain + lastIf.getElseNodes().add(nodes.remove(nodes.size() - 1)); + } + + /** + * The else nodes are processed as though they were written as {@code @elif + * true} rules. + */ + void parseElse(String atRule) throws CSSException { + // The last CssIf in the if/else chain + CssIf lastIf = findLastIfInChain(currentParent.peek().getNodes()); + + if (lastIf == null) { + throw new CSSException(CSSException.SAC_SYNTAX_ERR, + "@else must immediately follow an @if or @elif", null); + } + + // Create the CssIf to hold the @else rules + String fakeElif = "@elif (true) " + atRule.substring(atRule.indexOf("{")); + parseElif(fakeElif); + CssIf elseIf = findLastIfInChain(currentParent.peek().getNodes()); + + assert lastIf.getElseNodes().size() == 1 + && lastIf.getElseNodes().get(0) == elseIf; + assert elseIf.getElseNodes().isEmpty(); + + // Merge the rules into the last CssIf to break the chain and prevent + // @else followed by @else + lastIf.getElseNodes().clear(); + lastIf.getElseNodes().addAll(elseIf.getNodes()); + } + + void parseEval(String atRule) throws CSSException { + // @eval key com.google.Type.staticFunction + String[] parts = atRule.substring(0, atRule.length() - 1).split("\\s"); + + if (parts.length != 3) { + throw new CSSException(CSSException.SAC_SYNTAX_ERR, + "Incorrect number of parts for @eval", null); + } + + CssEval eval = new CssEval(parts[1], parts[2]); + addNode(eval); + } + + void parseIf(String atRule) throws CSSException { + String predicate = atRule.substring(3, atRule.indexOf('{') - 1).trim(); + String blockContents = atRule.substring(atRule.indexOf('{') + 1, + atRule.length() - 1); + + CssIf cssIf = new CssIf(); + + if (predicate.startsWith("(") && predicate.endsWith(")")) { + cssIf.setExpression(predicate); + } else { + + String[] predicateParts = predicate.split("\\s"); + + switch (predicateParts.length) { + case 0: + throw new CSSException(CSSException.SAC_SYNTAX_ERR, + "Incorrect format for @if predicate", null); + case 1: + if (predicateParts[0].length() == 0) { + throw new CSSException(CSSException.SAC_SYNTAX_ERR, + "Incorrect format for @if predicate", null); + } + errors.log( + TreeLogger.WARN, + "Deprecated syntax for Java expression detected. Enclose the expression in parentheses"); + cssIf.setExpression(predicateParts[0]); + break; + default: + if (predicateParts[0].startsWith("!")) { + cssIf.setNegated(true); + cssIf.setProperty(predicateParts[0].substring(1)); + } else { + cssIf.setProperty(predicateParts[0]); + } + String[] values = new String[predicateParts.length - 1]; + System.arraycopy(predicateParts, 1, values, 0, values.length); + cssIf.setPropertyValues(values); + } + } + + parseInnerStylesheet("@if", cssIf, blockContents); + } + + void parseNoflip(String atRule) throws CSSException { + String blockContents = atRule.substring(atRule.indexOf('{') + 1, + atRule.length() - 1); + + parseInnerStylesheet("@noflip", new CssNoFlip(), blockContents); + } + + void parseSprite(String atRule) throws CSSException { + CssSprite sprite = new CssSprite(); + currentRule = sprite; + addNode(sprite); + + // Flag to tell startSelector() to use the CssSprite instead of creating + // its own CssRule. + nextSelectorCreatesRule = false; + + // parse the inner text + InputSource s = new InputSource(); + s.setCharacterStream(new StringReader(atRule.substring(7))); + Parser parser = new Parser(); + parser.setDocumentHandler(this); + parser.setErrorHandler(errors); + + try { + parser.parseRule(s); + } catch (IOException e) { + throw new CSSException(CSSException.SAC_SYNTAX_ERR, + "Unable to parse @sprite", e); + } + } + + void parseUrl(String atRule) throws CSSException { + // @url key dataResourceFunction + String[] parts = atRule.substring(0, atRule.length() - 1).split("\\s"); + + if (parts.length != 3) { + throw new CSSException(CSSException.SAC_SYNTAX_ERR, + "Incorrect number of parts for @url", null); + } + + CssUrl url = new CssUrl(parts[1], parts[2]); + addNode(url); + } + + /** + * Add a node to the current parent. + */ + private void addNode(CssNode node) { + currentParent.peek().getNodes().add(node); + } + + private <T extends CssNode & HasNodes> void parseInnerStylesheet( + String tagName, T parent, String blockContents) { + pushParent(parent); + + // parse the inner text + InputSource s = new InputSource(); + s.setCharacterStream(new StringReader(blockContents)); + Parser parser = new Parser(); + parser.setDocumentHandler(this); + parser.setErrorHandler(errors); + + try { + parser.parseStyleSheet(s); + } catch (IOException e) { + throw new CSSException(CSSException.SAC_SYNTAX_ERR, "Unable to parse " + + tagName, e); + } + + if (currentParent.pop() != parent) { + // This is a coding error + throw new RuntimeException("Incorrect element popped"); + } + } + + /** + * Adds a node to the current parent and then makes the node the current + * parent node. + */ + private <T extends CssNode & HasNodes> void pushParent(T newParent) { + addNode(newParent); + currentParent.push(newParent); + } + } + + /** + * Extracts all properties in a document into a List. + */ + private static class PropertyExtractor implements DocumentHandler { + private final List<Value> values; + + private PropertyExtractor(List<Value> values) { + this.values = values; + } + + public void comment(String text) throws CSSException { + } + + public void endDocument(InputSource source) throws CSSException { + } + + public void endFontFace() throws CSSException { + } + + public void endMedia(SACMediaList media) throws CSSException { + } + + public void endPage(String name, String pseudoPage) throws CSSException { + } + + public void endSelector(SelectorList selectors) throws CSSException { + } + + public void ignorableAtRule(String atRule) throws CSSException { + } + + public void importStyle(String uri, SACMediaList media, + String defaultNamespaceURI) throws CSSException { + } + + public void namespaceDeclaration(String prefix, String uri) + throws CSSException { + } + + public void property(String name, LexicalUnit value, boolean important) + throws CSSException { + extractValueOf(values, value); + } + + public void startDocument(InputSource source) throws CSSException { + } + + public void startFontFace() throws CSSException { + } + + public void startMedia(SACMediaList media) throws CSSException { + } + + public void startPage(String name, String pseudoPage) throws CSSException { + } + + public void startSelector(SelectorList selectors) throws CSSException { + } + } + + private static final String LITERAL_FUNCTION_NAME = "literal"; + + private static final String VALUE_FUNCTION_NAME = "value"; + + /** + * Create a CssStylesheet from the contents of a URL. + */ + public static CssStylesheet exec(TreeLogger logger, URL[] stylesheets) + throws UnableToCompleteException { + Parser p = new Parser(); + Errors errors = new Errors(logger); + GenerationHandler g = new GenerationHandler(errors); + p.setDocumentHandler(g); + p.setErrorHandler(errors); + + for (URL stylesheet : stylesheets) { + TreeLogger branchLogger = logger.branch(TreeLogger.DEBUG, + "Parsing CSS stylesheet " + stylesheet.toExternalForm()); + try { + p.parseStyleSheet(stylesheet.toURI().toString()); + continue; + } catch (CSSException e) { + branchLogger.log(TreeLogger.ERROR, "Unable to parse CSS", e); + } catch (IOException e) { + branchLogger.log(TreeLogger.ERROR, "Unable to parse CSS", e); + } catch (URISyntaxException e) { + branchLogger.log(TreeLogger.ERROR, "Unable to parse CSS", e); + } + throw new UnableToCompleteException(); + } + + if (errors.fatalErrorEncountered) { + // Logging will have been performed by the Errors instance, just exit + throw new UnableToCompleteException(); + } + + return g.css; + } + + /** + * Expresses an rgb function as a hex expression. + * + * @param colors a sequence of LexicalUnits, assumed to be + * <code>(INT COMMA INT COMMA INT)</code> + * @return the minimal hex expression for the RGB color values + */ + private static Value colorValue(LexicalUnit colors) { + LexicalUnit red = colors; + assert red.getLexicalUnitType() == LexicalUnit.SAC_INTEGER; + LexicalUnit green = red.getNextLexicalUnit().getNextLexicalUnit(); + assert green.getLexicalUnitType() == LexicalUnit.SAC_INTEGER; + LexicalUnit blue = green.getNextLexicalUnit().getNextLexicalUnit(); + assert blue.getLexicalUnitType() == LexicalUnit.SAC_INTEGER; + + int r = Math.min(red.getIntegerValue(), 255); + int g = Math.min(green.getIntegerValue(), 255); + int b = Math.min(blue.getIntegerValue(), 255); + + String sr = Integer.toHexString(r); + if (sr.length() == 1) { + sr = "0" + sr; + } + + String sg = Integer.toHexString(g); + if (sg.length() == 1) { + sg = "0" + sg; + } + + String sb = Integer.toHexString(b); + if (sb.length() == 1) { + sb = "0" + sb; + } + + // #AABBCC --> #ABC + if (sr.charAt(0) == sr.charAt(1) && sg.charAt(0) == sg.charAt(1) + && sb.charAt(0) == sb.charAt(1)) { + sr = sr.substring(1); + sg = sg.substring(1); + sb = sb.substring(1); + } + + return new IdentValue("#" + sr + sg + sb); + } + + private static String escapeIdent(String selector) { + assert selector.length() > 0; + + StringBuilder toReturn = new StringBuilder(); + if (!isIdentStart(selector.charAt(0))) { + toReturn.append('\\'); + } + toReturn.append(selector.charAt(0)); + + if (selector.length() > 1) { + for (char c : selector.substring(1).toCharArray()) { + if (!isIdentPart(c)) { + toReturn.append('\\'); + } + toReturn.append(c); + } + } + return toReturn.toString(); + } + + /** + * Convert a LexicalUnit list into a List of Values. + */ + private static void extractValueOf(List<Value> accumulator, LexicalUnit value) { + do { + accumulator.add(valueOf(value)); + value = value.getNextLexicalUnit(); + } while (value != null); + } + + /** + * The elif and else constructs are modeled as nested if statements in the + * CssIf's elseNodes field. This method will search a list of CssNodes and + * remove the last chained CssIf from the last element in the list of nodes. + */ + private static CssIf findLastIfInChain(List<CssNode> nodes) { + if (nodes.isEmpty()) { + return null; + } + + CssNode lastNode = nodes.get(nodes.size() - 1); + if (lastNode instanceof CssIf) { + CssIf asIf = (CssIf) lastNode; + if (asIf.getElseNodes().isEmpty()) { + return asIf; + } else { + return findLastIfInChain(asIf.getElseNodes()); + } + } + return null; + } + + private static boolean isIdentPart(char c) { + return Character.isLetterOrDigit(c) || (c == '\\') || (c == '-'); + } + + private static boolean isIdentStart(char c) { + return Character.isLetter(c) || (c == '\\'); + } + + /** + * Utility method to concatenate strings. + */ + private static String join(Iterable<Value> elements, String separator) { + StringBuilder b = new StringBuilder(); + for (Iterator<Value> i = elements.iterator(); i.hasNext();) { + b.append(i.next().toCss()); + if (i.hasNext()) { + b.append(separator); + } + } + return b.toString(); + } + + private static String maybeUnquote(String s) { + if (s.startsWith("\"") && s.endsWith("\"")) { + return s.substring(1, s.length() - 1); + } + return s; + } + + /** + * Used when evaluating literal() rules. + */ + private static String unescapeLiteral(String s) { + s = s.replaceAll(Pattern.quote("\\\""), "\""); + s = s.replaceAll(Pattern.quote("\\\\"), Matcher.quoteReplacement("\\")); + return s; + } + + private static String valueOf(Condition condition) { + if (condition instanceof AttributeCondition) { + AttributeCondition c = (AttributeCondition) condition; + switch (c.getConditionType()) { + case Condition.SAC_ATTRIBUTE_CONDITION: + return "[" + c.getLocalName() + + (c.getValue() != null ? "=\"" + c.getValue() + '"' : "") + "]"; + case Condition.SAC_ONE_OF_ATTRIBUTE_CONDITION: + return "[" + c.getLocalName() + "~=\"" + c.getValue() + "\"]"; + case Condition.SAC_BEGIN_HYPHEN_ATTRIBUTE_CONDITION: + return "[" + c.getLocalName() + "|=\"" + c.getValue() + "\"]"; + case Condition.SAC_ID_CONDITION: + return "#" + c.getValue(); + case Condition.SAC_CLASS_CONDITION: + return "." + c.getValue(); + case Condition.SAC_PSEUDO_CLASS_CONDITION: + return ":" + c.getValue(); + } + + } else if (condition instanceof CombinatorCondition) { + CombinatorCondition c = (CombinatorCondition) condition; + switch (condition.getConditionType()) { + case Condition.SAC_AND_CONDITION: + return valueOf(c.getFirstCondition()) + + valueOf(c.getSecondCondition()); + case Condition.SAC_OR_CONDITION: + // Unimplemented in CSS2? + } + + } else if (condition instanceof ContentCondition) { + // Unimplemented in CSS2? + + } else if (condition instanceof LangCondition) { + LangCondition c = (LangCondition) condition; + return ":lang(" + c.getLang() + ")"; + + } else if (condition instanceof NegativeCondition) { + // Unimplemented in CSS2? + } else if (condition instanceof PositionalCondition) { + // Unimplemented in CSS2? + } + + throw new RuntimeException("Unhandled condition of type " + + condition.getConditionType() + " " + condition.getClass().getName()); + } + + private static Value valueOf(LexicalUnit value) { + switch (value.getLexicalUnitType()) { + case LexicalUnit.SAC_ATTR: + return new IdentValue("attr(" + value.getStringValue() + ")"); + case LexicalUnit.SAC_IDENT: + return new IdentValue(escapeIdent(value.getStringValue())); + case LexicalUnit.SAC_STRING_VALUE: + return new StringValue(value.getStringValue()); + case LexicalUnit.SAC_RGBCOLOR: + // flute models the commas as operators so no separator needed + return colorValue(value.getParameters()); + case LexicalUnit.SAC_INTEGER: + return new NumberValue(value.getIntegerValue()); + case LexicalUnit.SAC_REAL: + return new NumberValue(value.getFloatValue()); + case LexicalUnit.SAC_CENTIMETER: + case LexicalUnit.SAC_DEGREE: + case LexicalUnit.SAC_DIMENSION: + case LexicalUnit.SAC_EM: + case LexicalUnit.SAC_EX: + case LexicalUnit.SAC_GRADIAN: + case LexicalUnit.SAC_HERTZ: + case LexicalUnit.SAC_KILOHERTZ: + case LexicalUnit.SAC_MILLIMETER: + case LexicalUnit.SAC_MILLISECOND: + case LexicalUnit.SAC_PERCENTAGE: + case LexicalUnit.SAC_PICA: + case LexicalUnit.SAC_PIXEL: + case LexicalUnit.SAC_POINT: + case LexicalUnit.SAC_RADIAN: + case LexicalUnit.SAC_SECOND: + return new NumberValue(value.getFloatValue(), + value.getDimensionUnitText()); + case LexicalUnit.SAC_URI: + return new IdentValue("url(" + value.getStringValue() + ")"); + case LexicalUnit.SAC_OPERATOR_COMMA: + return new IdentValue(","); + case LexicalUnit.SAC_COUNTER_FUNCTION: + case LexicalUnit.SAC_COUNTERS_FUNCTION: + case LexicalUnit.SAC_FUNCTION: { + if (value.getFunctionName().equals(VALUE_FUNCTION_NAME)) { + // This is a call to value() + List<Value> params = new ArrayList<Value>(); + extractValueOf(params, value.getParameters()); + + if (params.size() != 1 && params.size() != 3) { + throw new CSSException(CSSException.SAC_SYNTAX_ERR, + "Incorrect number of parameters to " + VALUE_FUNCTION_NAME, + null); + } + + Value dotPathValue = params.get(0); + String dotPath = maybeUnquote(((StringValue) dotPathValue).getValue()); + String suffix = params.size() == 3 + ? maybeUnquote(((StringValue) params.get(2)).getValue()) : ""; + + return new DotPathValue(dotPath, suffix); + } else if (value.getFunctionName().equals(LITERAL_FUNCTION_NAME)) { + // This is a call to value() + List<Value> params = new ArrayList<Value>(); + extractValueOf(params, value.getParameters()); + + if (params.size() != 1) { + throw new CSSException(CSSException.SAC_SYNTAX_ERR, + "Incorrect number of parameters to " + LITERAL_FUNCTION_NAME, + null); + } + + Value expression = params.get(0); + if (!(expression instanceof StringValue)) { + throw new CSSException(CSSException.SAC_SYNTAX_ERR, + "The single argument to " + LITERAL_FUNCTION_NAME + + " must be a string value", null); + } + + String s = maybeUnquote(((StringValue) expression).getValue()); + s = unescapeLiteral(s); + + return new IdentValue(s); + + } else { + // Just return a String representation of the original value + List<Value> parameters = new ArrayList<Value>(); + extractValueOf(parameters, value.getParameters()); + return new IdentValue(value.getFunctionName() + "(" + + join(parameters, "") + ")"); + } + } + case LexicalUnit.SAC_INHERIT: + return new IdentValue("inherit"); + case LexicalUnit.SAC_OPERATOR_EXP: + return new IdentValue("^"); + case LexicalUnit.SAC_OPERATOR_GE: + return new IdentValue(">="); + case LexicalUnit.SAC_OPERATOR_GT: + return new IdentValue(">"); + case LexicalUnit.SAC_OPERATOR_LE: + return new IdentValue("<="); + case LexicalUnit.SAC_OPERATOR_LT: + return new IdentValue("<"); + case LexicalUnit.SAC_OPERATOR_MINUS: + return new IdentValue("-"); + case LexicalUnit.SAC_OPERATOR_MOD: + return new IdentValue("%"); + case LexicalUnit.SAC_OPERATOR_MULTIPLY: + return new IdentValue("*"); + case LexicalUnit.SAC_OPERATOR_PLUS: + return new IdentValue("+"); + case LexicalUnit.SAC_OPERATOR_SLASH: + return new IdentValue("/"); + case LexicalUnit.SAC_OPERATOR_TILDE: + return new IdentValue("~"); + case LexicalUnit.SAC_RECT_FUNCTION: { + // Just return this as a String + List<Value> parameters = new ArrayList<Value>(); + extractValueOf(parameters, value.getParameters()); + return new IdentValue("rect(" + join(parameters, "") + ")"); + } + case LexicalUnit.SAC_SUB_EXPRESSION: + // Should have been taken care of by our own traversal + case LexicalUnit.SAC_UNICODERANGE: + // Cannot be expressed in CSS2 + } + throw new RuntimeException("Unhandled LexicalUnit type " + + value.getLexicalUnitType()); + } + + private static String valueOf(Selector selector) { + if (selector instanceof CharacterDataSelector) { + // Unimplemented in CSS2? + + } else if (selector instanceof ConditionalSelector) { + ConditionalSelector s = (ConditionalSelector) selector; + String simpleSelector = valueOf(s.getSimpleSelector()); + + if ("*".equals(simpleSelector)) { + // Don't need the extra * for compound selectors + return valueOf(s.getCondition()); + } else { + return simpleSelector + valueOf(s.getCondition()); + } + + } else if (selector instanceof DescendantSelector) { + DescendantSelector s = (DescendantSelector) selector; + switch (s.getSelectorType()) { + case Selector.SAC_CHILD_SELECTOR: + if (s.getSimpleSelector().getSelectorType() == Selector.SAC_PSEUDO_ELEMENT_SELECTOR) { + return valueOf(s.getAncestorSelector()) + ":" + + valueOf(s.getSimpleSelector()); + } else { + return valueOf(s.getAncestorSelector()) + ">" + + valueOf(s.getSimpleSelector()); + } + case Selector.SAC_DESCENDANT_SELECTOR: + return valueOf(s.getAncestorSelector()) + " " + + valueOf(s.getSimpleSelector()); + } + + } else if (selector instanceof ElementSelector) { + ElementSelector s = (ElementSelector) selector; + if (s.getLocalName() == null) { + return "*"; + } else { + return escapeIdent(s.getLocalName()); + } + + } else if (selector instanceof NegativeSelector) { + // Unimplemented in CSS2? + + } else if (selector instanceof ProcessingInstructionSelector) { + // Unimplemented in CSS2? + + } else if (selector instanceof SiblingSelector) { + SiblingSelector s = (SiblingSelector) selector; + return valueOf(s.getSelector()) + "+" + valueOf(s.getSiblingSelector()); + } + + throw new RuntimeException("Unhandled selector of type " + + selector.getClass().getName()); + } + + /** + * Utility class. + */ + private GenerateCssAst() { + } +}
diff --git a/user/src/com/google/gwt/resources/css/Minify.java b/user/src/com/google/gwt/resources/css/Minify.java new file mode 100644 index 0000000..1a75c5b --- /dev/null +++ b/user/src/com/google/gwt/resources/css/Minify.java
@@ -0,0 +1,125 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css; + +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.dev.util.DefaultTextOutput; +import com.google.gwt.dev.util.TextOutput; +import com.google.gwt.dev.util.log.PrintWriterTreeLogger; +import com.google.gwt.resources.css.ast.CssStylesheet; +import com.google.gwt.util.tools.ArgHandlerExtra; +import com.google.gwt.util.tools.ArgHandlerFlag; +import com.google.gwt.util.tools.ToolBase; + +import java.io.File; +import java.io.PrintWriter; +import java.net.MalformedURLException; +import java.net.URL; + +/** + * This is a command-line utility to minify a GWT CSS stylesheet. + */ +public class Minify extends ToolBase { + + /** + * See {@link #printHelp()} for usage. + */ + public static void main(String[] args) { + (new Minify()).exec(args); + } + + private final PrintWriterTreeLogger logger = new PrintWriterTreeLogger( + new PrintWriter(System.err)); + private URL source; + private boolean pretty; + + private Minify() { + logger.setMaxDetail(TreeLogger.DEBUG); + } + + @Override + protected String getDescription() { + return "Minify a CSS file"; + } + + private void exec(String[] args) { + registerHandler(new ArgHandlerExtra() { + + @Override + public boolean addExtraArg(String arg) { + if (source != null) { + return false; + } + + try { + source = (new File(arg)).toURL(); + return true; + } catch (MalformedURLException e) { + e.printStackTrace(); + return false; + } + } + + @Override + public String getPurpose() { + return "The css file to process"; + } + + @Override + public String[] getTagArgs() { + return new String[] {"stylesheet.css"}; + } + }); + + registerHandler(new ArgHandlerFlag() { + @Override + public String getPurpose() { + return "Enable human-parsable output"; + } + + @Override + public String getTag() { + return "-pretty"; + } + + @Override + public boolean setFlag() { + return pretty = true; + } + }); + + if (!processArgs(args)) { + System.exit(-1); + } + + if (source == null) { + printHelp(); + System.exit(-1); + } + + try { + CssStylesheet sheet = GenerateCssAst.exec(logger, new URL[] {source}); + TextOutput out = new DefaultTextOutput(!pretty); + (new CssGenerationVisitor(out)).accept(sheet); + System.out.println(out.toString()); + } catch (UnableToCompleteException e) { + logger.log(TreeLogger.ERROR, "Unable to compile CSS"); + } + + System.exit(0); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CollapsedNode.java b/user/src/com/google/gwt/resources/css/ast/CollapsedNode.java new file mode 100644 index 0000000..f3dae4d --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CollapsedNode.java
@@ -0,0 +1,44 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import java.util.List; + +/** + * This delegate class bypasses traversal of a node, instead traversing the + * node's children. Any modifications made to the node list of the CollapsedNode + * will be reflected in the original node. + */ +public class CollapsedNode extends CssNode implements HasNodes { + + private final List<CssNode> nodes; + + public CollapsedNode(HasNodes parent) { + this(parent.getNodes()); + } + + public CollapsedNode(List<CssNode> nodes) { + this.nodes = nodes; + } + + public List<CssNode> getNodes() { + return nodes; + } + + public void traverse(CssVisitor visitor, Context context) { + visitor.acceptWithInsertRemove(getNodes()); + } +} \ No newline at end of file
diff --git a/user/src/com/google/gwt/resources/css/ast/Context.java b/user/src/com/google/gwt/resources/css/ast/Context.java new file mode 100644 index 0000000..9ee2608 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/Context.java
@@ -0,0 +1,35 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +/** + * The context in which a CSSNode visitation occurs. This represents the set of + * possible operations a CSSVisitor subclass can perform on the currently + * visited node. + */ +public interface Context { + boolean canInsert(); + + boolean canRemove(); + + void insertAfter(CssNode node); + + void insertBefore(CssNode node); + + void removeMe(); + + void replaceMe(CssNode node); +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssCompilerException.java b/user/src/com/google/gwt/resources/css/ast/CssCompilerException.java new file mode 100644 index 0000000..044d306 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssCompilerException.java
@@ -0,0 +1,32 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +/** + * Used by {@link CssVisitor}. + */ +public class CssCompilerException extends RuntimeException { + public CssCompilerException(String message) { + super(message); + } + + public CssCompilerException(String message, Throwable cause) { + super(message, cause); + } + + void addNode(CssNode node) { + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssDef.java b/user/src/com/google/gwt/resources/css/ast/CssDef.java new file mode 100644 index 0000000..2506989 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssDef.java
@@ -0,0 +1,46 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import com.google.gwt.resources.css.ast.CssProperty.Value; + +import java.util.ArrayList; +import java.util.List; + +/** + * A constant definition. + */ +public class CssDef extends CssNode { + private final String key; + private final List<Value> values = new ArrayList<Value>(); + + public CssDef(String key) { + this.key = key; + } + + public String getKey() { + return key; + } + + public List<Value> getValues() { + return values; + } + + public void traverse(CssVisitor visitor, Context context) { + visitor.visit(this, context); + visitor.endVisit(this, context); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssEval.java b/user/src/com/google/gwt/resources/css/ast/CssEval.java new file mode 100644 index 0000000..8a5ff98 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssEval.java
@@ -0,0 +1,46 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import com.google.gwt.resources.css.ast.CssProperty.ExpressionValue; +import com.google.gwt.resources.css.ast.CssProperty.Value; + +import java.util.Collections; +import java.util.List; + +/** + * A definition that is evaluated at runtime. + */ +public class CssEval extends CssDef { + private final List<Value> values; + + public CssEval(String key, String expression) { + super(key); + Value value = new ExpressionValue(expression); + values = Collections.singletonList(value); + } + + @Override + public List<Value> getValues() { + return values; + } + + @Override + public void traverse(CssVisitor visitor, Context context) { + visitor.visit(this, context); + visitor.endVisit(this, context); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssIf.java b/user/src/com/google/gwt/resources/css/ast/CssIf.java new file mode 100644 index 0000000..7a535f7 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssIf.java
@@ -0,0 +1,80 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import java.util.ArrayList; +import java.util.List; + +/** + * A GWTCSS if statement. The elif and else constructs are modeled as nested if + * statement is the elseNodes. + */ +public class CssIf extends CssNode implements HasNodes { + private final List<CssNode> elseNodes = new ArrayList<CssNode>(); + private final List<CssNode> nodes = new ArrayList<CssNode>(); + private String expression; + private boolean isNegated; + private String property; + private String[] propertyValues; + + public List<CssNode> getElseNodes() { + return elseNodes; + } + + public String getExpression() { + return expression; + } + + public List<CssNode> getNodes() { + return nodes; + } + + public String getPropertyName() { + return property; + } + + public String[] getPropertyValues() { + return propertyValues; + } + + public boolean isNegated() { + return isNegated; + } + + public void setExpression(String expression) { + this.expression = expression; + } + + public void setNegated(boolean isNegated) { + this.isNegated = isNegated; + } + + public void setProperty(String property) { + this.property = property; + } + + public void setPropertyValues(String[] propertyValues) { + this.propertyValues = propertyValues; + } + + public void traverse(CssVisitor visitor, Context context) { + if (visitor.visit(this, context)) { + visitor.acceptWithInsertRemove(nodes); + visitor.acceptWithInsertRemove(elseNodes); + } + visitor.endVisit(this, context); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssMediaRule.java b/user/src/com/google/gwt/resources/css/ast/CssMediaRule.java new file mode 100644 index 0000000..28c9192 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssMediaRule.java
@@ -0,0 +1,42 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import java.util.ArrayList; +import java.util.List; + +/** + * Represents an {@literal @}media rule. + */ +public class CssMediaRule extends CssNode implements HasNodes { + private final List<String> selectors = new ArrayList<String>(); + private final List<CssNode> nodes = new ArrayList<CssNode>(); + + public List<String> getMedias() { + return selectors; + } + + public List<CssNode> getNodes() { + return nodes; + } + + public void traverse(CssVisitor visitor, Context context) { + if (visitor.visit(this, context)) { + visitor.acceptWithInsertRemove(nodes); + } + visitor.endVisit(this, context); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssModVisitor.java b/user/src/com/google/gwt/resources/css/ast/CssModVisitor.java new file mode 100644 index 0000000..e0244fc --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssModVisitor.java
@@ -0,0 +1,107 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import java.util.List; + +/** + * A visitor that can make structural modifications to a CSS tree. + */ +@SuppressWarnings("unchecked") +public class CssModVisitor extends CssVisitor { + private class ListContext<T extends CssNode> implements Context { + private int index; + private List list; + private boolean removed; + private boolean replaced; + + public boolean canInsert() { + return true; + } + + public boolean canRemove() { + return true; + } + + public void insertAfter(CssNode node) { + checkRemoved(); + list.add(index + 1, node); + didChange = true; + } + + public void insertBefore(CssNode node) { + checkRemoved(); + list.add(index++, node); + didChange = true; + } + + public void removeMe() { + checkState(); + list.remove(index--); + didChange = removed = true; + } + + public void replaceMe(CssNode node) { + checkState(); + checkReplacement((CssNode) list.get(index), node); + list.set(index, node); + didChange = replaced = true; + } + + protected void traverse(List<? extends CssNode> list) { + this.list = list; + for (index = 0; index < list.size(); ++index) { + removed = replaced = false; + doTraverse(list.get(index), this); + } + } + + private void checkRemoved() { + if (removed) { + throw new CssCompilerException("Node was already removed"); + } + } + + private void checkState() { + checkRemoved(); + if (replaced) { + throw new CssCompilerException("Node was already replaced"); + } + } + } + + protected static void checkReplacement(CssNode origNode, CssNode newNode) { + if (newNode == null) { + throw new CssCompilerException("Cannot replace with null"); + } + if (newNode == origNode) { + throw new CssCompilerException( + "The replacement is the same as the original"); + } + } + + private boolean didChange; + + public boolean didChange() { + return didChange; + } + + @Override + protected void doAcceptWithInsertRemove(List<? extends CssNode> list) { + ListContext context = new ListContext(); + context.traverse(list); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssNoFlip.java b/user/src/com/google/gwt/resources/css/ast/CssNoFlip.java new file mode 100644 index 0000000..35604cd --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssNoFlip.java
@@ -0,0 +1,38 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import java.util.ArrayList; +import java.util.List; + +/** + * This is a container node to prevent the RTL visitor from affecting its child + * nodes. + */ +public class CssNoFlip extends CssNode implements HasNodes { + private List<CssNode> nodes = new ArrayList<CssNode>(); + + public List<CssNode> getNodes() { + return nodes; + } + + public void traverse(CssVisitor visitor, Context context) { + if (visitor.visit(this, context)) { + visitor.acceptWithInsertRemove(nodes); + } + visitor.endVisit(this, context); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssNode.java b/user/src/com/google/gwt/resources/css/ast/CssNode.java new file mode 100644 index 0000000..80d6fd5 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssNode.java
@@ -0,0 +1,32 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import com.google.gwt.dev.util.DefaultTextOutput; +import com.google.gwt.resources.css.CssGenerationVisitor; + +/** + * The basic type that composes a CSS tree. + */ +public abstract class CssNode implements CssVisitable { + @Override + public String toString() { + DefaultTextOutput out = new DefaultTextOutput(false); + CssGenerationVisitor v = new CssGenerationVisitor(out, true); + v.accept(this); + return out.toString(); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssNodeCloner.java b/user/src/com/google/gwt/resources/css/ast/CssNodeCloner.java new file mode 100644 index 0000000..8e8d145 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssNodeCloner.java
@@ -0,0 +1,310 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Stack; + +/** + * Clones CssNodes. + */ +public class CssNodeCloner extends CssVisitor { + + /** + * Clone a list of nodes. + */ + public static <T extends CssNode> List<T> clone(Class<T> clazz, List<T> nodes) { + + // Push a fake context that will contain the cloned node + List<CssNode> topContext = new ArrayList<CssNode>(); + final List<CssProperty> topProperties = new ArrayList<CssProperty>(); + final List<CssSelector> topSelectors = new ArrayList<CssSelector>(); + + CssNodeCloner cloner = new CssNodeCloner(); + cloner.curentNodes.push(topContext); + cloner.currentHasProperties = new HasProperties() { + public List<CssProperty> getProperties() { + return topProperties; + } + }; + cloner.currentHasSelectors = new HasSelectors() { + public List<CssSelector> getSelectors() { + return topSelectors; + } + }; + + // Process the nodes + cloner.accept(nodes); + + /* + * Return the requested data. Different AST nodes will have been collected + * in different parts of the initial context. + */ + List<?> toIterate; + if (CssProperty.class.isAssignableFrom(clazz)) { + toIterate = topProperties; + } else if (CssSelector.class.isAssignableFrom(clazz)) { + toIterate = topSelectors; + } else { + toIterate = topContext; + } + + assert toIterate.size() == nodes.size() : "Wrong number of nodes in top " + + "context. Expecting: " + nodes.size() + " Found: " + toIterate.size(); + + // Create the final return value + List<T> toReturn = new ArrayList<T>(toIterate.size()); + for (Object node : toIterate) { + assert clazz.isInstance(node) : "Return type mismatch. Expecting: " + + clazz.getName() + " Found: " + node.getClass().getName(); + + // Cast to the correct type to avoid an unchecked generic cast + toReturn.add(clazz.cast(node)); + } + + return toReturn; + } + + /** + * Clone a single node. + */ + public static <T extends CssNode> T clone(Class<T> clazz, T node) { + return clone(clazz, Collections.singletonList(node)).get(0); + } + + private HasProperties currentHasProperties; + + private HasSelectors currentHasSelectors; + + private final Stack<List<CssNode>> curentNodes = new Stack<List<CssNode>>(); + + private CssNodeCloner() { + } + + @Override + public void endVisit(CssMediaRule x, Context ctx) { + popNodes(x); + } + + @Override + public void endVisit(CssNoFlip x, Context ctx) { + popNodes(x); + } + + @Override + public void endVisit(CssStylesheet x, Context ctx) { + popNodes(x); + } + + @Override + public boolean visit(CssDef x, Context ctx) { + CssDef newDef = new CssDef(x.getKey()); + newDef.getValues().addAll(x.getValues()); + + addToNodes(newDef); + return true; + } + + @Override + public boolean visit(CssEval x, Context ctx) { + assert x.getValues().size() == 1; + assert x.getValues().get(0).isExpressionValue() != null; + + String value = x.getValues().get(0).isExpressionValue().getExpression(); + CssEval newEval = new CssEval(x.getKey(), value); + addToNodes(newEval); + return true; + } + + /** + * A CssIf has two lists of nodes, so we want to handle traversal in this + * visitor. + */ + @Override + public boolean visit(CssIf x, Context ctx) { + CssIf newIf = new CssIf(); + + if (x.getExpression() != null) { + newIf.setExpression(x.getExpression()); + } else { + newIf.setProperty(x.getPropertyName()); + + String[] newValues = new String[x.getPropertyValues().length]; + System.arraycopy(x.getPropertyValues(), 0, newValues, 0, newValues.length); + newIf.setPropertyValues(newValues); + + newIf.setNegated(x.isNegated()); + } + + // Handle the "then" part + pushNodes(newIf); + accept(x.getNodes()); + popNodes(x, newIf); + + /* + * Push the "else" part as though it were its own node, but don't add it as + * its own top-level node. + */ + CollapsedNode oldElseNodes = new CollapsedNode(x.getElseNodes()); + CollapsedNode newElseNodes = new CollapsedNode(newIf.getElseNodes()); + pushNodes(newElseNodes, false); + accept(oldElseNodes); + popNodes(oldElseNodes, newElseNodes); + + return false; + } + + @Override + public boolean visit(CssMediaRule x, Context ctx) { + CssMediaRule newRule = new CssMediaRule(); + newRule.getMedias().addAll(newRule.getMedias()); + + pushNodes(newRule); + return true; + } + + @Override + public boolean visit(CssNoFlip x, Context ctx) { + pushNodes(new CssNoFlip()); + return true; + } + + @Override + public boolean visit(CssPageRule x, Context ctx) { + CssPageRule newRule = new CssPageRule(); + newRule.setPseudoPage(x.getPseudoPage()); + addToNodes(newRule); + return true; + } + + @Override + public boolean visit(CssProperty x, Context ctx) { + CssProperty newProperty = new CssProperty(x.getName(), x.getValues(), + x.isImportant()); + currentHasProperties.getProperties().add(newProperty); + return true; + } + + @Override + public boolean visit(CssRule x, Context ctx) { + CssRule newRule = new CssRule(); + addToNodes(newRule); + return true; + } + + @Override + public boolean visit(CssSelector x, Context ctx) { + CssSelector newSelector = new CssSelector(x.getSelector()); + currentHasSelectors.getSelectors().add(newSelector); + return true; + } + + @Override + public boolean visit(CssSprite x, Context ctx) { + CssSprite newSprite = new CssSprite(); + newSprite.setResourceFunction(x.getResourceFunction()); + addToNodes(newSprite); + return true; + } + + @Override + public boolean visit(CssStylesheet x, Context ctx) { + CssStylesheet newSheet = new CssStylesheet(); + pushNodes(newSheet); + return true; + } + + @Override + public boolean visit(CssUrl x, Context ctx) { + assert x.getValues().size() == 1; + assert x.getValues().get(0).isIdentValue() != null; + String ident = x.getValues().get(0).isIdentValue().getIdent(); + CssUrl newUrl = new CssUrl(x.getKey(), ident); + addToNodes(newUrl); + return true; + } + + /** + * Add a cloned node instance to the output. + */ + private void addToNodes(CssNode node) { + curentNodes.peek().add(node); + + currentHasProperties = node instanceof HasProperties ? (HasProperties) node + : null; + currentHasSelectors = node instanceof HasSelectors ? (HasSelectors) node + : null; + } + + /** + * Remove a frame. + * + * @param original the node that was being cloned so that validity checks may + * be performed + */ + private List<CssNode> popNodes(HasNodes original) { + List<CssNode> toReturn = curentNodes.pop(); + + if (toReturn.size() != original.getNodes().size()) { + throw new RuntimeException("Insufficient number of nodes for a " + + original.getClass().getName() + " Expected: " + + original.getNodes().size() + " Found: " + toReturn.size()); + } + + return toReturn; + } + + /** + * Remove a frame. + * + * @param original the node that was being cloned so that validity checks may + * be performed + * @param expected the HasNodes whose nodes were being populated by the frame + * being removed. + */ + private List<CssNode> popNodes(HasNodes original, HasNodes expected) { + List<CssNode> toReturn = popNodes(original); + + if (toReturn != expected.getNodes()) { + throw new RuntimeException("Incorrect parent node list popped"); + } + + return toReturn; + } + + /** + * Push a new frame, adding the new parent as a child of the current parent. + */ + private <T extends CssNode & HasNodes> void pushNodes(T parent) { + pushNodes(parent, true); + } + + /** + * Push a new frame. + * + * @param addToNodes if <code>true</code> add the new parent node as a child + * of the current parent. + */ + private <T extends CssNode & HasNodes> void pushNodes(T parent, + boolean addToNodes) { + if (addToNodes) { + addToNodes(parent); + } + this.curentNodes.push(parent.getNodes()); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssPageRule.java b/user/src/com/google/gwt/resources/css/ast/CssPageRule.java new file mode 100644 index 0000000..36423ce --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssPageRule.java
@@ -0,0 +1,46 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import java.util.ArrayList; +import java.util.List; + +/** + * A page rule in CSS. + */ +public class CssPageRule extends CssNode implements HasProperties { + private final List<CssProperty> nodes = new ArrayList<CssProperty>(); + private String pseudoPage; + + public List<CssProperty> getProperties() { + return nodes; + } + + public String getPseudoPage() { + return pseudoPage; + } + + public void setPseudoPage(String pseudoPage) { + this.pseudoPage = pseudoPage; + } + + public void traverse(CssVisitor visitor, Context context) { + if (visitor.visit(this, context)) { + visitor.acceptWithInsertRemove(nodes); + } + visitor.endVisit(this, context); + } +} \ No newline at end of file
diff --git a/user/src/com/google/gwt/resources/css/ast/CssProperty.java b/user/src/com/google/gwt/resources/css/ast/CssProperty.java new file mode 100644 index 0000000..be4e91d --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssProperty.java
@@ -0,0 +1,389 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import com.google.gwt.core.ext.Generator; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; + +/** + * Maps a named property to a Value. + */ +public class CssProperty extends CssNode { + + /** + * Represents a sequence of no-arg method invocations. + */ + public static class DotPathValue extends Value { + private final String path; + private final String suffix; + + public DotPathValue(String path, String suffix) { + this.path = path; + this.suffix = suffix; + } + + public String getExpression() { + return path.replace(".", "().") + "() + \"" + Generator.escape(suffix) + + "\""; + } + + public String getPath() { + return path; + } + + public String getSuffix() { + return suffix; + } + + @Override + public DotPathValue isDotPathValue() { + return this; + } + + public String toCss() { + return "value(\"" + path + "\"" + + (suffix == null ? "" : (", \"" + suffix + "\"")) + ")"; + } + } + + /** + * Represents a literal Java expression. + */ + public static class ExpressionValue extends Value { + private final String expression; + + public ExpressionValue(String expression) { + this.expression = expression; + } + + public String getExpression() { + return expression; + } + + @Override + public ExpressionValue isExpressionValue() { + return this; + } + + public String toCss() { + return "/* Java expression */"; + } + + /** + * For debugging only. + */ + @Override + public String toString() { + return expression; + } + } + + /** + * Represents an identifier in the CSS source. + */ + public static class IdentValue extends Value { + private final String ident; + + public IdentValue(String ident) { + this.ident = ident; + } + + public String getExpression() { + return '"' + Generator.escape(ident) + '"'; + } + + public String getIdent() { + return ident; + } + + @Override + public IdentValue isIdentValue() { + return this; + } + + public String toCss() { + return ident; + } + } + + /** + * Represents a space-separated list of Values. + */ + public static class ListValue extends Value { + private final List<Value> values; + + public ListValue(List<Value> values) { + this.values = Collections.unmodifiableList(new ArrayList<Value>(values)); + } + + public ListValue(Value... values) { + this(Arrays.asList(values)); + } + + public String getExpression() { + StringBuilder toReturn = new StringBuilder(); + for (Iterator<Value> i = values.iterator(); i.hasNext();) { + toReturn.append(i.next().getExpression()); + if (i.hasNext()) { + toReturn.append("+ \" \" +"); + } + } + return toReturn.toString(); + } + + public List<Value> getValues() { + return values; + } + + @Override + public ListValue isListValue() { + return this; + } + + public String toCss() { + StringBuilder sb = new StringBuilder(); + for (Value v : values) { + sb.append(" ").append(v.toCss()); + } + return sb.substring(1); + } + } + + /** + * Represents a numeric value, possibly with attached units. + */ + public static class NumberValue extends Value { + private final String css; + private final String expression; + private final String units; + private final float value; + + public NumberValue(float value) { + this(value, null); + } + + public NumberValue(float value, String units) { + this.value = value; + this.units = units; + + String s; + int i = (int) value; + if (i == value) { + s = String.valueOf(i); + } else { + s = String.valueOf(value); + } + + if (units != null && value != 0) { + css = s + units; + expression = '"' + s + Generator.escape(units) + '"'; + } else if (value == 0) { + css = "0"; + expression = "\"0\""; + } else { + css = s; + expression = '"' + s + '"'; + } + } + + public String getExpression() { + return expression; + } + + public String getUnits() { + return units; + } + + public float getValue() { + return value; + } + + @Override + public NumberValue isNumberValue() { + return this; + } + + public String toCss() { + return css; + } + } + + /** + * Represents one or more quoted string literals. + */ + public static class StringValue extends Value { + private static String escapeValue(String s, boolean inDoubleQuotes) { + StringBuilder b = new StringBuilder(); + for (char c : s.toCharArray()) { + if (Character.isISOControl(c)) { + b.append('\\').append(Integer.toHexString(c).toUpperCase()).append( + " "); + } else { + switch (c) { + case '\'': + // Special case a single quote in a pair of double quotes + if (inDoubleQuotes) { + b.append(c); + } else { + b.append("\\'"); + } + break; + + case '"': + // Special case a single quote in a pair of single quotes + if (inDoubleQuotes) { + b.append("\\\""); + } else { + b.append(c); + } + break; + + case '\\': + b.append("\\\\"); + break; + + default: + b.append(c); + } + } + } + + return b.toString(); + } + + private final String value; + + public StringValue(String value) { + this.value = value; + } + + public String getExpression() { + // The escaped CSS content has to be escaped to be a valid Java literal + return "\"" + Generator.escape(toCss()) + "\""; + } + + public String getValue() { + return value; + } + + @Override + public StringValue isStringValue() { + return this; + } + + /** + * Returns a escaped, quoted representation of the underlying value. + */ + public String toCss() { + return '"' + escapeValue(value, true) + '"'; + } + } + + /** + * An abstract encapsulation of property values in GWT CSS. + */ + public abstract static class Value { + /** + * Generate a Java expression whose execution results in the value. + */ + public abstract String getExpression(); + + public DotPathValue isDotPathValue() { + return null; + } + + public ExpressionValue isExpressionValue() { + return null; + } + + public IdentValue isIdentValue() { + return null; + } + + public ListValue isListValue() { + return null; + } + + public NumberValue isNumberValue() { + return null; + } + + public StringValue isStringValue() { + return null; + } + + /** + * Generate a CSS expression that represents the Value. + */ + public abstract String toCss(); + + /** + * For debugging only. + */ + @Override + public String toString() { + return toCss(); + } + } + + private boolean important; + + private String name; + private ListValue value; + + public CssProperty(String name, Value value, boolean important) { + this.name = name; + setValue(value); + this.important = important; + } + + public String getName() { + return name; + } + + public ListValue getValues() { + return value; + } + + public boolean isImportant() { + return important; + } + + public void setImportant(boolean important) { + this.important = important; + } + + public void setName(String name) { + this.name = name; + } + + public void setValue(Value value) { + this.value = value.isListValue(); + if (this.value == null) { + this.value = new ListValue(value); + } + } + + public void traverse(CssVisitor visitor, Context context) { + visitor.visit(this, context); + visitor.endVisit(this, context); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssRule.java b/user/src/com/google/gwt/resources/css/ast/CssRule.java new file mode 100644 index 0000000..6cb06ff --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssRule.java
@@ -0,0 +1,43 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import java.util.ArrayList; +import java.util.List; + +/** + * + */ +public class CssRule extends CssNode implements HasProperties, HasSelectors { + protected final List<CssProperty> properties = new ArrayList<CssProperty>(); + protected final List<CssSelector> selectors = new ArrayList<CssSelector>(); + + public List<CssProperty> getProperties() { + return properties; + } + + public List<CssSelector> getSelectors() { + return selectors; + } + + public void traverse(CssVisitor visitor, Context context) { + if (visitor.visit(this, context)) { + visitor.acceptWithInsertRemove(selectors); + visitor.acceptWithInsertRemove(properties); + } + visitor.endVisit(this, context); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssSelector.java b/user/src/com/google/gwt/resources/css/ast/CssSelector.java new file mode 100644 index 0000000..5d52ed1 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssSelector.java
@@ -0,0 +1,44 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +/** + * + */ +public class CssSelector extends CssNode { + /* + * TODO: Evaluate whether or not we need to have a type hierarchy of + * selectors. + */ + private String selector; + + public CssSelector(String selector) { + this.selector = selector; + } + + public String getSelector() { + return selector; + } + + public void setSelector(String selector) { + this.selector = selector; + } + + public void traverse(CssVisitor visitor, Context context) { + visitor.visit(this, context); + visitor.endVisit(this, context); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssSprite.java b/user/src/com/google/gwt/resources/css/ast/CssSprite.java new file mode 100644 index 0000000..0d563f9 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssSprite.java
@@ -0,0 +1,214 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import com.google.gwt.resources.css.ast.CssProperty.ListValue; +import com.google.gwt.resources.css.ast.CssProperty.StringValue; +import com.google.gwt.resources.css.ast.CssProperty.Value; + +import java.util.Collection; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; + +/** + * Represents a sprited image. This is basically a normal CssRule, except for + * one well-known property {@value CssSprite#IMAGE_PROPERTY_NAME}, which + * specifies the name of an ImageResource accessor. + */ +public class CssSprite extends CssRule { + + public static final String IMAGE_PROPERTY_NAME = "gwt-image"; + + /** + * A facade for the underlying CssProperty list maintained by CssRule. We + * override the add and set methods to intercept the + * {@value CssSprite#IMAGE_PROPERTY_NAME} property. + */ + private class SpritePropertyList implements List<CssProperty> { + private final List<CssProperty> source; + + public SpritePropertyList(List<CssProperty> source) { + this.source = source; + } + + public boolean add(CssProperty o) { + if (!processProperty(o)) { + return source.add(o); + } else { + return false; + } + } + + public void add(int index, CssProperty element) { + if (!processProperty(element)) { + source.add(index, element); + } + } + + public boolean addAll(Collection<? extends CssProperty> c) { + return source.addAll(c); + } + + public boolean addAll(int index, Collection<? extends CssProperty> c) { + return source.addAll(index, c); + } + + public void clear() { + source.clear(); + } + + public boolean contains(Object o) { + return source.contains(o); + } + + public boolean containsAll(Collection<?> c) { + return source.containsAll(c); + } + + public boolean equals(Object o) { + return source.equals(o); + } + + public CssProperty get(int index) { + return source.get(index); + } + + public int hashCode() { + return source.hashCode(); + } + + public int indexOf(Object o) { + return source.indexOf(o); + } + + public boolean isEmpty() { + return source.isEmpty(); + } + + public Iterator<CssProperty> iterator() { + return source.iterator(); + } + + public int lastIndexOf(Object o) { + return source.lastIndexOf(o); + } + + public ListIterator<CssProperty> listIterator() { + return source.listIterator(); + } + + public ListIterator<CssProperty> listIterator(int index) { + return source.listIterator(index); + } + + public CssProperty remove(int index) { + return source.remove(index); + } + + public boolean remove(Object o) { + return source.remove(o); + } + + public boolean removeAll(Collection<?> c) { + return source.removeAll(c); + } + + public boolean retainAll(Collection<?> c) { + return source.retainAll(c); + } + + public CssProperty set(int index, CssProperty element) { + if (!processProperty(element)) { + return source.set(index, element); + } else { + return source.remove(index); + } + } + + public int size() { + return source.size(); + } + + public List<CssProperty> subList(int fromIndex, int toIndex) { + return source.subList(fromIndex, toIndex); + } + + public Object[] toArray() { + return source.toArray(); + } + + public <T> T[] toArray(T[] a) { + return source.toArray(a); + } + } + + private String resourceFunction; + + @Override + public List<CssProperty> getProperties() { + return new SpritePropertyList(super.getProperties()); + } + + public String getResourceFunction() { + return resourceFunction; + } + + public void setResourceFunction(String resourceFunction) { + this.resourceFunction = resourceFunction; + } + + public void traverse(CssVisitor visitor, Context context) { + if (visitor.visit(this, context)) { + visitor.acceptWithInsertRemove(selectors); + visitor.acceptWithInsertRemove(getProperties()); + } + visitor.endVisit(this, context); + } + + private boolean processProperty(CssProperty property) { + if (IMAGE_PROPERTY_NAME.equals(property.getName())) { + setImageProperty(property.getValues()); + return true; + } + return false; + } + + private void setImageProperty(Value value) { + StringValue stringValue; + ListValue listValue; + + if ((stringValue = value.isStringValue()) != null) { + resourceFunction = stringValue.getValue(); + + // Allow the user to use both raw idents and quoted strings + if (resourceFunction.startsWith("\"")) { + resourceFunction = resourceFunction.substring(1, + resourceFunction.length() - 1); + } + + } else if ((listValue = value.isListValue()) != null) { + List<Value> values = listValue.getValues(); + if (values.size() == 1) { + setImageProperty(values.get(0)); + } + + } else { + throw new IllegalArgumentException("The " + IMAGE_PROPERTY_NAME + + " property of @sprite must have exactly one value"); + } + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssStylesheet.java b/user/src/com/google/gwt/resources/css/ast/CssStylesheet.java new file mode 100644 index 0000000..743d54e --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssStylesheet.java
@@ -0,0 +1,37 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import java.util.ArrayList; +import java.util.List; + +/** + * + */ +public class CssStylesheet extends CssNode implements HasNodes { + private List<CssNode> rules = new ArrayList<CssNode>(); + + public List<CssNode> getNodes() { + return rules; + } + + public void traverse(CssVisitor visitor, Context context) { + if (visitor.visit(this, context)) { + visitor.acceptWithInsertRemove(rules); + } + visitor.endVisit(this, context); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssUrl.java b/user/src/com/google/gwt/resources/css/ast/CssUrl.java new file mode 100644 index 0000000..17f175c --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssUrl.java
@@ -0,0 +1,47 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import com.google.gwt.resources.css.ast.CssProperty.IdentValue; +import com.google.gwt.resources.css.ast.CssProperty.Value; + +import java.util.Collections; +import java.util.List; + +/** + * A reference to a DataResource that results in a url expression being inserted + * into the generated CSS. + */ +public class CssUrl extends CssDef { + private final List<Value> values; + + public CssUrl(String key, String functionPath) { + super(key); + Value functionValue = new IdentValue(functionPath); + values = Collections.singletonList(functionValue); + } + + @Override + public List<Value> getValues() { + return values; + } + + @Override + public void traverse(CssVisitor visitor, Context context) { + visitor.visit(this, context); + visitor.endVisit(this, context); + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssVisitable.java b/user/src/com/google/gwt/resources/css/ast/CssVisitable.java new file mode 100644 index 0000000..335638d --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssVisitable.java
@@ -0,0 +1,23 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +/** + * Allows traversal of a CSS tree. + */ +public interface CssVisitable { + void traverse(CssVisitor visitor, Context context); +}
diff --git a/user/src/com/google/gwt/resources/css/ast/CssVisitor.java b/user/src/com/google/gwt/resources/css/ast/CssVisitor.java new file mode 100644 index 0000000..9c4edc9 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/CssVisitor.java
@@ -0,0 +1,182 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import java.util.List; + +/** + * The base class for visiting a CSS tree. + */ +public class CssVisitor { + protected static final Context UNMODIFIABLE_CONTEXT = new Context() { + + public boolean canInsert() { + return false; + } + + public boolean canRemove() { + return false; + } + + public void insertAfter(CssNode node) { + throw new UnsupportedOperationException(); + } + + public void insertBefore(CssNode node) { + throw new UnsupportedOperationException(); + } + + public void removeMe() { + throw new UnsupportedOperationException(); + } + + public void replaceMe(CssNode node) { + throw new UnsupportedOperationException(); + } + }; + + public final void accept(List<? extends CssNode> nodes) { + doAccept(nodes); + } + + public final <T extends CssNode> T accept(T node) { + return doAccept(node); + } + + public final void acceptWithInsertRemove(List<? extends CssNode> nodes) { + doAcceptWithInsertRemove(nodes); + } + + public void endVisit(CssDef x, Context ctx) { + } + + public void endVisit(CssEval x, Context ctx) { + } + + public void endVisit(CssIf x, Context ctx) { + } + + public void endVisit(CssMediaRule x, Context ctx) { + } + + public void endVisit(CssNoFlip x, Context ctx) { + } + + public void endVisit(CssPageRule x, Context ctx) { + } + + public void endVisit(CssProperty x, Context ctx) { + } + + public void endVisit(CssRule x, Context ctx) { + } + + public void endVisit(CssSelector x, Context ctx) { + } + + public void endVisit(CssSprite x, Context ctx) { + } + + public void endVisit(CssStylesheet x, Context ctx) { + } + + public void endVisit(CssUrl x, Context ctx) { + } + + public boolean visit(CssDef x, Context ctx) { + return true; + } + + public boolean visit(CssEval x, Context ctx) { + return true; + } + + public boolean visit(CssIf x, Context ctx) { + return true; + } + + public boolean visit(CssMediaRule x, Context ctx) { + return true; + } + + public boolean visit(CssNoFlip x, Context ctx) { + return true; + } + + public boolean visit(CssPageRule x, Context ctx) { + return true; + } + + public boolean visit(CssProperty x, Context ctx) { + return true; + } + + public boolean visit(CssRule x, Context ctx) { + return true; + } + + public boolean visit(CssSelector x, Context ctx) { + return true; + } + + public boolean visit(CssSprite x, Context ctx) { + return true; + } + + public boolean visit(CssStylesheet x, Context ctx) { + return true; + } + + public boolean visit(CssUrl x, Context ctx) { + return true; + } + + protected void doAccept(List<? extends CssNode> list) { + for (CssNode node : list) { + doTraverse(node, UNMODIFIABLE_CONTEXT); + } + } + + protected <T extends CssNode> T doAccept(T node) { + doTraverse(node, UNMODIFIABLE_CONTEXT); + return node; + } + + protected void doAcceptWithInsertRemove(List<? extends CssNode> list) { + for (CssNode node : list) { + doTraverse(node, UNMODIFIABLE_CONTEXT); + } + } + + protected final void doTraverse(CssNode node, Context ctx) { + try { + node.traverse(this, ctx); + } catch (Throwable e) { + throw translateException(node, e); + } + } + + private CssCompilerException translateException(CssNode node, Throwable e) { + CssCompilerException ex; + if (e instanceof CssCompilerException) { + ex = (CssCompilerException) e; + } else { + ex = new CssCompilerException("Unexpected error during visit.", e); + } + ex.addNode(node); + return ex; + } +}
diff --git a/user/src/com/google/gwt/resources/css/ast/HasNodes.java b/user/src/com/google/gwt/resources/css/ast/HasNodes.java new file mode 100644 index 0000000..28d1c41 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/HasNodes.java
@@ -0,0 +1,25 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import java.util.List; + +/** + * Indicates that the node contains other nodes. + */ +public interface HasNodes { + List<CssNode> getNodes(); +}
diff --git a/user/src/com/google/gwt/resources/css/ast/HasProperties.java b/user/src/com/google/gwt/resources/css/ast/HasProperties.java new file mode 100644 index 0000000..cb1eb47 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/HasProperties.java
@@ -0,0 +1,25 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import java.util.List; + +/** + * Something that has CSS properties. + */ +public interface HasProperties { + List<CssProperty> getProperties(); +}
diff --git a/user/src/com/google/gwt/resources/css/ast/HasSelectors.java b/user/src/com/google/gwt/resources/css/ast/HasSelectors.java new file mode 100644 index 0000000..bf2557f --- /dev/null +++ b/user/src/com/google/gwt/resources/css/ast/HasSelectors.java
@@ -0,0 +1,25 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.css.ast; + +import java.util.List; + +/** + * Something that has CSS selectors. + */ +public interface HasSelectors { + List<CssSelector> getSelectors(); +}
diff --git a/user/src/com/google/gwt/resources/css/package-info.java b/user/src/com/google/gwt/resources/css/package-info.java new file mode 100644 index 0000000..a930495 --- /dev/null +++ b/user/src/com/google/gwt/resources/css/package-info.java
@@ -0,0 +1,21 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ + +/** + * Support package for manipulating CSS resources. + */ +@com.google.gwt.util.PreventSpuriousRebuilds +package com.google.gwt.resources.css; \ No newline at end of file
diff --git a/user/src/com/google/gwt/resources/ext/ClientBundleFields.java b/user/src/com/google/gwt/resources/ext/ClientBundleFields.java new file mode 100644 index 0000000..205774e --- /dev/null +++ b/user/src/com/google/gwt/resources/ext/ClientBundleFields.java
@@ -0,0 +1,62 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.ext; + +import com.google.gwt.core.ext.typeinfo.JType; + +/** + * Allows ResourceGenerators to define fields within the implementation class + * for a bundle type. An instance of this interface will be provided via the + * {@link ResourceGenerator#createFields} method. + * <p> + * Because multiple, unrelated ResourceGenerators may be generating method + * implementations within a single bundle implementation, it is necessary to + * ensure that they do not attempt to declare multiple fields with the same + * name. The methods in this interface will provide a guaranteed-unique + * identifier to use when generating method implementations. + * <p> + * Multiple invocations of the {@link #define} method with the same inputs will + * result in different identifiers being produced. + */ +public interface ClientBundleFields { + /** + * Adds a field to the bundle. Equivalent to + * <code>defineField(type, name, null, true, false)</code>. + * + * @param type the declared type of the field + * @param name a Java identifier to be used as the basis for the name of the + * field + * @return the identifier that must be used to access the field + */ + String define(JType type, String name); + + /** + * Adds a field to the bundle. + * + * @param type the declared type of the field + * @param name a Java identifier to be used as the basis for the name of the + * field + * @param initializer a Java expression that will be used as the field's + * initializer, or <code>null</code> if no initialization expression + * is desired + * @param isStatic if <code>true</code> the field will be declared to be + * static + * @param isFinal if <code>true</code> the fields will be declared as final + * @return the identifier that must be used to access the field + */ + String define(JType type, String name, String initializer, boolean isStatic, + boolean isFinal); +}
diff --git a/user/src/com/google/gwt/resources/ext/ClientBundleRequirements.java b/user/src/com/google/gwt/resources/ext/ClientBundleRequirements.java new file mode 100644 index 0000000..caea394 --- /dev/null +++ b/user/src/com/google/gwt/resources/ext/ClientBundleRequirements.java
@@ -0,0 +1,41 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.ext; + +import com.google.gwt.core.ext.BadPropertyValueException; + +/** + * Allows ResourceGenerators to indicate how their generated resources may be + * affected by their execution environment. An instance of this type will be + * provided to the ResourceGenerator via the {@link ResourceGenerator#prepare} + * method. + */ +public interface ClientBundleRequirements { + /** + * Indicates that the ResourcePrototype implementation generated by a + * ResourceGenerator is sensitive to the value of the specified + * deferred-binding property. This method should be called when the behavior + * of the ResourcePrototype must differ between permutations of the compiled + * output. For example, some resource implementations may be sensitive to the + * <code>user.agent</code> deferred-binding property, and would call this + * method with the literal string <code>user.agent</code>. + * + * @param propertyName the name of the deferred-binding property + * @throws BadPropertyValueException if <code>propertyName</code> is not a + * valid deferred-binding property. + */ + void addPermutationAxis(String propertyName) throws BadPropertyValueException; +}
diff --git a/user/src/com/google/gwt/resources/ext/ResourceContext.java b/user/src/com/google/gwt/resources/ext/ResourceContext.java new file mode 100644 index 0000000..409dc31 --- /dev/null +++ b/user/src/com/google/gwt/resources/ext/ResourceContext.java
@@ -0,0 +1,105 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.ext; + +import com.google.gwt.core.ext.GeneratorContext; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JClassType; + +import java.net.URL; + +/** + * Context object for ResourceGenerators. An instance of this type will be + * provided by the resource generation framework to implementations of + * ResourceGenerator via {@link ResourceGenerator#init}. Because this interface + * is not intended to be implemented by end-users, the API provided by this + * interface may be extended in the future. + * <p> + * Depending on the optimizations made by the implementation of {@link #deploy}, + * the resulting URL may or may not be compatible with standard + * {@link com.google.gwt.http.client.RequestBuilder} / XMLHttpRequest security + * semantics. If the resource is intended to be used with XHR, the + * <code>xhrCompatible</code> paramater should be set to <code>true</code> when + * invoking {@link #deploy}. + * </p> + */ +public interface ResourceContext { + + /** + * Cause a specific collection of bytes to be available in the program's + * compiled output. The return value of this method is a Java expression which + * will evaluate to the location of the resource at runtime. The exact format + * should not be depended upon. + * + * @param suggestedFileName an unobfuscated filename to possibly use for the + * resource + * @param mimeType the MIME type of the data being provided + * @param data the bytes to add to the output + * @param xhrCompatible enforces compatibility with security restrictions if + * the resource is intended to be accessed via an XMLHttpRequest. + * @return a Java expression which will evaluate to the location of the + * provided resource at runtime. + */ + String deploy(String suggestedFileName, String mimeType, byte[] data, + boolean xhrCompatible) throws UnableToCompleteException; + + /** + * Cause a specific collection of bytes to be available in the program's + * compiled output. The return value of this method is a Java expression which + * will evaluate to the location of the resource at runtime. The exact format + * should not be depended upon. + * + * @param resource the resource to add to the compiled output + * @param xhrCompatible enforces compatibility with security restrictions if + * the resource is intended to be accessed via an XMLHttpRequest. + * @return a Java expression which will evaluate to the location of the + * provided resource at runtime. + */ + String deploy(URL resource, boolean xhrCompatible) + throws UnableToCompleteException; + + /** + * Return the interface type of the resource bundle being generated. + */ + JClassType getClientBundleType(); + + /** + * Return the GeneratorContext in which the overall resource generation + * framework is being run. Implementations of ResourceGenerator should prefer + * {@link #addToOutput} over {@link GeneratorContext#tryCreateResource} in + * order to take advantage of serving optimizations that can be performed by + * the bundle architecture. + */ + GeneratorContext getGeneratorContext(); + + /** + * Returns the simple source name of the implementation of the bundle being + * generated. This can be used during code-generation to refer to the instance + * of the bundle (e.g. via <code>SimpleSourceName.this</code>). + * + * @throws IllegalStateException if this method is called during + * {@link ResourceGenerator#init} or + * {@link ResourceGenerator#prepare} methods. + */ + String getImplementationSimpleSourceName() throws IllegalStateException; + + /** + * Indicates if the runtime context supports data: urls. When data URLs are + * supported by the context, aggregation of resource data into larger payloads + * is discouraged, as it offers reduced benefit to the application at runtime. + */ + boolean supportsDataUrls(); +}
diff --git a/user/src/com/google/gwt/resources/ext/ResourceGenerator.java b/user/src/com/google/gwt/resources/ext/ResourceGenerator.java new file mode 100644 index 0000000..2a61d56 --- /dev/null +++ b/user/src/com/google/gwt/resources/ext/ResourceGenerator.java
@@ -0,0 +1,107 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.ext; + +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JMethod; + +/** + * Encapsulates per-type resource generation logic. This type is used only by + * developers who wish to add additional resource types to the resource + * generation system. Implementations are paired with one or more interfaces + * derived from ResourcePrototype that have been annotated with an + * {@link ResourceGeneratorType} annotation. Instances of ResourceGenerator must + * support default-instantiation (i.e. via {@link Class#newInstance()}). + * <p> + * The methods on an instance of ResourceGenerator will be called in the + * following order by the resource generation system: + * <ol> + * <li>{@link #init}</li> + * <li> + * {@link #prepare} once for each method</li> + * <li>Based on the requirements specified by the ResourceGenerator, the + * framework may decide that no further action is required. If this is the case, + * the framework will immediately invoke {@link #finish}.</li> + * <li>{@link #createFields}</li> + * <li>{@link #createAssignment} once for each method</li> + * <li>{@link #finish}</li> + * </ol> + * <p> + * The methods {@link #prepare} and {@link #createAssignment} will be called + * only with those methods whose ResourcePrototype-derived type specifies the + * particular type of ResourceGenerator as the implementor. The relative order + * in which ResourceGenerators are invoked and the specific order in which the + * bundle's methods are presented is undefined. + * <p> + * Direct access to the contents of the generated bundle implementation is + * intentionally limited to prevent unrelated ResourceGenerators from + * potentially creating namespace conflicts or generating invalid Java source. + * + * @see ResourceGeneratorUtil + */ +public interface ResourceGenerator { + + /** + * Produce the right-hand-side of a Java assignment expression to provide the + * singleton instance object for a particular resource. + * <p> + * Example: + * + * <pre> + * new MySampleResource() { public Foo getFoo() { ... } } + * </pre> + */ + String createAssignment(TreeLogger logger, ResourceContext context, + JMethod method) throws UnableToCompleteException; + + /** + * The ResourceGenerator can create fields within the implementation of the + * bundle type. The Fields object passed into this method is used to declare, + * and possibly initialize, Java fields within the final implementation of the + * resource bundle type. + * <p> + * The Fields instance should not be retained beyond the lifetime of this + * method as operation on this object is not defined after the implementation + * of this method returns. + */ + void createFields(TreeLogger logger, ResourceContext context, + ClientBundleFields fields) throws UnableToCompleteException; + + /** + * Called at the end of the resource generation phase and can be used to + * perform cleanup. + */ + void finish(TreeLogger logger, ResourceContext context) + throws UnableToCompleteException; + + /** + * Initialize the ResourceGenerator with the generation context that will + * remain valid for the duration of the resource-generation phase. The logger + * instance should not be retained; use the per-method loggers instead. + */ + void init(TreeLogger logger, ResourceContext context) + throws UnableToCompleteException; + + /** + * Called once for each method the ResourceGenerator is expected to handle. + * This allows cross-resource state to be accumulated, such as for data + * aggregation. + */ + void prepare(TreeLogger logger, ResourceContext context, + ClientBundleRequirements requirements, JMethod method) + throws UnableToCompleteException; +} \ No newline at end of file
diff --git a/user/src/com/google/gwt/resources/ext/ResourceGeneratorType.java b/user/src/com/google/gwt/resources/ext/ResourceGeneratorType.java new file mode 100644 index 0000000..7489198 --- /dev/null +++ b/user/src/com/google/gwt/resources/ext/ResourceGeneratorType.java
@@ -0,0 +1,28 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.ext; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +/** + * Specifies the implementation of ResourceGenerator to use for a type of + * {@link com.google.gwt.resources.client.ResourcePrototype}. + */ +@Target(ElementType.TYPE) +public @interface ResourceGeneratorType { + Class<? extends ResourceGenerator> value(); +}
diff --git a/user/src/com/google/gwt/resources/ext/ResourceGeneratorUtil.java b/user/src/com/google/gwt/resources/ext/ResourceGeneratorUtil.java new file mode 100644 index 0000000..9b4e4a4 --- /dev/null +++ b/user/src/com/google/gwt/resources/ext/ResourceGeneratorUtil.java
@@ -0,0 +1,317 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.ext; + +import com.google.gwt.core.ext.BadPropertyValueException; +import com.google.gwt.core.ext.PropertyOracle; +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JMethod; +import com.google.gwt.core.ext.typeinfo.JPackage; +import com.google.gwt.resources.client.ClientBundle.Source; + +import java.lang.annotation.Annotation; +import java.net.URL; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * Utility methods for building ResourceGenerators. + */ +public final class ResourceGeneratorUtil { + + /** + * These are type names from previous APIs or from APIs with similar + * functionality that might be confusing. + * + * @see #checkForDeprecatedAnnotations + */ + private static final String[] DEPRECATED_ANNOTATION_NAMES = { + "com.google.gwt.libideas.resources.client.ImmutableResourceBundle$Resource", + "com.google.gwt.user.client.ui.ImageBundle$Resource"}; + + private static final List<Class<? extends Annotation>> DEPRECATED_ANNOTATION_CLASSES; + + static { + List<Class<? extends Annotation>> classes = new ArrayList<Class<? extends Annotation>>( + DEPRECATED_ANNOTATION_NAMES.length); + + for (String name : DEPRECATED_ANNOTATION_NAMES) { + try { + Class<?> maybeAnnotation = Class.forName(name, false, + ResourceGeneratorUtil.class.getClassLoader()); + + // Possibly throws ClassCastException + Class<? extends Annotation> annotationClass = maybeAnnotation.asSubclass(Annotation.class); + + classes.add(annotationClass); + + } catch (ClassCastException e) { + // If it's not an Annotation type, we don't care about it + } catch (ClassNotFoundException e) { + // This is OK; the annotation doesn't exist. + } + } + + if (classes.isEmpty()) { + DEPRECATED_ANNOTATION_CLASSES = Collections.emptyList(); + } else { + DEPRECATED_ANNOTATION_CLASSES = Collections.unmodifiableList(classes); + } + } + + /** + * Return the base filename of a resource. The behavior is similar to the unix + * command <code>basename</code>. + * + * @param resource the URL of the resource + * @return the final name segment of the resource + */ + public static String baseName(URL resource) { + String path = resource.getPath(); + return path.substring(path.lastIndexOf('/') + 1); + } + + /** + * Find all resources referenced by a method in a bundle. The method's + * {@link Source} annotation will be examined and the specified locations will + * be expanded into URLs by which they may be accessed on the local system. + * <p> + * This method is sensitive to the <code>locale</code> deferred-binding + * property and will attempt to use a best-match lookup by removing locale + * components. + * + * @param logger a TreeLogger that will be used to report errors or warnings + * @param context the ResourceContext in which the ResourceGenerator is + * operating + * @param classLoader the ClassLoader to use when locating resources + * @param method the method to examine for {@link Source} annotations + * @param defaultSuffixes if the supplied method does not have any + * {@link Source} annotations, act as though a Source annotation was + * specified, using the name of the method and each of supplied + * extensions in the order in which they are specified + * @return URLs for each {@link Source} annotation value defined on the + * method, or an empty array if no sources could be found. + * @throws UnableToCompleteException if ore or more of the sources could not + * be found. The error will be reported via the <code>logger</code> + * provided to this method + */ + public static URL[] findResources(TreeLogger logger, ClassLoader classLoader, + ResourceContext context, JMethod method, String[] defaultSuffixes) + throws UnableToCompleteException { + logger = logger.branch(TreeLogger.DEBUG, "Finding resources"); + + String locale; + try { + PropertyOracle oracle = context.getGeneratorContext().getPropertyOracle(); + locale = oracle.getPropertyValue(logger, "locale"); + } catch (BadPropertyValueException e) { + locale = null; + } + + checkForDeprecatedAnnotations(logger, method); + + Source resourceAnnotation = method.getAnnotation(Source.class); + if (resourceAnnotation == null) { + if (defaultSuffixes != null) { + for (String extension : defaultSuffixes) { + logger.log(TreeLogger.SPAM, "Trying default extension " + extension); + URL resourceUrl = tryFindResource(classLoader, + getPathRelativeToPackage(method.getEnclosingType().getPackage(), + method.getName() + extension), locale); + + if (resourceUrl != null) { + return new URL[] {resourceUrl}; + } + } + } + logger.log(TreeLogger.SPAM, + "No annotation and no hits with default extensions"); + return new URL[0]; + } + + String[] resources = resourceAnnotation.value(); + + URL[] toReturn = new URL[resources.length]; + + boolean error = false; + int tagIndex = 0; + for (String resource : resources) { + // Try to find the resource relative to the package. + URL resourceURL = tryFindResource(classLoader, getPathRelativeToPackage( + method.getEnclosingType().getPackage(), resource), locale); + + // If we didn't find the resource relative to the package, assume it is + // absolute. + if (resourceURL == null) { + resourceURL = tryFindResource(classLoader, resource, locale); + } + + if (resourceURL == null) { + logger.log(TreeLogger.ERROR, "Resource " + resource + + " not found on classpath. Is the name specified as " + + "Class.getResource() would expect?"); + error = true; + } + + toReturn[tagIndex++] = resourceURL; + } + + if (error) { + throw new UnableToCompleteException(); + } + + return toReturn; + } + + /** + * Find all resources referenced by a method in a bundle. The method's + * {@link Source} annotation will be examined and the specified locations will + * be expanded into URLs by which they may be accessed on the local system. + * <p> + * This method is sensitive to the <code>locale</code> deferred-binding + * property and will attempt to use a best-match lookup by removing locale + * components. + * <p> + * The current Thread's context ClassLoader will be used to resolve resource + * locations. If it is necessary to alter the manner in which resources are + * resolved, use the overload that accepts an arbitrary ClassLoader. + * + * @param logger a TreeLogger that will be used to report errors or warnings + * @param context the ResourceContext in which the ResourceGenerator is + * operating + * @param method the method to examine for {@link Source} annotations + * @return URLs for each {@link Source} annotation value defined on the + * method, or an empty array if no sources could be found. + * @throws UnableToCompleteException if ore or more of the sources could not + * be found. The error will be reported via the <code>logger</code> + * provided to this method + */ + public static URL[] findResources(TreeLogger logger, ResourceContext context, + JMethod method) throws UnableToCompleteException { + return findResources(logger, context, method, new String[0]); + } + + /** + * Find all resources referenced by a method in a bundle. The method's + * {@link Source} annotation will be examined and the specified locations will + * be expanded into URLs by which they may be accessed on the local system. + * <p> + * This method is sensitive to the <code>locale</code> deferred-binding + * property and will attempt to use a best-match lookup by removing locale + * components. + * <p> + * The current Thread's context ClassLoader will be used to resolve resource + * locations. If it is necessary to alter the manner in which resources are + * resolved, use the overload that accepts an arbitrary ClassLoader. + * + * @param logger a TreeLogger that will be used to report errors or warnings + * @param context the ResourceContext in which the ResourceGenerator is + * operating + * @param method the method to examine for {@link Source} annotations + * @param defaultSuffixes if the supplied method does not have any + * {@link Source} annotations, act as though a Source annotation was + * specified, using the name of the method and each of supplied + * extensions in the order in which they are specified + * @return URLs for each {@link Source} annotation value defined on the + * method, or an empty array if no sources could be found. + * @throws UnableToCompleteException if ore or more of the sources could not + * be found. The error will be reported via the <code>logger</code> + * provided to this method + */ + public static URL[] findResources(TreeLogger logger, ResourceContext context, + JMethod method, String[] defaultSuffixes) + throws UnableToCompleteException { + return findResources(logger, + Thread.currentThread().getContextClassLoader(), context, method, + defaultSuffixes); + } + + /** + * We want to warn the user about any annotations from ImageBundle or the old + * incubator code. + */ + private static void checkForDeprecatedAnnotations(TreeLogger logger, + JMethod method) { + + for (Class<? extends Annotation> annotationClass : DEPRECATED_ANNOTATION_CLASSES) { + if (method.isAnnotationPresent(annotationClass)) { + logger.log(TreeLogger.WARN, "Deprecated annotation used; expecting " + + Source.class.getCanonicalName() + " but found " + + annotationClass.getName() + " instead. It is likely " + + "that undesired operation will occur."); + } + } + } + + /** + * Converts a package relative path into an absolute path. + * + * @param pkg the package + * @param path a path relative to the package + * @return an absolute path + */ + private static String getPathRelativeToPackage(JPackage pkg, String path) { + return pkg.getName().replace('.', '/') + '/' + path; + } + + /** + * This performs the locale lookup function for a given resource name. + * + * @param classLoader the ClassLoader to use to load the resources + * @param resourceName the string name of the desired resource + * @param locale the locale of the current rebind permutation + * @return a URL by which the resource can be loaded, <code>null</code> if one + * cannot be found + */ + private static URL tryFindResource(ClassLoader classLoader, + String resourceName, String locale) { + URL toReturn = null; + + // Look for locale-specific variants of individual resources + if (locale != null) { + // Convert language_country_variant to independent pieces + String[] localeSegments = locale.split("_"); + int lastDot = resourceName.lastIndexOf("."); + String prefix = lastDot == -1 ? resourceName : resourceName.substring(0, + lastDot); + String extension = lastDot == -1 ? "" : resourceName.substring(lastDot); + + for (int i = localeSegments.length - 1; i >= -1; i--) { + String localeInsert = ""; + for (int j = 0; j <= i; j++) { + localeInsert += "_" + localeSegments[j]; + } + + toReturn = classLoader.getResource(prefix + localeInsert + extension); + if (toReturn != null) { + break; + } + } + } else { + toReturn = classLoader.getResource(resourceName); + } + + return toReturn; + } + + /** + * Utility class. + */ + private ResourceGeneratorUtil() { + } +}
diff --git a/user/src/com/google/gwt/resources/rebind/context/AbstractClientBundleGenerator.java b/user/src/com/google/gwt/resources/rebind/context/AbstractClientBundleGenerator.java new file mode 100644 index 0000000..65d51cd --- /dev/null +++ b/user/src/com/google/gwt/resources/rebind/context/AbstractClientBundleGenerator.java
@@ -0,0 +1,587 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rebind.context; + +import com.google.gwt.core.client.GWT; +import com.google.gwt.core.ext.BadPropertyValueException; +import com.google.gwt.core.ext.Generator; +import com.google.gwt.core.ext.GeneratorContext; +import com.google.gwt.core.ext.PropertyOracle; +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JClassType; +import com.google.gwt.core.ext.typeinfo.JMethod; +import com.google.gwt.core.ext.typeinfo.JType; +import com.google.gwt.core.ext.typeinfo.TypeOracle; +import com.google.gwt.dev.generator.NameFactory; +import com.google.gwt.dev.util.Util; +import com.google.gwt.resources.client.ClientBundle; +import com.google.gwt.resources.client.ClientBundleWithLookup; +import com.google.gwt.resources.client.ResourcePrototype; +import com.google.gwt.resources.ext.ClientBundleFields; +import com.google.gwt.resources.ext.ClientBundleRequirements; +import com.google.gwt.resources.ext.ResourceContext; +import com.google.gwt.resources.ext.ResourceGenerator; +import com.google.gwt.resources.ext.ResourceGeneratorType; +import com.google.gwt.resources.rg.BundleResourceGenerator; +import com.google.gwt.user.rebind.ClassSourceFileComposerFactory; +import com.google.gwt.user.rebind.SourceWriter; + +import java.io.PrintWriter; +import java.io.StringWriter; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.IdentityHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * The base class for creating new ClientBundle implementations. + */ +public abstract class AbstractClientBundleGenerator extends Generator { + + /** + * An implementation of FieldAccumulator that immediately composes its output + * into a StringWriter. + */ + private static class FieldsImpl implements ClientBundleFields { + private final NameFactory factory = new NameFactory(); + private final StringWriter buffer = new StringWriter(); + private final PrintWriter pw = new PrintWriter(buffer); + + public void addName(String name) { + factory.addName(name); + } + + public String define(JType type, String name) { + return define(type, name, null, true, false); + } + + public String define(JType type, String name, String initializer, + boolean isStatic, boolean isFinal) { + + assert Util.isValidJavaIdent(name) : name + + " is not a valid Java identifier"; + + String ident = factory.createName(name); + + pw.print("private "); + + if (isStatic) { + pw.print("static "); + } + + if (isFinal) { + pw.print("final "); + } + + pw.print(type.getQualifiedSourceName()); + pw.print(" "); + pw.print(ident); + + if (initializer != null) { + pw.print(" = "); + pw.print(initializer); + } + + pw.println(";"); + + return ident; + } + + public String toString() { + pw.flush(); + return buffer.getBuffer().toString(); + } + } + + private static class RequirementsImpl implements ClientBundleRequirements { + private final Set<String> axes = new HashSet<String>(); + private final PropertyOracle oracle; + + public RequirementsImpl(PropertyOracle oracle) { + this.oracle = oracle; + } + + public void addPermutationAxis(String propertyName) + throws BadPropertyValueException { + oracle.getPropertyValue(TreeLogger.NULL, propertyName); + axes.add(propertyName); + } + } + + public final String generate(TreeLogger logger, + GeneratorContext generatorContext, String typeName) + throws UnableToCompleteException { + + // The TypeOracle knows about all types in the type system + TypeOracle typeOracle = generatorContext.getTypeOracle(); + + // Get a reference to the type that the generator should implement + JClassType sourceType = typeOracle.findType(typeName); + + // Ensure that the requested type exists + if (sourceType == null) { + logger.log(TreeLogger.ERROR, "Could not find requested typeName"); + throw new UnableToCompleteException(); + } else if (sourceType.isInterface() == null) { + // The incoming type wasn't a plain interface, we don't support + // abstract base classes + logger.log(TreeLogger.ERROR, sourceType.getQualifiedSourceName() + + " is not an interface.", null); + throw new UnableToCompleteException(); + } + + /* + * This associates the methods to implement with the ResourceGenerator class + * that will generate the implementations of those methods. + */ + Map<Class<? extends ResourceGenerator>, List<JMethod>> taskList = createTaskList( + logger, typeOracle, sourceType); + + /* + * Additional objects that hold state during the generation process. + */ + AbstractResourceContext resourceContext = createResourceContext(logger, + generatorContext, sourceType); + FieldsImpl fields = new FieldsImpl(); + RequirementsImpl requirements = new RequirementsImpl( + generatorContext.getPropertyOracle()); + + /* + * Initialize the ResourceGenerators and prepare them for subsequent code + * generation. + */ + Map<ResourceGenerator, List<JMethod>> generators = initAndPrepare(logger, + taskList, resourceContext, requirements); + + /* + * Now that the ResourceGenerators have been initialized and prepared, we + * can compute the actual name of the implementation class in order to + * ensure that we use a distinct name between permutations. + */ + String generatedSimpleSourceName = generateSimpleSourceName(logger, + resourceContext, requirements); + + // Begin writing the generated source. + ClassSourceFileComposerFactory f = new ClassSourceFileComposerFactory( + sourceType.getPackage().getName(), generatedSimpleSourceName); + + // The generated class needs to be able to determine the module base URL + f.addImport(GWT.class.getName()); + + // Used by the map methods + f.addImport(ResourcePrototype.class.getName()); + + // The whole point of this exercise + f.addImplementedInterface(sourceType.getQualifiedSourceName()); + + String createdClassName = f.getCreatedClassName(); + + // All source gets written through this Writer + PrintWriter out = generatorContext.tryCreate(logger, + sourceType.getPackage().getName(), generatedSimpleSourceName); + + // If an implementation already exists, we don't need to do any work + if (out != null) { + SourceWriter sw = f.createSourceWriter(generatorContext, out); + + // Set the now-calculated simple source name + resourceContext.setSimpleSourceName(generatedSimpleSourceName); + + // Write the generated code to disk + createFieldsAndAssignments(logger, sw, generators, resourceContext, + fields); + + // Print the accumulated field definitions + sw.println(fields.toString()); + + /* + * The map-accessor methods use JSNI and need a fully-qualified class + * name, but should not include any sub-bundles. + */ + taskList.remove(BundleResourceGenerator.class); + writeMapMethods(logger, createdClassName, sw, taskList); + + sw.commit(logger); + } + + finish(logger, resourceContext, generators.keySet()); + + // Return the name of the concrete class + return createdClassName; + } + + /** + * Create the ResourceContext object that will be used by + * {@link ResourceGenerator} subclasses. This is the primary way to implement + * custom logic in the resource generation pass. + */ + protected abstract AbstractResourceContext createResourceContext( + TreeLogger logger, GeneratorContext context, JClassType resourceBundleType); + + /** + * Create fields and assignments for a single ResourceGenerator. + */ + private boolean createFieldsAndAssignments(TreeLogger logger, + ResourceContext resourceContext, ResourceGenerator rg, + List<JMethod> generatorMethods, SourceWriter sw, ClientBundleFields fields) { + + // Defer failure until this phase has ended + boolean fail = false; + + // Write all field values + try { + rg.createFields(logger.branch(TreeLogger.DEBUG, "Creating fields"), + resourceContext, fields); + } catch (UnableToCompleteException e) { + return false; + } + + // Create the instance variables in the IRB subclass by calling + // writeAssignment() on the ResourceGenerator + for (JMethod m : generatorMethods) { + String rhs; + + try { + rhs = rg.createAssignment(logger.branch(TreeLogger.DEBUG, + "Creating assignment for " + m.getName()), resourceContext, m); + } catch (UnableToCompleteException e) { + fail = true; + continue; + } + + String ident = fields.define(m.getReturnType().isClassOrInterface(), + m.getName(), null, true, false); + + // Strip off all but the access modifiers + sw.print(m.getReadableDeclaration(false, true, true, true, true)); + sw.println(" {"); + sw.indent(); + sw.println("if (" + ident + " == null) {"); + sw.indent(); + sw.println(ident + " = " + rhs + ";"); + sw.outdent(); + sw.println("}"); + sw.println("return " + ident + ";"); + sw.outdent(); + sw.println("}"); + } + + if (fail) { + return false; + } + + return true; + } + + /** + * Create fields and assignments for multiple ResourceGenerators. + */ + private void createFieldsAndAssignments(TreeLogger logger, SourceWriter sw, + Map<ResourceGenerator, List<JMethod>> generators, + ResourceContext resourceContext, ClientBundleFields fields) + throws UnableToCompleteException { + // Try to provide as many errors as possible before failing. + boolean success = true; + + // Run the ResourceGenerators to generate implementations of the methods + for (Map.Entry<ResourceGenerator, List<JMethod>> entry : generators.entrySet()) { + + success &= createFieldsAndAssignments(logger, resourceContext, + entry.getKey(), entry.getValue(), sw, fields); + } + + if (!success) { + throw new UnableToCompleteException(); + } + } + + /** + * Given a ClientBundle subtype, compute which ResourceGenerators should + * implement which methods. + */ + private Map<Class<? extends ResourceGenerator>, List<JMethod>> createTaskList( + TreeLogger logger, TypeOracle typeOracle, JClassType sourceType) + throws UnableToCompleteException { + + Map<Class<? extends ResourceGenerator>, List<JMethod>> toReturn = new HashMap<Class<? extends ResourceGenerator>, List<JMethod>>(); + + JClassType bundleType = typeOracle.findType(ClientBundle.class.getName()); + assert bundleType != null; + + JClassType bundleWithLookupType = typeOracle.findType(ClientBundleWithLookup.class.getName()); + assert bundleWithLookupType != null; + + JClassType resourcePrototypeType = typeOracle.findType(ResourcePrototype.class.getName()); + assert resourcePrototypeType != null; + + // Accumulate as many errors as possible before failing + boolean throwException = false; + + // Using overridable methods allows composition of interface types + for (JMethod m : sourceType.getOverridableMethods()) { + JClassType returnType = m.getReturnType().isClassOrInterface(); + + if (m.getEnclosingType().equals(bundleType) + || m.getEnclosingType().equals(bundleWithLookupType)) { + // Methods that we must generate, but that are not resources + continue; + + } else if (!m.isAbstract()) { + // Covers the case of an abstract class base type + continue; + + } else if (returnType == null + || !(returnType.isAssignableTo(resourcePrototypeType) || returnType.isAssignableTo(bundleType))) { + // Primitives and random other abstract methods + logger.log(TreeLogger.ERROR, "Unable to implement " + m.getName() + + " because it does not derive from " + + resourcePrototypeType.getQualifiedSourceName() + " or " + + bundleType.getQualifiedSourceName()); + throwException = true; + continue; + } + + try { + Class<? extends ResourceGenerator> clazz = findResourceGenerator( + logger, typeOracle, m); + List<JMethod> generatorMethods; + if (toReturn.containsKey(clazz)) { + generatorMethods = toReturn.get(clazz); + } else { + generatorMethods = new ArrayList<JMethod>(); + toReturn.put(clazz, generatorMethods); + } + + generatorMethods.add(m); + } catch (UnableToCompleteException e) { + throwException = true; + } + } + + if (throwException) { + throw new UnableToCompleteException(); + } + + return toReturn; + } + + /** + * Given a JMethod, find the a ResourceGenerator class that will be able to + * provide an implementation of the method. + */ + private Class<? extends ResourceGenerator> findResourceGenerator( + TreeLogger logger, TypeOracle typeOracle, JMethod method) + throws UnableToCompleteException { + + JClassType resourceType = method.getReturnType().isClassOrInterface(); + assert resourceType != null; + + List<JClassType> searchTypes = new ArrayList<JClassType>(); + searchTypes.add(resourceType); + + ResourceGeneratorType generatorType = null; + + while (!searchTypes.isEmpty()) { + JClassType current = searchTypes.remove(0); + generatorType = current.getAnnotation(ResourceGeneratorType.class); + if (generatorType != null) { + break; + } + + if (current.getSuperclass() != null) { + searchTypes.add(current.getSuperclass()); + } + + for (JClassType t : current.getImplementedInterfaces()) { + searchTypes.add(t); + } + } + + if (generatorType == null) { + logger.log(TreeLogger.ERROR, "No @" + + ResourceGeneratorType.class.getName() + + " was specifed for resource type " + + resourceType.getQualifiedSourceName() + " or its supertypes"); + throw new UnableToCompleteException(); + } + + return generatorType.value(); + } + + /** + * Call finish() on several ResourceGenerators. + */ + private void finish(TreeLogger logger, ResourceContext context, + Collection<ResourceGenerator> generators) + throws UnableToCompleteException { + boolean fail = false; + // Finalize the ResourceGenerator + for (ResourceGenerator rg : generators) { + try { + rg.finish( + logger.branch(TreeLogger.DEBUG, "Finishing ResourceGenerator"), + context); + } catch (UnableToCompleteException e) { + fail = true; + } + } + if (fail) { + throw new UnableToCompleteException(); + } + } + + /** + * Given a user-defined type name, determine the type name for the generated + * class based on accumulated requirements. + */ + private String generateSimpleSourceName(TreeLogger logger, + ResourceContext context, RequirementsImpl requirements) + throws UnableToCompleteException { + StringBuilder toReturn = new StringBuilder( + context.getClientBundleType().getQualifiedSourceName().replaceAll( + "[.$]", "_")); + Set<String> permutationAxes = new HashSet<String>(requirements.axes); + permutationAxes.add("locale"); + + try { + PropertyOracle oracle = context.getGeneratorContext().getPropertyOracle(); + for (String property : permutationAxes) { + String value = oracle.getPropertyValue(logger, property); + toReturn.append("_" + value); + } + } catch (BadPropertyValueException e) { + } + + toReturn.append("_" + getClass().getSimpleName()); + + return toReturn.toString(); + } + + private Map<ResourceGenerator, List<JMethod>> initAndPrepare( + TreeLogger logger, + Map<Class<? extends ResourceGenerator>, List<JMethod>> taskList, + ResourceContext resourceContext, ClientBundleRequirements requirements) + throws UnableToCompleteException { + // Try to provide as many errors as possible before failing. + boolean success = true; + Map<ResourceGenerator, List<JMethod>> toReturn = new IdentityHashMap<ResourceGenerator, List<JMethod>>(); + + // Run the ResourceGenerators to generate implementations of the methods + for (Map.Entry<Class<? extends ResourceGenerator>, List<JMethod>> entry : taskList.entrySet()) { + + ResourceGenerator rg = instantiateResourceGenerator(logger, + entry.getKey()); + toReturn.put(rg, entry.getValue()); + + success &= initAndPrepare(logger, resourceContext, rg, entry.getValue(), + requirements); + } + + if (!success) { + throw new UnableToCompleteException(); + } + + return toReturn; + } + + private boolean initAndPrepare(TreeLogger logger, + ResourceContext resourceContext, ResourceGenerator rg, + List<JMethod> generatorMethods, ClientBundleRequirements requirements) { + try { + rg.init( + logger.branch(TreeLogger.DEBUG, "Initializing ResourceGenerator"), + resourceContext); + } catch (UnableToCompleteException e) { + return false; + } + + boolean fail = false; + + // Prepare the ResourceGenerator by telling it all methods that it is + // expected to produce. + for (JMethod m : generatorMethods) { + try { + rg.prepare(logger.branch(TreeLogger.DEBUG, "Preparing method " + + m.getName()), resourceContext, requirements, m); + } catch (UnableToCompleteException e) { + fail = true; + } + } + + return !fail; + } + + /** + * Utility method to construct a ResourceGenerator that logs errors. + */ + private <T extends ResourceGenerator> T instantiateResourceGenerator( + TreeLogger logger, Class<T> generatorClass) + throws UnableToCompleteException { + try { + return generatorClass.newInstance(); + } catch (InstantiationException e) { + logger.log(TreeLogger.ERROR, "Unable to initialize ResourceGenerator", e); + } catch (IllegalAccessException e) { + logger.log(TreeLogger.ERROR, "Unable to instantiate ResourceGenerator. " + + "Does it have a public default constructor?", e); + } + throw new UnableToCompleteException(); + } + + private void writeMapMethods(TreeLogger logger, String createdClassName, + SourceWriter sw, + Map<Class<? extends ResourceGenerator>, List<JMethod>> taskList) + throws UnableToCompleteException { + + // Complete the IRB contract + sw.println("public ResourcePrototype[] getResources() {"); + sw.indent(); + sw.println("return new ResourcePrototype[] {"); + sw.indent(); + for (List<JMethod> methods : taskList.values()) { + for (JMethod m : methods) { + sw.println(m.getName() + "(), "); + } + } + sw.outdent(); + sw.println("};"); + sw.outdent(); + sw.println("}"); + + // Use a switch statement as a fast map + sw.println("public native ResourcePrototype " + + "getResource(String name) /*-{"); + sw.indent(); + sw.println("switch (name) {"); + sw.indent(); + for (List<JMethod> list : taskList.values()) { + for (JMethod m : list) { + sw.println("case '" + m.getName() + "': return this.@" + + createdClassName + "::" + (m.getName() + "()()") + ";"); + } + } + sw.outdent(); + sw.println("}"); + sw.println("return null;"); + sw.outdent(); + sw.println("}-*/;"); + } +}
diff --git a/user/src/com/google/gwt/resources/rebind/context/AbstractResourceContext.java b/user/src/com/google/gwt/resources/rebind/context/AbstractResourceContext.java new file mode 100644 index 0000000..9e4e549 --- /dev/null +++ b/user/src/com/google/gwt/resources/rebind/context/AbstractResourceContext.java
@@ -0,0 +1,62 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rebind.context; + +import com.google.gwt.core.ext.GeneratorContext; +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.typeinfo.JClassType; +import com.google.gwt.resources.ext.ResourceContext; + +/** + * Defines base methods for ResourceContext implementations. + */ +public abstract class AbstractResourceContext implements ResourceContext { + private final TreeLogger logger; + private final GeneratorContext context; + private final JClassType resourceBundleType; + private String simpleSourceName; + + protected AbstractResourceContext(TreeLogger logger, + GeneratorContext context, JClassType resourceBundleType) { + this.logger = logger; + this.context = context; + this.resourceBundleType = resourceBundleType; + } + + public JClassType getClientBundleType() { + return resourceBundleType; + } + + public GeneratorContext getGeneratorContext() { + return context; + } + + public String getImplementationSimpleSourceName() { + if (simpleSourceName == null) { + throw new IllegalStateException( + "Simple source name has not yet been set."); + } + return simpleSourceName; + } + + protected TreeLogger getLogger() { + return logger; + } + + void setSimpleSourceName(String name) { + simpleSourceName = name; + } +}
diff --git a/user/src/com/google/gwt/resources/rebind/context/InlineClientBundleGenerator.java b/user/src/com/google/gwt/resources/rebind/context/InlineClientBundleGenerator.java new file mode 100644 index 0000000..ecbd37d --- /dev/null +++ b/user/src/com/google/gwt/resources/rebind/context/InlineClientBundleGenerator.java
@@ -0,0 +1,36 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rebind.context; + +import com.google.gwt.core.ext.GeneratorContext; +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.typeinfo.JClassType; + +/** + * This is a refinement that will use data urls for browsers that support them. + * Only files whose size are smaller than MAX_INLINE_SIZE will be inlined. + * Larger files will use the standard CacheBundle behavior. + * + * @see "RFC 2397" + */ +public final class InlineClientBundleGenerator extends + AbstractClientBundleGenerator { + protected AbstractResourceContext createResourceContext(TreeLogger logger, + GeneratorContext context, JClassType resourceBundleType) { + return new InlineResourceContext(logger.branch(TreeLogger.DEBUG, + "Using inline resources", null), context, resourceBundleType); + } +}
diff --git a/user/src/com/google/gwt/resources/rebind/context/InlineResourceContext.java b/user/src/com/google/gwt/resources/rebind/context/InlineResourceContext.java new file mode 100644 index 0000000..53aef65 --- /dev/null +++ b/user/src/com/google/gwt/resources/rebind/context/InlineResourceContext.java
@@ -0,0 +1,61 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rebind.context; + +import com.google.gwt.core.ext.GeneratorContext; +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JClassType; + +class InlineResourceContext extends StaticResourceContext { + /** + * The largest file size that will be inlined. Note that this value is taken + * before any encodings are applied. + */ + // The JLS specifies a maximum size for any string to be 2^16 characters, so + // we'll leave some padding. Assuming a Base64 encoding, it is true that + // (2 ^ 15) * 4/3 < 2 ^ 16, so we can safely inline files up to 32k. + private static final int MAX_INLINE_SIZE = 2 << 15; + + InlineResourceContext(TreeLogger logger, GeneratorContext context, + JClassType resourceBundleType) { + super(logger, context, resourceBundleType); + } + + @Override + public String deploy(String suggestedFileName, String mimeType, byte[] data, + boolean xhrCompatible) throws UnableToCompleteException { + TreeLogger logger = getLogger(); + + // data: URLs are not compatible with XHRs on FF and Safari browsers + if ((!xhrCompatible) && (data.length < MAX_INLINE_SIZE)) { + logger.log(TreeLogger.DEBUG, "Inlining", null); + + // This is bad, but I am lazy and don't want to write _another_ encoder + sun.misc.BASE64Encoder enc = new sun.misc.BASE64Encoder(); + String base64Contents = enc.encode(data).replaceAll("\\s+", ""); + + return "\"data:" + mimeType + ";base64," + base64Contents + "\""; + } else { + return super.deploy(suggestedFileName, mimeType, data, true); + } + } + + @Override + public boolean supportsDataUrls() { + return true; + } +} \ No newline at end of file
diff --git a/user/src/com/google/gwt/resources/rebind/context/StaticClientBundleGenerator.java b/user/src/com/google/gwt/resources/rebind/context/StaticClientBundleGenerator.java new file mode 100644 index 0000000..44f6534 --- /dev/null +++ b/user/src/com/google/gwt/resources/rebind/context/StaticClientBundleGenerator.java
@@ -0,0 +1,34 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rebind.context; + +import com.google.gwt.core.ext.GeneratorContext; +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.typeinfo.JClassType; + +/** + * Copies selected files into module output with strong names and generates the + * ClientBundle mappings. + */ +public final class StaticClientBundleGenerator extends + AbstractClientBundleGenerator { + + protected AbstractResourceContext createResourceContext(TreeLogger logger, + GeneratorContext context, JClassType resourceBundleType) { + return new StaticResourceContext(logger.branch(TreeLogger.DEBUG, + "Using static resources", null), context, resourceBundleType); + } +}
diff --git a/user/src/com/google/gwt/resources/rebind/context/StaticResourceContext.java b/user/src/com/google/gwt/resources/rebind/context/StaticResourceContext.java new file mode 100644 index 0000000..a4beb90 --- /dev/null +++ b/user/src/com/google/gwt/resources/rebind/context/StaticResourceContext.java
@@ -0,0 +1,123 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rebind.context; + +import com.google.gwt.core.ext.BadPropertyValueException; +import com.google.gwt.core.ext.GeneratorContext; +import com.google.gwt.core.ext.PropertyOracle; +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JClassType; +import com.google.gwt.dev.util.Util; +import com.google.gwt.resources.ext.ResourceGeneratorUtil; + +import java.io.IOException; +import java.io.OutputStream; +import java.net.URL; + +class StaticResourceContext extends AbstractResourceContext { + /** + * The name of a deferred binding property that determines whether or not this + * generator will rename the incoming resources to strong file names. + */ + static final String ENABLE_RENAMING = "ClientBundle.enableRenaming"; + + StaticResourceContext(TreeLogger logger, GeneratorContext context, + JClassType resourceBundleType) { + super(logger, context, resourceBundleType); + } + + public String deploy(String suggestedFileName, String mimeType, byte[] data, + boolean xhrCompatible) throws UnableToCompleteException { + TreeLogger logger = getLogger(); + GeneratorContext context = getGeneratorContext(); + PropertyOracle propertyOracle = context.getPropertyOracle(); + + // See if filename obfuscation should be enabled + String enableRenaming = null; + try { + enableRenaming = propertyOracle.getPropertyValue(logger, ENABLE_RENAMING); + } catch (BadPropertyValueException e) { + logger.log(TreeLogger.ERROR, "Bad value for " + ENABLE_RENAMING, e); + throw new UnableToCompleteException(); + } + + // Determine the final filename for the resource's file + String outputName; + if (Boolean.parseBoolean(enableRenaming)) { + String strongName = Util.computeStrongName(data); + + // Determine the extension of the original file + String extension; + int lastIdx = suggestedFileName.lastIndexOf('.'); + if (lastIdx != -1) { + extension = suggestedFileName.substring(lastIdx + 1); + } else { + extension = "noext"; + } + + // The name will be MD5.cache.ext + outputName = strongName + ".cache." + extension; + + } else { + outputName = suggestedFileName.substring(suggestedFileName.lastIndexOf('/') + 1); + } + + // Ask the context for an OutputStream into the named resource + OutputStream out = context.tryCreateResource(logger, outputName); + + // This would be null if the resource has already been created in the + // output (because two or more resources had identical content). + if (out != null) { + try { + out.write(data); + + } catch (IOException e) { + logger.log(TreeLogger.ERROR, "Unable to write data to output name " + + outputName, e); + throw new UnableToCompleteException(); + } + + // If there's an error, this won't be called and there will be nothing + // created in the output directory. + context.commitResource(logger, out); + + logger.log(TreeLogger.DEBUG, "Copied " + data.length + " bytes to " + + outputName, null); + } + + // Return a Java expression + return "GWT.getModuleBaseURL() + \"" + outputName + "\""; + } + + public String deploy(URL resource, boolean xhrCompatible) + throws UnableToCompleteException { + String fileName = ResourceGeneratorUtil.baseName(resource); + byte[] bytes = Util.readURLAsBytes(resource); + try { + return deploy(fileName, resource.openConnection().getContentType(), + bytes, xhrCompatible); + } catch (IOException e) { + getLogger().log(TreeLogger.ERROR, + "Unable to determine mime type of resource", e); + throw new UnableToCompleteException(); + } + } + + public boolean supportsDataUrls() { + return false; + } +} \ No newline at end of file
diff --git a/user/src/com/google/gwt/resources/rg/AbstractResourceGenerator.java b/user/src/com/google/gwt/resources/rg/AbstractResourceGenerator.java new file mode 100644 index 0000000..bec4310 --- /dev/null +++ b/user/src/com/google/gwt/resources/rg/AbstractResourceGenerator.java
@@ -0,0 +1,63 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JMethod; +import com.google.gwt.resources.ext.ClientBundleFields; +import com.google.gwt.resources.ext.ClientBundleRequirements; +import com.google.gwt.resources.ext.ResourceContext; +import com.google.gwt.resources.ext.ResourceGenerator; + +/** + * A base class providing common methods for ResourceGenerator implementations. + * + * @see com.google.gwt.resources.ext.ResourceGeneratorUtil + */ +public abstract class AbstractResourceGenerator implements ResourceGenerator { + public abstract String createAssignment(TreeLogger logger, + ResourceContext context, JMethod method) throws UnableToCompleteException; + + /** + * A no-op implementation. + */ + public void createFields(TreeLogger logger, ResourceContext context, + ClientBundleFields fields) throws UnableToCompleteException { + } + + /** + * A no-op implementation. + */ + public void finish(TreeLogger logger, ResourceContext context) + throws UnableToCompleteException { + } + + /** + * A no-op implementation. + */ + public void init(TreeLogger logger, ResourceContext context) + throws UnableToCompleteException { + } + + /** + * A no-op implementation. + */ + public void prepare(TreeLogger logger, ResourceContext context, + ClientBundleRequirements requirements, JMethod method) + throws UnableToCompleteException { + } +}
diff --git a/user/src/com/google/gwt/resources/rg/BundleResourceGenerator.java b/user/src/com/google/gwt/resources/rg/BundleResourceGenerator.java new file mode 100644 index 0000000..579677d --- /dev/null +++ b/user/src/com/google/gwt/resources/rg/BundleResourceGenerator.java
@@ -0,0 +1,40 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +import com.google.gwt.core.client.GWT; +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JClassType; +import com.google.gwt.core.ext.typeinfo.JMethod; +import com.google.gwt.resources.ext.ResourceContext; + +/** + * This is a special case of ResourceGenerator that handles nested bundles. + */ +public class BundleResourceGenerator extends AbstractResourceGenerator { + + @Override + public String createAssignment(TreeLogger logger, ResourceContext context, + JMethod method) throws UnableToCompleteException { + JClassType gwtType = context.getGeneratorContext().getTypeOracle().findType( + GWT.class.getName()); + assert gwtType != null; + + return gwtType.getQualifiedSourceName() + ".create(" + + method.getReturnType().getQualifiedSourceName() + ".class)"; + } +}
diff --git a/user/src/com/google/gwt/resources/rg/CssResourceGenerator.java b/user/src/com/google/gwt/resources/rg/CssResourceGenerator.java new file mode 100644 index 0000000..0a5c70b --- /dev/null +++ b/user/src/com/google/gwt/resources/rg/CssResourceGenerator.java
@@ -0,0 +1,1614 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +import com.google.gwt.core.ext.BadPropertyValueException; +import com.google.gwt.core.ext.Generator; +import com.google.gwt.core.ext.PropertyOracle; +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JClassType; +import com.google.gwt.core.ext.typeinfo.JMethod; +import com.google.gwt.core.ext.typeinfo.JPrimitiveType; +import com.google.gwt.core.ext.typeinfo.JType; +import com.google.gwt.core.ext.typeinfo.NotFoundException; +import com.google.gwt.core.ext.typeinfo.TypeOracle; +import com.google.gwt.dev.util.DefaultTextOutput; +import com.google.gwt.dev.util.Util; +import com.google.gwt.dom.client.Element; +import com.google.gwt.resources.client.CssResource; +import com.google.gwt.resources.client.DataResource; +import com.google.gwt.resources.client.ImageResource; +import com.google.gwt.resources.client.CssResource.ClassName; +import com.google.gwt.resources.client.CssResource.Import; +import com.google.gwt.resources.client.CssResource.ImportedWithPrefix; +import com.google.gwt.resources.client.CssResource.Shared; +import com.google.gwt.resources.client.CssResource.Strict; +import com.google.gwt.resources.client.ImageResource.ImageOptions; +import com.google.gwt.resources.client.ImageResource.RepeatStyle; +import com.google.gwt.resources.css.CssGenerationVisitor; +import com.google.gwt.resources.css.GenerateCssAst; +import com.google.gwt.resources.css.ast.CollapsedNode; +import com.google.gwt.resources.css.ast.Context; +import com.google.gwt.resources.css.ast.CssCompilerException; +import com.google.gwt.resources.css.ast.CssDef; +import com.google.gwt.resources.css.ast.CssEval; +import com.google.gwt.resources.css.ast.CssIf; +import com.google.gwt.resources.css.ast.CssMediaRule; +import com.google.gwt.resources.css.ast.CssModVisitor; +import com.google.gwt.resources.css.ast.CssNoFlip; +import com.google.gwt.resources.css.ast.CssNode; +import com.google.gwt.resources.css.ast.CssNodeCloner; +import com.google.gwt.resources.css.ast.CssProperty; +import com.google.gwt.resources.css.ast.CssRule; +import com.google.gwt.resources.css.ast.CssSelector; +import com.google.gwt.resources.css.ast.CssSprite; +import com.google.gwt.resources.css.ast.CssStylesheet; +import com.google.gwt.resources.css.ast.CssUrl; +import com.google.gwt.resources.css.ast.CssVisitor; +import com.google.gwt.resources.css.ast.HasNodes; +import com.google.gwt.resources.css.ast.CssProperty.DotPathValue; +import com.google.gwt.resources.css.ast.CssProperty.ExpressionValue; +import com.google.gwt.resources.css.ast.CssProperty.IdentValue; +import com.google.gwt.resources.css.ast.CssProperty.ListValue; +import com.google.gwt.resources.css.ast.CssProperty.NumberValue; +import com.google.gwt.resources.css.ast.CssProperty.Value; +import com.google.gwt.resources.ext.ClientBundleRequirements; +import com.google.gwt.resources.ext.ResourceContext; +import com.google.gwt.resources.ext.ResourceGeneratorUtil; +import com.google.gwt.user.rebind.SourceWriter; +import com.google.gwt.user.rebind.StringSourceWriter; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.net.URL; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.IdentityHashMap; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; +import java.util.Map; +import java.util.Set; +import java.util.SortedSet; +import java.util.TreeSet; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.zip.Adler32; + +/** + * Provides implementations of CSSResources. + */ +public class CssResourceGenerator extends AbstractResourceGenerator { + private static final String[] DEFAULT_EXTENSIONS = new String[] {".css"}; + + static class ClassRenamer extends CssVisitor { + private final Map<String, Map<JMethod, String>> classReplacementsWithPrefix; + private final Pattern classSelectorPattern = Pattern.compile("\\.([^ :>+#.]*)"); + private final TreeLogger logger; + private final Set<JMethod> missingClasses; + private final Set<String> replacedClasses = new HashSet<String>(); + private final boolean strict; + private final Set<String> unknownClasses = new HashSet<String>(); + + public ClassRenamer(TreeLogger logger, + Map<String, Map<JMethod, String>> classReplacementsWithPrefix, + boolean strict) { + this.logger = logger.branch(TreeLogger.DEBUG, "Replacing CSS class names"); + this.classReplacementsWithPrefix = classReplacementsWithPrefix; + this.strict = strict; + + // Require a definition for all classes in the default namespace + assert classReplacementsWithPrefix.containsKey(""); + missingClasses = new HashSet<JMethod>( + classReplacementsWithPrefix.get("").keySet()); + } + + @Override + public void endVisit(CssSelector x, Context ctx) { + String sel = x.getSelector(); + + // TODO This would be simplified by having a class hierarchy for selectors + for (Map.Entry<String, Map<JMethod, String>> outerEntry : classReplacementsWithPrefix.entrySet()) { + String prefix = outerEntry.getKey(); + for (Map.Entry<JMethod, String> entry : outerEntry.getValue().entrySet()) { + String name = entry.getKey().getName(); + + ClassName className = entry.getKey().getAnnotation(ClassName.class); + if (className != null) { + name = className.value(); + } + name = prefix + name; + + Pattern p = Pattern.compile("(.*)\\.(" + Pattern.quote(name) + + ")([ :>+#.].*|$)"); + Matcher m = p.matcher(sel); + if (m.find()) { + sel = m.group(1) + "." + entry.getValue() + m.group(3); + missingClasses.remove(entry.getKey()); + if (strict) { + replacedClasses.add(entry.getValue()); + } + } + } + } + + sel = sel.trim(); + + if (strict) { + Matcher m = classSelectorPattern.matcher(sel); + while (m.find()) { + String classSelector = m.group(1); + if (!replacedClasses.contains(classSelector)) { + unknownClasses.add(classSelector); + } + } + } + + x.setSelector(sel); + } + + @Override + public void endVisit(CssStylesheet x, Context ctx) { + boolean stop = false; + if (!missingClasses.isEmpty()) { + stop = true; + TreeLogger errorLogger = logger.branch(TreeLogger.INFO, + "The following obfuscated style classes were missing from " + + "the source CSS file:"); + for (JMethod m : missingClasses) { + String name = m.getName(); + ClassName className = m.getAnnotation(ClassName.class); + if (className != null) { + name = className.value(); + } + errorLogger.log(TreeLogger.ERROR, name + ": Fix by adding ." + name + + "{}"); + } + } + + if (strict && !unknownClasses.isEmpty()) { + stop = true; + TreeLogger errorLogger = logger.branch(TreeLogger.ERROR, + "The following unobfuscated classes were present in a strict CssResource:"); + for (String s : unknownClasses) { + errorLogger.log(TreeLogger.ERROR, s); + } + } + + if (stop) { + throw new CssCompilerException("Missing a CSS replacement"); + } + } + } + + /** + * Statically evaluates {@literal @if} rules. + */ + static class IfEvaluator extends CssModVisitor { + private final TreeLogger logger; + private final PropertyOracle oracle; + + public IfEvaluator(TreeLogger logger, PropertyOracle oracle) { + this.logger = logger.branch(TreeLogger.DEBUG, + "Replacing property-based @if blocks"); + this.oracle = oracle; + } + + @Override + public void endVisit(CssIf x, Context ctx) { + if (x.getExpression() != null) { + // This gets taken care of by the runtime substitution visitor + } else { + try { + String propertyName = x.getPropertyName(); + String propValue = oracle.getPropertyValue(logger, propertyName); + + /* + * If the deferred binding property's value is in the list of values + * in the @if rule, move the rules into the @if's context. + */ + if (Arrays.asList(x.getPropertyValues()).contains(propValue) + ^ x.isNegated()) { + for (CssNode n : x.getNodes()) { + ctx.insertBefore(n); + } + } else { + // Otherwise, move the else block into the if statement's position + for (CssNode n : x.getElseNodes()) { + ctx.insertBefore(n); + } + } + + // Always delete @if rules that we can statically evaluate + ctx.removeMe(); + } catch (BadPropertyValueException e) { + logger.log(TreeLogger.ERROR, "Unable to evaluate @if block", e); + throw new CssCompilerException("Unable to parse CSS", e); + } + } + } + } + + static class JClassOrderComparator implements Comparator<JClassType> { + public int compare(JClassType o1, JClassType o2) { + return o1.getQualifiedSourceName().compareTo(o2.getQualifiedSourceName()); + } + } + + /** + * Merges rules that have matching selectors. + */ + static class MergeIdenticalSelectorsVisitor extends CssModVisitor { + private final Map<String, CssRule> canonicalRules = new HashMap<String, CssRule>(); + private final List<CssRule> rulesInOrder = new ArrayList<CssRule>(); + + @Override + public boolean visit(CssIf x, Context ctx) { + visitInNewContext(x.getNodes()); + visitInNewContext(x.getElseNodes()); + return false; + } + + @Override + public boolean visit(CssMediaRule x, Context ctx) { + visitInNewContext(x.getNodes()); + return false; + } + + @Override + public boolean visit(CssRule x, Context ctx) { + // Assumed to run immediately after SplitRulesVisitor + assert x.getSelectors().size() == 1; + CssSelector sel = x.getSelectors().get(0); + + if (canonicalRules.containsKey(sel.getSelector())) { + CssRule canonical = canonicalRules.get(sel.getSelector()); + + // Check everything between the canonical rule and this rule for common + // properties. If there are common properties, it would be unsafe to + // promote the rule. + boolean hasCommon = false; + int index = rulesInOrder.indexOf(canonical) + 1; + assert index != 0; + + for (Iterator<CssRule> i = rulesInOrder.listIterator(index); i.hasNext() + && !hasCommon;) { + hasCommon = haveCommonProperties(i.next(), x); + } + + if (!hasCommon) { + // It's safe to promote the rule + canonical.getProperties().addAll(x.getProperties()); + ctx.removeMe(); + return false; + } + } + + canonicalRules.put(sel.getSelector(), x); + rulesInOrder.add(x); + return false; + } + + private void visitInNewContext(List<CssNode> nodes) { + MergeIdenticalSelectorsVisitor v = new MergeIdenticalSelectorsVisitor(); + v.accept(nodes); + rulesInOrder.addAll(v.rulesInOrder); + } + } + + /** + * Merges rules that have identical content. + */ + static class MergeRulesByContentVisitor extends CssModVisitor { + private Map<String, CssRule> rulesByContents = new HashMap<String, CssRule>(); + private final List<CssRule> rulesInOrder = new ArrayList<CssRule>(); + + @Override + public boolean visit(CssIf x, Context ctx) { + visitInNewContext(x.getNodes()); + visitInNewContext(x.getElseNodes()); + return false; + } + + @Override + public boolean visit(CssMediaRule x, Context ctx) { + visitInNewContext(x.getNodes()); + return false; + } + + @Override + public boolean visit(CssRule x, Context ctx) { + StringBuilder b = new StringBuilder(); + for (CssProperty p : x.getProperties()) { + b.append(p.getName()).append(":").append(p.getValues().getExpression()); + } + + String content = b.toString(); + CssRule canonical = rulesByContents.get(content); + + // Check everything between the canonical rule and this rule for common + // properties. If there are common properties, it would be unsafe to + // promote the rule. + if (canonical != null) { + boolean hasCommon = false; + int index = rulesInOrder.indexOf(canonical) + 1; + assert index != 0; + + for (Iterator<CssRule> i = rulesInOrder.listIterator(index); i.hasNext() + && !hasCommon;) { + hasCommon = haveCommonProperties(i.next(), x); + } + + if (!hasCommon) { + canonical.getSelectors().addAll(x.getSelectors()); + ctx.removeMe(); + return false; + } + } + + rulesByContents.put(content, x); + rulesInOrder.add(x); + return false; + } + + private void visitInNewContext(List<CssNode> nodes) { + MergeRulesByContentVisitor v = new MergeRulesByContentVisitor(); + v.accept(nodes); + rulesInOrder.addAll(v.rulesInOrder); + } + } + + static class RequirementsCollector extends CssVisitor { + private final TreeLogger logger; + private final ClientBundleRequirements requirements; + + public RequirementsCollector(TreeLogger logger, + ClientBundleRequirements requirements) { + this.logger = logger.branch(TreeLogger.DEBUG, + "Scanning CSS for requirements"); + this.requirements = requirements; + } + + @Override + public void endVisit(CssIf x, Context ctx) { + String propertyName = x.getPropertyName(); + if (propertyName != null) { + try { + requirements.addPermutationAxis(propertyName); + } catch (BadPropertyValueException e) { + logger.log(TreeLogger.ERROR, "Unknown deferred-binding property " + + propertyName, e); + throw new CssCompilerException("Unknown deferred-binding property", e); + } + } + } + } + + static class RtlVisitor extends CssModVisitor { + /** + * Records if we're currently visiting a CssRule whose only selector is + * "body". + */ + private boolean inBodyRule; + + @Override + public void endVisit(CssProperty x, Context ctx) { + String name = x.getName(); + + if (name.equalsIgnoreCase("left")) { + x.setName("right"); + } else if (name.equalsIgnoreCase("right")) { + x.setName("left"); + } else if (name.endsWith("-left")) { + int len = name.length(); + x.setName(name.substring(0, len - 4) + "right"); + } else if (name.endsWith("-right")) { + int len = name.length(); + x.setName(name.substring(0, len - 5) + "left"); + } else if (name.contains("-right-")) { + x.setName(name.replace("-right-", "-left-")); + } else if (name.contains("-left-")) { + x.setName(name.replace("-left-", "-right-")); + } else { + List<Value> values = new ArrayList<Value>(x.getValues().getValues()); + invokePropertyHandler(x.getName(), values); + x.setValue(new CssProperty.ListValue(values)); + } + } + + @Override + public boolean visit(CssNoFlip x, Context ctx) { + return false; + } + + @Override + public boolean visit(CssRule x, Context ctx) { + inBodyRule = x.getSelectors().size() == 1 + && x.getSelectors().get(0).getSelector().equals("body"); + return true; + } + + void propertyHandlerBackground(List<Value> values) { + /* + * The first numeric value will be treated as the left position only if we + * havn't seen any value that could potentially be the left value. + */ + boolean seenLeft = false; + + for (ListIterator<Value> it = values.listIterator(); it.hasNext();) { + Value v = it.next(); + Value maybeFlipped = flipLeftRightIdentValue(v); + NumberValue nv = v.isNumberValue(); + if (v != maybeFlipped) { + it.set(maybeFlipped); + seenLeft = true; + + } else if (isIdent(v, "center")) { + seenLeft = true; + + } else if (!seenLeft && (nv != null)) { + seenLeft = true; + if ("%".equals(nv.getUnits())) { + float position = 100f - nv.getValue(); + it.set(new NumberValue(position, "%")); + break; + } + } + } + } + + void propertyHandlerBackgroundPosition(List<Value> values) { + propertyHandlerBackground(values); + } + + Value propertyHandlerBackgroundPositionX(Value v) { + ArrayList<Value> list = new ArrayList<Value>(1); + list.add(v); + propertyHandlerBackground(list); + return list.get(0); + } + + /** + * Note there should be no propertyHandlerBorder(). The CSS spec states that + * the border property must set all values at once. + */ + void propertyHandlerBorderColor(List<Value> values) { + swapFour(values); + } + + void propertyHandlerBorderStyle(List<Value> values) { + swapFour(values); + } + + void propertyHandlerBorderWidth(List<Value> values) { + swapFour(values); + } + + Value propertyHandlerClear(Value v) { + return propertyHandlerFloat(v); + } + + Value propertyHandlerCursor(Value v) { + IdentValue identValue = v.isIdentValue(); + if (identValue == null) { + return v; + } + + String ident = identValue.getIdent().toLowerCase(); + if (!ident.endsWith("-resize")) { + return v; + } + + StringBuffer newIdent = new StringBuffer(); + + if (ident.length() == 9) { + if (ident.charAt(0) == 'n') { + newIdent.append('n'); + ident = ident.substring(1); + } else if (ident.charAt(0) == 's') { + newIdent.append('s'); + ident = ident.substring(1); + } else { + return v; + } + } + + if (ident.length() == 8) { + if (ident.charAt(0) == 'e') { + newIdent.append("w-resize"); + } else if (ident.charAt(0) == 'w') { + newIdent.append("e-resize"); + } else { + return v; + } + return new IdentValue(newIdent.toString()); + } else { + return v; + } + } + + Value propertyHandlerDirection(Value v) { + if (inBodyRule) { + if (isIdent(v, "ltr")) { + return new IdentValue("rtl"); + } else if (isIdent(v, "rtl")) { + return new IdentValue("ltr"); + } + } + return v; + } + + Value propertyHandlerFloat(Value v) { + return flipLeftRightIdentValue(v); + } + + void propertyHandlerMargin(List<Value> values) { + swapFour(values); + } + + void propertyHandlerPadding(List<Value> values) { + swapFour(values); + } + + Value propertyHandlerPageBreakAfter(Value v) { + return flipLeftRightIdentValue(v); + } + + Value propertyHandlerPageBreakBefore(Value v) { + return flipLeftRightIdentValue(v); + } + + Value propertyHandlerTextAlign(Value v) { + return flipLeftRightIdentValue(v); + } + + private Value flipLeftRightIdentValue(Value v) { + if (isIdent(v, "right")) { + return new IdentValue("left"); + + } else if (isIdent(v, "left")) { + return new IdentValue("right"); + } + return v; + } + + /** + * Reflectively invokes a propertyHandler method for the named property. + * Dashed names are transformed into camel-case names; only letters + * following a dash will be capitalized when looking for a method to prevent + * <code>fooBar<code> and <code>foo-bar</code> from colliding. + */ + private void invokePropertyHandler(String name, List<Value> values) { + // See if we have a property-handler function + try { + String[] parts = name.toLowerCase().split("-"); + StringBuffer methodName = new StringBuffer("propertyHandler"); + for (String part : parts) { + methodName.append(Character.toUpperCase(part.charAt(0))); + methodName.append(part, 1, part.length()); + } + + try { + // Single-arg for simplicity + Method m = getClass().getDeclaredMethod(methodName.toString(), + Value.class); + assert Value.class.isAssignableFrom(m.getReturnType()); + Value newValue = (Value) m.invoke(this, values.get(0)); + values.set(0, newValue); + } catch (NoSuchMethodException e) { + // OK + } + + try { + // Or the whole List for completeness + Method m = getClass().getDeclaredMethod(methodName.toString(), + List.class); + m.invoke(this, values); + } catch (NoSuchMethodException e) { + // OK + } + + } catch (SecurityException e) { + throw new CssCompilerException( + "Unable to invoke property handler function for " + name, e); + } catch (IllegalArgumentException e) { + throw new CssCompilerException( + "Unable to invoke property handler function for " + name, e); + } catch (IllegalAccessException e) { + throw new CssCompilerException( + "Unable to invoke property handler function for " + name, e); + } catch (InvocationTargetException e) { + throw new CssCompilerException( + "Unable to invoke property handler function for " + name, e); + } + } + + private boolean isIdent(Value value, String query) { + IdentValue v = value.isIdentValue(); + return v != null && v.getIdent().equalsIgnoreCase(query); + } + + /** + * Swaps the second and fourth values in a list of four values. + */ + private void swapFour(List<Value> values) { + if (values.size() == 4) { + Collections.swap(values, 1, 3); + } + } + } + + /** + * Splits rules with compound selectors into multiple rules. + */ + static class SplitRulesVisitor extends CssModVisitor { + @Override + public void endVisit(CssRule x, Context ctx) { + if (x.getSelectors().size() == 1) { + return; + } + + for (CssSelector sel : x.getSelectors()) { + CssRule newRule = new CssRule(); + newRule.getSelectors().add(sel); + newRule.getProperties().addAll( + CssNodeCloner.clone(CssProperty.class, x.getProperties())); + ctx.insertBefore(newRule); + } + ctx.removeMe(); + return; + } + } + + /** + * Replaces CssSprite nodes with CssRule nodes that will display the sprited + * image. The real trick with spriting the images is to reuse the + * ImageResource processing framework by requiring the sprite to be defined in + * terms of an ImageResource. + */ + static class Spriter extends CssModVisitor { + private final ResourceContext context; + private final TreeLogger logger; + + public Spriter(TreeLogger logger, ResourceContext context) { + this.logger = logger.branch(TreeLogger.DEBUG, + "Creating image sprite classes"); + this.context = context; + } + + @Override + public void endVisit(CssSprite x, Context ctx) { + JClassType bundleType = context.getClientBundleType(); + String functionName = x.getResourceFunction(); + + if (functionName == null) { + logger.log(TreeLogger.ERROR, "The @sprite rule " + x.getSelectors() + + " must specify the " + CssSprite.IMAGE_PROPERTY_NAME + + " property"); + throw new CssCompilerException("No image property specified"); + } + + // Find the image accessor method + JMethod imageMethod = null; + JMethod[] allMethods = bundleType.getOverridableMethods(); + for (int i = 0; imageMethod == null && i < allMethods.length; i++) { + JMethod candidate = allMethods[i]; + // If the function name matches and takes no parameters + if (candidate.getName().equals(functionName) + && candidate.getParameters().length == 0) { + // We have a match + imageMethod = candidate; + } + } + + // Method unable to be located + if (imageMethod == null) { + logger.log(TreeLogger.ERROR, "Unable to find ImageResource method " + + functionName + " in " + bundleType.getQualifiedSourceName()); + throw new CssCompilerException("Cannot find image function"); + } + + JClassType imageResourceType = context.getGeneratorContext().getTypeOracle().findType( + ImageResource.class.getName()); + assert imageResourceType != null; + + if (!imageResourceType.isAssignableFrom(imageMethod.getReturnType().isClassOrInterface())) { + logger.log(TreeLogger.ERROR, "The return type of " + functionName + + " is not assignable to " + + imageResourceType.getSimpleSourceName()); + throw new CssCompilerException("Incorrect return type for " + + CssSprite.IMAGE_PROPERTY_NAME + " method"); + } + + ImageOptions options = imageMethod.getAnnotation(ImageOptions.class); + RepeatStyle repeatStyle; + if (options != null) { + repeatStyle = options.repeatStyle(); + } else { + repeatStyle = RepeatStyle.None; + } + + String instance = "(" + context.getImplementationSimpleSourceName() + + ".this." + functionName + "())"; + + CssRule replacement = new CssRule(); + replacement.getSelectors().addAll(x.getSelectors()); + List<CssProperty> properties = replacement.getProperties(); + + if (repeatStyle == RepeatStyle.None + || repeatStyle == RepeatStyle.Horizontal) { + properties.add(new CssProperty("height", new ExpressionValue(instance + + ".getHeight() + \"px\""), false)); + } + + if (repeatStyle == RepeatStyle.None + || repeatStyle == RepeatStyle.Vertical) { + properties.add(new CssProperty("width", new ExpressionValue(instance + + ".getWidth() + \"px\""), false)); + } + properties.add(new CssProperty("overflow", new IdentValue("hidden"), + false)); + + String repeatText; + switch (repeatStyle) { + case None: + repeatText = " no-repeat"; + break; + case Horizontal: + repeatText = " repeat-x"; + break; + case Vertical: + repeatText = " repeat-y"; + break; + case Both: + repeatText = " repeat"; + break; + default: + throw new RuntimeException("Unknown repeatStyle " + repeatStyle); + } + + String backgroundExpression = "\"url(\\\"\" + " + instance + + ".getURL() + \"\\\") -\" + " + instance + + ".getLeft() + \"px -\" + " + instance + ".getTop() + \"px " + + repeatText + "\""; + properties.add(new CssProperty("background", new ExpressionValue( + backgroundExpression), false)); + + // Retain any user-specified properties + properties.addAll(x.getProperties()); + + ctx.replaceMe(replacement); + } + } + + static class SubstitutionCollector extends CssVisitor { + private final Map<String, CssDef> substitutions = new HashMap<String, CssDef>(); + + @Override + public void endVisit(CssDef x, Context ctx) { + substitutions.put(x.getKey(), x); + } + + @Override + public void endVisit(CssEval x, Context ctx) { + substitutions.put(x.getKey(), x); + } + + @Override + public void endVisit(CssUrl x, Context ctx) { + substitutions.put(x.getKey(), x); + } + } + + /** + * Substitute symbolic replacements into string values. + */ + static class SubstitutionReplacer extends CssVisitor { + private final ResourceContext context; + private final TreeLogger logger; + private final Map<String, CssDef> substitutions; + + public SubstitutionReplacer(TreeLogger logger, ResourceContext context, + Map<String, CssDef> substitutions) { + this.context = context; + this.logger = logger; + this.substitutions = substitutions; + } + + @Override + public void endVisit(CssProperty x, Context ctx) { + if (x.getValues() == null) { + // Nothing to do + return; + } + + List<Value> values = new ArrayList<Value>(x.getValues().getValues()); + + for (ListIterator<Value> i = values.listIterator(); i.hasNext();) { + IdentValue v = i.next().isIdentValue(); + + if (v == null) { + // Don't try to substitute into anything other than idents + continue; + } + + String value = v.getIdent(); + CssDef def = substitutions.get(value); + + if (def == null) { + continue; + } else if (def instanceof CssUrl) { + assert def.getValues().size() == 1; + assert def.getValues().get(0).isIdentValue() != null; + String functionName = def.getValues().get(0).isIdentValue().getIdent(); + + // Find the method + JMethod method = context.getClientBundleType().findMethod( + functionName, new JType[0]); + + if (method == null) { + logger.log(TreeLogger.ERROR, "Unable to find DataResource method " + + functionName + " in " + + context.getClientBundleType().getQualifiedSourceName()); + throw new CssCompilerException("Cannot find data function"); + } + + String instance = "((" + DataResource.class.getName() + ")(" + + context.getImplementationSimpleSourceName() + ".this." + + functionName + "()))"; + + StringBuilder expression = new StringBuilder(); + expression.append("\"url('\" + "); + expression.append(instance).append(".getUrl()"); + expression.append(" + \"')\""); + i.set(new ExpressionValue(expression.toString())); + + } else { + i.remove(); + for (Value defValue : def.getValues()) { + i.add(defValue); + } + } + } + + x.setValue(new ListValue(values)); + } + } + + /** + * A lookup table of base-32 chars we use to encode CSS idents. Because CSS + * class selectors may be case-insensitive, we don't have enough characters to + * use a base-64 encoding. + */ + private static final char[] BASE32_CHARS = new char[] { + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', + 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '-', '0', + '1', '2', '3', '4'}; + + /** + * This value is used by {@link #concatOp} to help create a more balanced AST + * tree by producing parenthetical expressions. + */ + private static final int CONCAT_EXPRESSION_LIMIT = 20; + + public static void main(String[] args) { + for (int i = 0; i < 1000; i++) { + System.out.println(makeIdent(i)); + } + } + + static boolean haveCommonProperties(CssRule a, CssRule b) { + if (a.getProperties().size() == 0 || b.getProperties().size() == 0) { + return false; + } + + SortedSet<String> aProperties = new TreeSet<String>(); + SortedSet<String> bProperties = new TreeSet<String>(); + + for (CssProperty p : a.getProperties()) { + aProperties.add(p.getName()); + } + for (CssProperty p : b.getProperties()) { + bProperties.add(p.getName()); + } + + Iterator<String> ai = aProperties.iterator(); + Iterator<String> bi = bProperties.iterator(); + + String aName = ai.next(); + String bName = bi.next(); + for (;;) { + int comp = aName.compareToIgnoreCase(bName); + if (comp == 0) { + return true; + } else if (comp > 0) { + if (aName.startsWith(bName + "-")) { + return true; + } + + if (!bi.hasNext()) { + break; + } + bName = bi.next(); + } else { + if (bName.startsWith(aName + "-")) { + return true; + } + if (!ai.hasNext()) { + break; + } + aName = ai.next(); + } + } + + return false; + } + + /** + * Create a Java expression that evaluates to a string representation of the + * given node. Visible only for testing. + */ + static <T extends CssNode & HasNodes> String makeExpression( + TreeLogger logger, ResourceContext context, JClassType cssResourceType, + T node, boolean prettyOutput) throws UnableToCompleteException { + // Generate the CSS template + DefaultTextOutput out = new DefaultTextOutput(!prettyOutput); + CssGenerationVisitor v = new CssGenerationVisitor(out); + v.accept(node); + + // Generate the final Java expression + String template = out.toString(); + StringBuilder b = new StringBuilder(); + int start = 0; + + /* + * Very large concatenation expressions using '+' cause the GWT compiler to + * overflow the stack due to deep AST nesting. The workaround for now is to + * force it to be more balanced using intermediate concatenation groupings. + * + * This variable is used to track the number of subexpressions within the + * current parenthetical expression. + */ + int numExpressions = 0; + + b.append('('); + for (Map.Entry<Integer, List<CssNode>> entry : v.getSubstitutionPositions().entrySet()) { + // Add the static section between start and the substitution point + b.append('"'); + b.append(Generator.escape(template.substring(start, entry.getKey()))); + b.append('\"'); + numExpressions = concatOp(numExpressions, b); + + // Add the nodes at the substitution point + for (CssNode x : entry.getValue()) { + TreeLogger loopLogger = logger.branch(TreeLogger.DEBUG, + "Performing substitution in node " + x.toString()); + + if (x instanceof CssIf) { + CssIf asIf = (CssIf) x; + + // Generate the sub-expressions + String expression = makeExpression(loopLogger, context, + cssResourceType, new CollapsedNode(asIf), prettyOutput); + + String elseExpression; + if (asIf.getElseNodes().isEmpty()) { + // We'll treat an empty else block as an empty string + elseExpression = "\"\""; + } else { + elseExpression = makeExpression(loopLogger, context, + cssResourceType, new CollapsedNode(asIf.getElseNodes()), + prettyOutput); + } + + // ((expr) ? "CSS" : "elseCSS") + + b.append("((" + asIf.getExpression() + ") ? " + expression + " : " + + elseExpression + ") "); + numExpressions = concatOp(numExpressions, b); + + } else if (x instanceof CssProperty) { + CssProperty property = (CssProperty) x; + + validateValue(loopLogger, context.getClientBundleType(), + property.getValues()); + + // (expr) + + b.append("(" + property.getValues().getExpression() + ") "); + numExpressions = concatOp(numExpressions, b); + + } else { + // This indicates that some magic node is slipping by our visitors + loopLogger.log(TreeLogger.ERROR, "Unhandled substitution " + + x.getClass()); + throw new UnableToCompleteException(); + } + } + start = entry.getKey(); + } + + // Add the remaining parts of the template + b.append('"'); + b.append(Generator.escape(template.substring(start))); + b.append('"'); + b.append(')'); + + return b.toString(); + } + + /** + * Check if number of concat expressions currently exceeds limit and either + * append '+' if the limit isn't reached or ') + (' if it is. + * + * @return numExpressions + 1 or 0 if limit was exceeded. + */ + private static int concatOp(int numExpressions, StringBuilder b) { + /* + * TODO: Fix the compiler to better handle arbitrarily long concatenation + * expressions. + */ + if (numExpressions >= CONCAT_EXPRESSION_LIMIT) { + b.append(") + ("); + return 0; + } + + b.append(" + "); + return numExpressions + 1; + } + + private static String makeIdent(long id) { + assert id >= 0; + + StringBuilder b = new StringBuilder(); + + // Use only guaranteed-alpha characters for the first character + b.append(BASE32_CHARS[(int) (id & 0xf)]); + id >>= 4; + + while (id != 0) { + b.append(BASE32_CHARS[(int) (id & 0x1f)]); + id >>= 5; + } + + return b.toString(); + } + + /** + * This function validates any context-sensitive Values. + */ + private static void validateValue(TreeLogger logger, + JClassType resourceBundleType, Value value) + throws UnableToCompleteException { + + ListValue list = value.isListValue(); + if (list != null) { + for (Value v : list.getValues()) { + validateValue(logger, resourceBundleType, v); + } + return; + } + + DotPathValue dot = value.isDotPathValue(); + if (dot != null) { + String[] elements = dot.getPath().split("\\."); + if (elements.length == 0) { + logger.log(TreeLogger.ERROR, "value() functions must specify a path"); + throw new UnableToCompleteException(); + } + + JType currentType = resourceBundleType; + for (Iterator<String> i = Arrays.asList(elements).iterator(); i.hasNext();) { + String pathElement = i.next(); + + JClassType referenceType = currentType.isClassOrInterface(); + if (referenceType == null) { + logger.log(TreeLogger.ERROR, "Cannot resolve member " + pathElement + + " on non-reference type " + + currentType.getQualifiedSourceName()); + throw new UnableToCompleteException(); + } + + try { + JMethod m = referenceType.getMethod(pathElement, new JType[0]); + currentType = m.getReturnType(); + } catch (NotFoundException e) { + logger.log(TreeLogger.ERROR, "Could not find no-arg method named " + + pathElement + " in type " + + currentType.getQualifiedSourceName()); + throw new UnableToCompleteException(); + } + } + return; + } + } + + private String classPrefix; + private JClassType cssResourceType; + private JClassType elementType; + private boolean enableMerge; + private boolean prettyOutput; + private Map<JClassType, Map<JMethod, String>> replacementsByClassAndMethod; + + private Map<JMethod, String> replacementsForSharedMethods; + + private Map<JMethod, CssStylesheet> stylesheetMap; + + private JClassType stringType; + + @Override + public String createAssignment(TreeLogger logger, ResourceContext context, + JMethod method) throws UnableToCompleteException { + + SourceWriter sw = new StringSourceWriter(); + // Write the expression to create the subtype. + sw.println("new " + method.getReturnType().getQualifiedSourceName() + + "() {"); + sw.indent(); + + JClassType cssResourceSubtype = method.getReturnType().isInterface(); + assert cssResourceSubtype != null; + Map<String, Map<JMethod, String>> replacementsWithPrefix = new HashMap<String, Map<JMethod, String>>(); + + replacementsWithPrefix.put("", + computeReplacementsForType(cssResourceSubtype)); + Import imp = method.getAnnotation(Import.class); + if (imp != null) { + boolean fail = false; + for (Class<? extends CssResource> clazz : imp.value()) { + JClassType importType = context.getGeneratorContext().getTypeOracle().findType( + clazz.getName().replace('$', '.')); + String prefix = importType.getSimpleSourceName(); + ImportedWithPrefix exp = importType.getAnnotation(ImportedWithPrefix.class); + if (exp != null) { + prefix = exp.value(); + } + assert importType != null; + + if (replacementsWithPrefix.put(prefix + "-", + computeReplacementsForType(importType)) != null) { + logger.log(TreeLogger.ERROR, + "Multiple imports that would use the prefix " + prefix); + fail = true; + } + } + if (fail) { + throw new UnableToCompleteException(); + } + } + + /* + * getOverridableMethods is used to handle CssResources extending + * non-CssResource types. See the discussion in computeReplacementsForType. + */ + for (JMethod toImplement : cssResourceSubtype.getOverridableMethods()) { + String name = toImplement.getName(); + if ("getName".equals(name) || "getText".equals(name)) { + continue; + } + + if (toImplement.getReturnType().equals(stringType) + && toImplement.getParameters().length == 0) { + writeClassAssignment(sw, toImplement, replacementsWithPrefix.get("")); + + } else if (toImplement.getReturnType().isPrimitive() != null + && toImplement.getParameters().length == 0) { + writeDefAssignment(logger, sw, toImplement, stylesheetMap.get(method)); + + } else { + logger.log(TreeLogger.ERROR, "Don't know how to implement method " + + toImplement.getName()); + throw new UnableToCompleteException(); + } + } + + sw.println("public String getText() {"); + sw.indent(); + + boolean strict = method.getAnnotation(Strict.class) != null; + if (!strict) { + /* + * The developer may choose to force strict behavior onto the system. If + * the method does already have the @Strict annotation, print a warning. + */ + try { + PropertyOracle propertyOracle = context.getGeneratorContext().getPropertyOracle(); + String propertyValue = propertyOracle.getPropertyValue(logger, + "CssResource.strictAccessors"); + if (Boolean.valueOf(propertyValue)) { + logger.log(TreeLogger.WARN, "CssResource.forceStrict is true, but " + + method.getName() + "() is missing the @Strict annotation."); + strict = true; + } + } catch (BadPropertyValueException e) { + // Ignore + } + } + + String cssExpression = makeExpression(logger, context, cssResourceSubtype, + stylesheetMap.get(method), replacementsWithPrefix, strict); + sw.println("return " + cssExpression + ";"); + sw.outdent(); + sw.println("}"); + + sw.println("public String getName() {"); + sw.indent(); + sw.println("return \"" + method.getName() + "\";"); + sw.outdent(); + sw.println("}"); + + sw.outdent(); + sw.println("}"); + + return sw.toString(); + } + + @Override + public void init(TreeLogger logger, ResourceContext context) + throws UnableToCompleteException { + try { + PropertyOracle propertyOracle = context.getGeneratorContext().getPropertyOracle(); + String style = propertyOracle.getPropertyValue(logger, + "CssResource.style").toLowerCase(); + prettyOutput = style.equals("pretty"); + + String merge = propertyOracle.getPropertyValue(logger, + "CssResource.mergeEnabled").toLowerCase(); + enableMerge = merge.equals("true"); + + classPrefix = propertyOracle.getPropertyValue(logger, + "CssResource.obfuscationPrefix"); + } catch (BadPropertyValueException e) { + logger.log(TreeLogger.WARN, "Unable to query module property", e); + throw new UnableToCompleteException(); + } + + if ("default".equals(classPrefix)) { + // Compute it later in computeObfuscatedNames(); + classPrefix = null; + } else if ("empty".equals(classPrefix)) { + classPrefix = ""; + } + + // Find all of the types that we care about in the type system + TypeOracle typeOracle = context.getGeneratorContext().getTypeOracle(); + + cssResourceType = typeOracle.findType(CssResource.class.getName()); + assert cssResourceType != null; + + elementType = typeOracle.findType(Element.class.getName()); + assert elementType != null; + + stringType = typeOracle.findType(String.class.getName()); + assert stringType != null; + + replacementsByClassAndMethod = new IdentityHashMap<JClassType, Map<JMethod, String>>(); + replacementsForSharedMethods = new IdentityHashMap<JMethod, String>(); + stylesheetMap = new IdentityHashMap<JMethod, CssStylesheet>(); + + computeObfuscatedNames(logger); + } + + @Override + public void prepare(TreeLogger logger, ResourceContext context, + ClientBundleRequirements requirements, JMethod method) + throws UnableToCompleteException { + + if (method.getReturnType().isInterface() == null) { + logger.log(TreeLogger.ERROR, "Return type must be an interface"); + throw new UnableToCompleteException(); + } + + URL[] resources = ResourceGeneratorUtil.findResources(logger, context, + method, DEFAULT_EXTENSIONS); + + if (resources.length == 0) { + logger.log(TreeLogger.ERROR, "At least one source must be specified"); + throw new UnableToCompleteException(); + } + + // Create the AST and do a quick scan for requirements + CssStylesheet sheet = GenerateCssAst.exec(logger, resources); + stylesheetMap.put(method, sheet); + (new RequirementsCollector(logger, requirements)).accept(sheet); + } + + /** + * Each distinct type of CssResource has a unique collection of values that it + * will return, excepting for those methods that are defined within an + * interface that is tagged with {@code @Shared}. + */ + private void computeObfuscatedNames(TreeLogger logger) { + logger = logger.branch(TreeLogger.DEBUG, "Computing CSS class replacements"); + + SortedSet<JClassType> cssResourceSubtypes = computeOperableTypes(logger); + + if (classPrefix == null) { + Adler32 checksum = new Adler32(); + for (JClassType type : cssResourceSubtypes) { + checksum.update(Util.getBytes(type.getQualifiedSourceName())); + } + classPrefix = "G" + + Long.toString(checksum.getValue(), Character.MAX_RADIX); + } + + int count = 0; + for (JClassType type : cssResourceSubtypes) { + Map<JMethod, String> replacements = new IdentityHashMap<JMethod, String>(); + replacementsByClassAndMethod.put(type, replacements); + + for (JMethod method : type.getOverridableMethods()) { + String name = method.getName(); + if ("getName".equals(name) || "getText".equals(name) + || !stringType.equals(method.getReturnType())) { + continue; + } + + // The user provided the class name to use + ClassName classNameOverride = method.getAnnotation(ClassName.class); + if (classNameOverride != null) { + name = classNameOverride.value(); + } + + String obfuscatedClassName; + if (prettyOutput) { + obfuscatedClassName = classPrefix + "-" + + type.getQualifiedSourceName().replaceAll("[.$]", "-") + "-" + + name; + } else { + obfuscatedClassName = classPrefix + makeIdent(count++); + } + + replacements.put(method, obfuscatedClassName); + + if (method.getEnclosingType() == type) { + Shared shared = type.getAnnotation(Shared.class); + if (shared != null) { + replacementsForSharedMethods.put(method, obfuscatedClassName); + } + } + + logger.log(TreeLogger.SPAM, "Mapped " + type.getQualifiedSourceName() + + "." + name + " to " + obfuscatedClassName); + } + } + } + + /** + * Returns all interfaces derived from CssResource, sorted by qualified name. + * <p> + * We'll ignore concrete implementations of CssResource, which include types + * previously-generated by CssResourceGenerator and user-provided + * implementations of CssResource, which aren't valid for use with + * CssResourceGenerator anyway. By ignoring newly-generated CssResource types, + * we'll ensure a stable ordering, regardless of the actual execution order + * used by the Generator framework. + * <p> + * It is still possible that additional pure-interfaces could be introduced by + * other generators, which would change the result of this computation, but + * there is presently no way to determine when, or by what means, a type was + * added to the TypeOracle. + */ + private SortedSet<JClassType> computeOperableTypes(TreeLogger logger) { + logger = logger.branch(TreeLogger.DEBUG, + "Finding operable CssResource subtypes"); + + SortedSet<JClassType> toReturn = new TreeSet<JClassType>( + new JClassOrderComparator()); + + JClassType[] cssResourceSubtypes = cssResourceType.getSubtypes(); + for (JClassType type : cssResourceSubtypes) { + if (type.isInterface() != null) { + logger.log(TreeLogger.SPAM, "Added " + type.getQualifiedSourceName()); + toReturn.add(type); + + } else { + logger.log(TreeLogger.SPAM, "Ignored " + type.getQualifiedSourceName()); + } + } + + return toReturn; + } + + /** + * Compute the mapping of original class names to obfuscated type names for a + * given subtype of CssResource. Mappings are inherited from the type's + * supertypes. + */ + private Map<JMethod, String> computeReplacementsForType(JClassType type) { + Map<JMethod, String> toReturn = new IdentityHashMap<JMethod, String>(); + + /* + * We check to see if the type is derived from CssResource so that we can + * handle the case of a CssResource type being derived from a + * non-CssResource base type. This basically collapses the non-CssResource + * base types into their least-derived CssResource subtypes. + */ + if (type == null || !derivedFromCssResource(type)) { + return toReturn; + } + + if (replacementsByClassAndMethod.containsKey(type)) { + toReturn.putAll(replacementsByClassAndMethod.get(type)); + } + + /* + * Replacements for methods defined in shared types will override any + * locally-computed values. + */ + for (JMethod method : type.getOverridableMethods()) { + if (replacementsForSharedMethods.containsKey(method)) { + assert toReturn.containsKey(method); + toReturn.put(method, replacementsForSharedMethods.get(method)); + } + } + + return toReturn; + } + + /** + * Determine if a type is derived from CssResource. + */ + private boolean derivedFromCssResource(JClassType type) { + List<JClassType> superInterfaces = Arrays.asList(type.getImplementedInterfaces()); + if (superInterfaces.contains(cssResourceType)) { + return true; + } + + JClassType superClass = type.getSuperclass(); + if (superClass != null) { + if (derivedFromCssResource(superClass)) { + return true; + } + } + + for (JClassType superInterface : superInterfaces) { + if (derivedFromCssResource(superInterface)) { + return true; + } + } + return false; + } + + /** + * Create a Java expression that evaluates to the string representation of the + * stylesheet resource. + */ + private String makeExpression(TreeLogger logger, ResourceContext context, + JClassType cssResourceType, CssStylesheet sheet, + Map<String, Map<JMethod, String>> classReplacementsWithPrefix, + boolean strict) throws UnableToCompleteException { + + try { + + // Create CSS sprites + (new Spriter(logger, context)).accept(sheet); + + // Perform @def and @eval substitutions + SubstitutionCollector collector = new SubstitutionCollector(); + collector.accept(sheet); + + (new SubstitutionReplacer(logger, context, collector.substitutions)).accept(sheet); + + // Evaluate @if statements based on deferred binding properties + (new IfEvaluator(logger, + context.getGeneratorContext().getPropertyOracle())).accept(sheet); + + // Rename css .class selectors + (new ClassRenamer(logger, classReplacementsWithPrefix, strict)).accept(sheet); + + // Combine rules with identical selectors + if (enableMerge) { + // TODO This is an off-switch while this is being developed; remove + (new SplitRulesVisitor()).accept(sheet); + (new MergeIdenticalSelectorsVisitor()).accept(sheet); + (new MergeRulesByContentVisitor()).accept(sheet); + } + + String standard = makeExpression(logger, context, cssResourceType, sheet, + prettyOutput); + + (new RtlVisitor()).accept(sheet); + + String reversed = makeExpression(logger, context, cssResourceType, sheet, + prettyOutput); + + return "com.google.gwt.i18n.client.LocaleInfo.getCurrentLocale().isRTL() ? (" + + reversed + ") : (" + standard + ")"; + + } catch (CssCompilerException e) { + // Take this as a sign that one of the visitors was unhappy, but only + // log the stack trace if there's a causal (i.e. unknown) exception. + logger.log(TreeLogger.ERROR, "Unable to process CSS", + e.getCause() == null ? null : e); + throw new UnableToCompleteException(); + } + } + + /** + * Write the CssResource accessor method for simple String return values. + */ + private void writeClassAssignment(SourceWriter sw, JMethod toImplement, + Map<JMethod, String> classReplacements) { + + String replacement = classReplacements.get(toImplement); + assert replacement != null; + + sw.println(toImplement.getReadableDeclaration(false, true, true, true, true) + + "{"); + sw.indent(); + sw.println("return \"" + replacement + "\";"); + sw.outdent(); + sw.println("}"); + } + + private void writeDefAssignment(TreeLogger logger, SourceWriter sw, + JMethod toImplement, CssStylesheet cssStylesheet) + throws UnableToCompleteException { + SubstitutionCollector collector = new SubstitutionCollector(); + collector.accept(cssStylesheet); + + String name = toImplement.getName(); + // TODO: Annotation for override + + CssDef def = collector.substitutions.get(name); + if (def == null) { + logger.log(TreeLogger.ERROR, "No @def rule for name " + name); + throw new UnableToCompleteException(); + } + + // TODO: Allow returning an array of values + if (def.getValues().size() != 1) { + logger.log(TreeLogger.ERROR, "@def rule " + name + + " must define exactly one value"); + throw new UnableToCompleteException(); + } + + NumberValue numberValue = def.getValues().get(0).isNumberValue(); + + if (numberValue == null) { + logger.log(TreeLogger.ERROR, "The define named " + name + + " does not define a numeric value"); + throw new UnableToCompleteException(); + } + + JPrimitiveType returnType = toImplement.getReturnType().isPrimitive(); + assert returnType != null; + + sw.print(toImplement.getReadableDeclaration(false, false, false, false, + true)); + sw.println(" {"); + sw.indent(); + if (returnType == JPrimitiveType.INT || returnType == JPrimitiveType.LONG) { + sw.println("return " + Math.round(numberValue.getValue()) + ";"); + } else if (returnType == JPrimitiveType.FLOAT) { + sw.println("return " + numberValue.getValue() + "F;"); + } else if (returnType == JPrimitiveType.DOUBLE) { + sw.println("return " + numberValue.getValue() + ";"); + } else { + logger.log(TreeLogger.ERROR, returnType.getQualifiedSourceName() + + " is not a valid return type for @def accessors"); + throw new UnableToCompleteException(); + } + sw.outdent(); + sw.println("}"); + + numberValue.getValue(); + } +}
diff --git a/user/src/com/google/gwt/resources/rg/DataResourceGenerator.java b/user/src/com/google/gwt/resources/rg/DataResourceGenerator.java new file mode 100644 index 0000000..f90257a --- /dev/null +++ b/user/src/com/google/gwt/resources/rg/DataResourceGenerator.java
@@ -0,0 +1,74 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JMethod; +import com.google.gwt.resources.client.DataResource; +import com.google.gwt.resources.ext.ResourceContext; +import com.google.gwt.resources.ext.ResourceGeneratorUtil; +import com.google.gwt.user.rebind.SourceWriter; +import com.google.gwt.user.rebind.StringSourceWriter; + +import java.net.URL; + +/** + * Provides implementations of DataResource. + */ +public final class DataResourceGenerator extends AbstractResourceGenerator { + @Override + public String createAssignment(TreeLogger logger, ResourceContext context, + JMethod method) throws UnableToCompleteException { + + URL[] resources = ResourceGeneratorUtil.findResources(logger, context, + method); + + if (resources.length != 1) { + logger.log(TreeLogger.ERROR, "Exactly one resource must be specified", + null); + throw new UnableToCompleteException(); + } + + URL resource = resources[0]; + String outputUrlExpression = context.deploy(resource, false); + + SourceWriter sw = new StringSourceWriter(); + // Write the expression to create the subtype. + sw.println("new " + DataResource.class.getName() + "() {"); + sw.indent(); + + // Convenience when examining the generated code. + sw.println("// " + resource.toExternalForm()); + + sw.println("public String getUrl() {"); + sw.indent(); + sw.println("return " + outputUrlExpression + ";"); + sw.outdent(); + sw.println("}"); + + sw.println("public String getName() {"); + sw.indent(); + sw.println("return \"" + method.getName() + "\";"); + sw.outdent(); + sw.println("}"); + + sw.outdent(); + sw.println("}"); + + return sw.toString(); + } +}
diff --git a/user/src/com/google/gwt/resources/rg/ExternalTextResourceGenerator.java b/user/src/com/google/gwt/resources/rg/ExternalTextResourceGenerator.java new file mode 100644 index 0000000..c5f3d31 --- /dev/null +++ b/user/src/com/google/gwt/resources/rg/ExternalTextResourceGenerator.java
@@ -0,0 +1,146 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +import com.google.gwt.core.ext.Generator; +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JClassType; +import com.google.gwt.core.ext.typeinfo.JMethod; +import com.google.gwt.core.ext.typeinfo.JType; +import com.google.gwt.core.ext.typeinfo.TypeOracle; +import com.google.gwt.dev.util.Util; +import com.google.gwt.resources.client.TextResource; +import com.google.gwt.resources.client.impl.ExternalTextResourcePrototype; +import com.google.gwt.resources.ext.ClientBundleFields; +import com.google.gwt.resources.ext.ClientBundleRequirements; +import com.google.gwt.resources.ext.ResourceContext; +import com.google.gwt.resources.ext.ResourceGeneratorUtil; +import com.google.gwt.user.rebind.SourceWriter; +import com.google.gwt.user.rebind.StringSourceWriter; + +import java.net.URL; +import java.util.HashMap; +import java.util.Map; + +/** + * Adds {@link ExternalTextResourcePrototype} objects to the bundle. + */ +public final class ExternalTextResourceGenerator extends + AbstractResourceGenerator { + private static final String[] DEFAULT_EXTENSIONS = new String[] {".txt"}; + private StringBuffer data; + private boolean first; + private String urlExpression; + private Map<String, Integer> hashes; + private Map<String, Integer> offsets; + private int currentIndex; + + private String externalTextUrlIdent; + + private String externalTextCacheIdent; + + @Override + public String createAssignment(TreeLogger logger, ResourceContext context, + JMethod method) throws UnableToCompleteException { + String name = method.getName(); + + SourceWriter sw = new StringSourceWriter(); + sw.println("new " + ExternalTextResourcePrototype.class.getName() + "("); + sw.indent(); + sw.println('"' + name + "\","); + // These are field names + sw.println(externalTextUrlIdent + ", " + externalTextCacheIdent + ", "); + sw.println(offsets.get(method.getName()).toString()); + sw.outdent(); + sw.print(")"); + + return sw.toString(); + } + + @Override + public void createFields(TreeLogger logger, ResourceContext context, + ClientBundleFields fields) throws UnableToCompleteException { + data.append(']'); + + urlExpression = context.deploy( + context.getClientBundleType().getQualifiedSourceName().replace('.', '_') + + "_jsonbundle.txt", "text/plain", data.toString().getBytes(), true); + + TypeOracle typeOracle = context.getGeneratorContext().getTypeOracle(); + JClassType stringType = typeOracle.findType(String.class.getName()); + assert stringType != null; + + externalTextUrlIdent = fields.define(stringType, "externalTextUrl", + urlExpression, true, true); + + JClassType textResourceType = typeOracle.findType(TextResource.class.getName()); + assert textResourceType != null; + JType textResourceArrayType = typeOracle.getArrayType(textResourceType); + + externalTextCacheIdent = fields.define(textResourceArrayType, + "externalTextCache", "new " + TextResource.class.getName() + "[" + + currentIndex + "]", true, true); + } + + @Override + public void init(TreeLogger logger, ResourceContext context) + throws UnableToCompleteException { + data = new StringBuffer("[\n"); + first = true; + urlExpression = null; + hashes = new HashMap<String, Integer>(); + offsets = new HashMap<String, Integer>(); + currentIndex = 0; + } + + @Override + public void prepare(TreeLogger logger, ResourceContext context, + ClientBundleRequirements requirements, JMethod method) + throws UnableToCompleteException { + + URL[] urls = ResourceGeneratorUtil.findResources(logger, context, method, + DEFAULT_EXTENSIONS); + + if (urls.length != 1) { + logger.log(TreeLogger.ERROR, "Exactly one resource must be specified", + null); + throw new UnableToCompleteException(); + } + + URL resource = urls[0]; + + String toWrite = Util.readURLAsString(resource); + + // This de-duplicates strings in the bundle. + if (!hashes.containsKey(toWrite)) { + hashes.put(toWrite, currentIndex++); + + if (!first) { + data.append(",\n"); + } else { + first = false; + } + + data.append('"'); + data.append(Generator.escape(toWrite)); + data.append('"'); + } + + // Store the (possibly n:1) mapping of resource function to bundle index. + offsets.put(method.getName(), hashes.get(toWrite)); + } +}
diff --git a/user/src/com/google/gwt/resources/rg/GwtCreateResourceGenerator.java b/user/src/com/google/gwt/resources/rg/GwtCreateResourceGenerator.java new file mode 100644 index 0000000..8b981f4 --- /dev/null +++ b/user/src/com/google/gwt/resources/rg/GwtCreateResourceGenerator.java
@@ -0,0 +1,61 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +import com.google.gwt.core.client.GWT; +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JClassType; +import com.google.gwt.core.ext.typeinfo.JMethod; +import com.google.gwt.core.ext.typeinfo.JParameterizedType; +import com.google.gwt.resources.client.GwtCreateResource.ClassType; +import com.google.gwt.resources.ext.ResourceContext; + +/** + * Provides implementations of GwtCreateResource. + */ +public class GwtCreateResourceGenerator extends AbstractResourceGenerator { + + @Override + public String createAssignment(TreeLogger logger, ResourceContext context, + JMethod method) throws UnableToCompleteException { + JParameterizedType returnType = method.getReturnType().isParameterized(); + assert returnType != null; + + JClassType args[] = returnType.getTypeArgs(); + assert args.length == 1; + + ClassType override = method.getAnnotation(ClassType.class); + JClassType toCreate; + if (override != null) { + toCreate = context.getGeneratorContext().getTypeOracle().findType( + override.value().getName().replace('$', '.')); + assert toCreate != null; + } else { + toCreate = args[0]; + } + + JClassType gwtType = context.getGeneratorContext().getTypeOracle().findType( + GWT.class.getName()); + assert gwtType != null; + + return "new " + returnType.getParameterizedQualifiedSourceName() + + "() {\n public " + toCreate.getQualifiedSourceName() + + " create() {\n return " + gwtType.getQualifiedSourceName() + + ".create(" + toCreate.getQualifiedSourceName() + ".class);}\n" + + "public String getName() { return \"" + method.getName() + "\";}}"; + } +}
diff --git a/user/src/com/google/gwt/resources/rg/ImageBundleBuilder.java b/user/src/com/google/gwt/resources/rg/ImageBundleBuilder.java new file mode 100644 index 0000000..46ce8c2 --- /dev/null +++ b/user/src/com/google/gwt/resources/rg/ImageBundleBuilder.java
@@ -0,0 +1,662 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.resources.ext.ResourceContext; + +import java.awt.Graphics2D; +import java.awt.geom.AffineTransform; +import java.awt.image.BufferedImage; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.net.URL; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import javax.imageio.ImageIO; + +/** + * Accumulates state for the bundled image. + */ +class ImageBundleBuilder { + /** + * Abstracts the process of arranging a number of images into a composite + * image. + */ + interface Arranger { + /** + * Determine the total area required to store a composite image. + */ + Size arrangeImages(Collection<HasRect> rects); + } + + /** + * Arranges the images to try to decrease the overall area of the resulting + * bundle. This uses a strategy that is basically Next-Fit Decreasing Height + * Decreasing Width (NFDHDW). The rectangles to be packed are sorted in + * decreasing order by height. The tallest rectangle is placed at the far + * left. We attempt to stack the remaining rectangles on top of one another to + * construct as many columns as necessary. After finishing each column, we + * also attempt to do some horizontal packing to fill up the space left due to + * widths of rectangles differing in the column. + */ + static class BestFitArranger implements Arranger { + private static final Comparator<HasRect> decreasingHeightComparator = new Comparator<HasRect>() { + public int compare(HasRect a, HasRect b) { + final int c = b.getHeight() - a.getHeight(); + // If we encounter equal heights, use the name to keep things + // deterministic. + return (c != 0) ? c : b.getName().compareTo(a.getName()); + } + }; + + private static final Comparator<HasRect> decreasingWidthComparator = new Comparator<HasRect>() { + public int compare(HasRect a, HasRect b) { + final int c = b.getWidth() - a.getWidth(); + // If we encounter equal heights, use the name to keep things + // deterministic. + return (c != 0) ? c : b.getName().compareTo(a.getName()); + } + }; + + public Size arrangeImages(Collection<HasRect> rects) { + if (rects.size() == 0) { + return new Size(0, 0); + } + + // Create a list of ImageRects ordered by decreasing height used for + // constructing columns. + final ArrayList<HasRect> rectsOrderedByHeight = new ArrayList<HasRect>( + rects); + Collections.sort(rectsOrderedByHeight, decreasingHeightComparator); + + // Create a list of ImageRects ordered by decreasing width used for + // packing + // individual columns. + final ArrayList<HasRect> rectsOrderedByWidth = new ArrayList<HasRect>( + rects); + Collections.sort(rectsOrderedByWidth, decreasingWidthComparator); + + // Place the first, tallest image as the first column. + final HasRect first = rectsOrderedByHeight.get(0); + first.setPosition(0, 0); + + // Setup state for laying things cumulatively. + int curX = first.getWidth(); + final int colH = first.getHeight(); + + for (int i = 1, n = rectsOrderedByHeight.size(); i < n; i++) { + // If this ImageRect has been positioned already, move on. + if (rectsOrderedByHeight.get(i).hasBeenPositioned()) { + continue; + } + + int colW = 0; + int curY = 0; + + final ArrayList<HasRect> rectsInColumn = new ArrayList<HasRect>(); + for (int j = i; j < n; j++) { + final HasRect current = rectsOrderedByHeight.get(j); + // Look for rects that have not been positioned with a small enough + // height to go in this column. + if (!current.hasBeenPositioned() + && (curY + current.getHeight()) <= colH) { + + // Set the horizontal position here, the top field will be set in + // arrangeColumn after we've collected a full set of ImageRects. + current.setPosition(curX, 0); + colW = Math.max(colW, current.getWidth()); + curY += current.getHeight(); + + // Keep the ImageRects in this column in decreasing order by width. + final int pos = Collections.binarySearch(rectsInColumn, current, + decreasingWidthComparator); + assert pos < 0; + rectsInColumn.add(-1 - pos, current); + } + } + + // Having selected a set of ImageRects that fill out this column + // vertical, + // now we'll scan the remaining ImageRects to try to fit some in the + // horizontal gaps. + if (!rectsInColumn.isEmpty()) { + arrangeColumn(rectsInColumn, rectsOrderedByWidth); + } + + // We're done with that column, so move the horizontal accumulator by + // the + // width of the column we just finished. + curX += colW; + } + + return new Size(curX, colH); + } + + /** + * Companion method to {@link #arrangeImages()}. This method does a best + * effort horizontal packing of a column after it was packed vertically. + * This is the Decreasing Width part of Next-Fit Decreasing Height + * Decreasing Width. The basic strategy is to sort the remaining rectangles + * by decreasing width and try to fit them to the left of each of the + * rectangles we've already picked for this column. + * + * @param rectsInColumn the ImageRects that were already selected for this + * column + * @param remainingRectsOrderedByWidth the sub list of ImageRects that may + * not have been positioned yet + */ + private void arrangeColumn(List<HasRect> rectsInColumn, + List<HasRect> remainingRectsOrderedByWidth) { + final HasRect first = rectsInColumn.get(0); + + final int columnWidth = first.getWidth(); + int curY = first.getHeight(); + + // Skip this first ImageRect because it is guaranteed to consume the full + // width of the column. + for (int i = 1, m = rectsInColumn.size(); i < m; i++) { + final HasRect r = rectsInColumn.get(i); + // The ImageRect was previously positioned horizontally, now set the top + // field. + r.setPosition(r.getLeft(), curY); + int curX = r.getWidth(); + + // Search for ImageRects that are shorter than the left most ImageRect + // and + // narrow enough to fit in the column. + for (int j = 0, n = remainingRectsOrderedByWidth.size(); j < n; j++) { + final HasRect current = remainingRectsOrderedByWidth.get(j); + if (!current.hasBeenPositioned() + && (curX + current.getWidth()) <= columnWidth + && (current.getHeight() <= r.getHeight())) { + current.setPosition(r.getLeft() + curX, r.getTop()); + curX += current.getWidth(); + } + } + + // Update the vertical accumulator so we'll know where to place the next + // ImageRect. + curY += r.getHeight(); + } + } + } + + /** + * A mockable interface to test the image arrangement algorithms. + */ + interface HasRect { + + int getHeight(); + + BufferedImage getImage(); + + int getLeft(); + + String getName(); + + int getTop(); + + AffineTransform getTransform(); + + int getWidth(); + + boolean hasBeenPositioned(); + + void setPosition(int left, int top); + + AffineTransform transform(); + } + + /** + * Performs a simple horizontal arrangement of rectangles. Images will be + * tiled vertically to fill to fill the full height of the image. + */ + static class HorizontalArranger implements Arranger { + public Size arrangeImages(Collection<HasRect> rects) { + int height = 1; + int width = 0; + + for (HasRect rect : rects) { + rect.setPosition(width, 0); + width += rect.getWidth(); + height = lcm(height, rect.getHeight()); + } + + List<HasRect> toAdd = new ArrayList<HasRect>(); + for (HasRect rect : rects) { + int y = rect.getHeight(); + while (y < height) { + ImageRect newRect = new ImageRect(rect); + newRect.setPosition(rect.getLeft(), y); + y += rect.getHeight(); + toAdd.add(newRect); + } + } + rects.addAll(toAdd); + + return new Size(width, height); + } + } + + /** + * Does not rearrange the rectangles, but simply computes the size of the + * canvas needed to hold the images in their current positions. + */ + static class IdentityArranger implements Arranger { + public Size arrangeImages(Collection<HasRect> rects) { + int height = 0; + int width = 0; + + for (HasRect rect : rects) { + height = Math.max(height, rect.getTop() + rect.getHeight()); + width = Math.max(width, rect.getLeft() + rect.getWidth()); + } + + return new Size(width, height); + } + } + + /** + * The rectangle at which the original image is placed into the composite + * image. + */ + static class ImageRect implements HasRect { + + private boolean hasBeenPositioned; + private final int height, width; + private final BufferedImage image; + private int left, top; + private final String name; + private final AffineTransform transform = new AffineTransform(); + + /** + * Copy constructor. + */ + public ImageRect(HasRect other) { + this.name = other.getName(); + this.height = other.getHeight(); + this.width = other.getWidth(); + this.image = other.getImage(); + this.left = other.getLeft(); + this.top = other.getTop(); + setTransform(other.getTransform()); + } + + public ImageRect(String name, BufferedImage image) { + this.name = name; + this.image = image; + this.width = image.getWidth(); + this.height = image.getHeight(); + } + + public int getHeight() { + return height; + } + + public BufferedImage getImage() { + return image; + } + + public int getLeft() { + return left; + } + + public String getName() { + return name; + } + + public int getTop() { + return top; + } + + public AffineTransform getTransform() { + return new AffineTransform(transform); + } + + public int getWidth() { + return width; + } + + public boolean hasBeenPositioned() { + return hasBeenPositioned; + } + + public void setPosition(int left, int top) { + hasBeenPositioned = true; + this.left = left; + this.top = top; + } + + public void setTransform(AffineTransform transform) { + this.transform.setTransform(transform); + } + + public AffineTransform transform() { + AffineTransform toReturn = new AffineTransform(); + toReturn.translate(left, top); + toReturn.concatenate(transform); + + assert checkTransform(toReturn); + return toReturn; + } + + private boolean checkTransform(AffineTransform tx) { + double[] in = {0, 0, width, height}; + double[] out = {0, 0, 0, 0}; + + tx.transform(in, 0, out, 0, 2); + + assert width == Math.abs(out[0] - out[2]); + assert height == Math.abs(out[1] - out[3]); + assert out[0] >= 0; + assert out[1] >= 0; + assert out[2] >= 0; + assert out[3] >= 0; + + return true; + } + } + + /** + * Used to return the size of the resulting image from the method + * {@link ImageBundleBuilder#arrangeImages()}. + */ + static class Size { + private final int width, height; + + Size(int width, int height) { + this.width = width; + this.height = height; + } + } + + /** + * Performs a simple vertical arrangement of rectangles. Images will be tiled + * horizontally to fill the full width of the image. + */ + static class VerticalArranger implements Arranger { + public Size arrangeImages(Collection<HasRect> rects) { + int height = 0; + int width = 1; + + for (HasRect rect : rects) { + rect.setPosition(0, height); + width = lcm(width, rect.getWidth()); + height += rect.getHeight(); + } + + List<HasRect> toAdd = new ArrayList<HasRect>(); + for (HasRect rect : rects) { + int x = rect.getWidth(); + while (x < width) { + ImageRect newRect = new ImageRect(rect); + newRect.setPosition(x, rect.getTop()); + x += rect.getWidth(); + toAdd.add(newRect); + } + } + rects.addAll(toAdd); + + return new Size(width, height); + } + } + + /* + * Only PNG is supported right now. In the future, we may be able to infer the + * best output type, and get rid of this constant. + */ + private static final String BUNDLE_FILE_TYPE = "png"; + private static final String BUNDLE_MIME_TYPE = "image/png"; + private static final int IMAGE_MAX_SIZE = 256; + + public static byte[] toPng(TreeLogger logger, HasRect rect) + throws UnableToCompleteException { + // Create the bundled image. + BufferedImage bundledImage = new BufferedImage(rect.getWidth(), + rect.getHeight(), BufferedImage.TYPE_INT_ARGB_PRE); + Graphics2D g2d = bundledImage.createGraphics(); + + g2d.drawImage(rect.getImage(), rect.transform(), null); + g2d.dispose(); + + byte[] imageBytes; + + try { + ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream(); + ImageIO.write(bundledImage, BUNDLE_FILE_TYPE, byteOutputStream); + imageBytes = byteOutputStream.toByteArray(); + } catch (IOException e) { + logger.log(TreeLogger.ERROR, + "Unable to generate file name for image bundle file", null); + throw new UnableToCompleteException(); + } + return imageBytes; + } + + /** + * Compute the greatest common denominator of two numbers. + */ + private static int gcd(int a, int b) { + while (b != 0) { + int t = b; + b = a % b; + a = t; + } + return a; + } + + /** + * Compute the least common multiple of two numbers. This is used by + * {@link HorizontalArranger} and {@link VerticalArranger} to determine how + * large the composite image should be to allow every image to line up when + * repeated. + */ + private static int lcm(int a, int b) { + return b / gcd(a, b) * a; + } + + private final Map<String, ImageRect> imageNameToImageRectMap = new HashMap<String, ImageRect>(); + + public ImageBundleBuilder() { + } + + /** + * Copy constructor. + */ + public ImageBundleBuilder(ImageBundleBuilder other) { + for (Map.Entry<String, ImageRect> entry : other.imageNameToImageRectMap.entrySet()) { + imageNameToImageRectMap.put(entry.getKey(), new ImageRect( + entry.getValue())); + } + } + + /** + * Assimilates the image associated with a particular image method into the + * master composite. If the method names an image that has already been + * assimilated, the existing image rectangle is reused. + * + * @param logger a hierarchical logger which logs to the hosted console + * @param imageName the name of an image that can be found on the classpath + * @param resource the URL from which the image data wil be loaded + * @throws UnableToCompleteException if the image with name + * <code>imageName</code> cannot be added to the master composite + * image + */ + public ImageRect assimilate(TreeLogger logger, String imageName, URL resource) + throws UnableToCompleteException, UnsuitableForStripException { + + /* + * Decide whether or not we need to add to the composite image. Either way, + * we associated it with the rectangle of the specified image as it exists + * within the composite image. Note that the coordinates of the rectangle + * aren't computed until the composite is written. + */ + ImageRect rect = getMapping(imageName); + if (rect == null) { + // Assimilate the image into the composite. + rect = addImage(logger, imageName, resource); + + imageNameToImageRectMap.put(imageName, rect); + } + return rect; + } + + public int getImageCount() { + return imageNameToImageRectMap.size(); + } + + public ImageRect getMapping(String imageName) { + return imageNameToImageRectMap.get(imageName); + } + + public ImageRect removeMapping(String imageName) { + return imageNameToImageRectMap.remove(imageName); + } + + /** + * Write all images into the output. + * + * @param logger a hierarchical logger which logs to the hosted console + * @param context the local ResourceContext that is being used to accumulate + * output files + * @param arranger a provider of image layout logic + * @return a Java expression which will evaluate to the location of the + * composite image at runtime + */ + public String writeBundledImage(TreeLogger logger, ResourceContext context, + Arranger arranger) throws UnableToCompleteException { + + if (imageNameToImageRectMap.isEmpty()) { + return null; + } + + // Create the bundled image from all of the constituent images. + BufferedImage bundledImage = drawBundledImage(arranger); + + // Write the bundled image into a byte array, so that we can compute + // its strong name. + byte[] imageBytes; + + try { + ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream(); + ImageIO.write(bundledImage, BUNDLE_FILE_TYPE, byteOutputStream); + imageBytes = byteOutputStream.toByteArray(); + } catch (IOException e) { + logger.log(TreeLogger.ERROR, + "Unable to generate file name for image bundle file", null); + throw new UnableToCompleteException(); + } + + String bundleFileName = context.deploy( + context.getClientBundleType().getQualifiedSourceName() + ".cache." + + BUNDLE_FILE_TYPE, BUNDLE_MIME_TYPE, imageBytes, false); + + return bundleFileName; + } + + private ImageRect addImage(TreeLogger logger, String imageName, URL imageUrl) + throws UnableToCompleteException, UnsuitableForStripException { + + logger = logger.branch(TreeLogger.TRACE, + "Adding image '" + imageName + "'", null); + + BufferedImage image; + // Load the image + try { + image = ImageIO.read(imageUrl); + } catch (IllegalArgumentException iex) { + if (imageName.toLowerCase().endsWith("png") + && iex.getMessage() != null + && iex.getStackTrace()[0].getClassName().equals( + "javax.imageio.ImageTypeSpecifier$Indexed")) { + logger.log(TreeLogger.ERROR, + "Unable to read image. The image may not be in valid PNG format. " + + "This problem may also be due to a bug in versions of the " + + "JRE prior to 1.6. See " + + "http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5098176 " + + "for more information. If this bug is the cause of the " + + "error, try resaving the image using a different image " + + "program, or upgrade to a newer JRE.", null); + throw new UnableToCompleteException(); + } else { + throw iex; + } + } catch (IOException e) { + logger.log(TreeLogger.ERROR, "Unable to read image resource", null); + throw new UnableToCompleteException(); + } + + if (image == null) { + logger.log(TreeLogger.ERROR, "Unrecognized image file format", null); + throw new UnableToCompleteException(); + } + + ImageRect toReturn = new ImageRect(imageName, image); + + if (toReturn.height > IMAGE_MAX_SIZE || toReturn.width > IMAGE_MAX_SIZE) { + throw new UnsuitableForStripException(toReturn); + } + + return toReturn; + } + + /** + * This method creates the bundled image through the composition of the other + * images. + * + * In this particular implementation, we use NFDHDW (see + * {@link #arrangeImages()}) to get an approximate optimal image packing. + * + * The most important aspect of drawing the bundled image is that it be drawn + * in a deterministic way. The drawing of the image should not rely on + * implementation details of the Generator system which may be subject to + * change. + */ + private BufferedImage drawBundledImage(Arranger arranger) { + + /* + * There is no need to impose any order here, because arrangeImages will + * position the ImageRects in a deterministic fashion, even though we might + * paint them in a non-deterministic order. + */ + Collection<HasRect> imageRects = new LinkedList<HasRect>( + imageNameToImageRectMap.values()); + + // Arrange images and determine the size of the resulting bundle. + Size size = arranger.arrangeImages(imageRects); + + // Create the bundled image. + BufferedImage bundledImage = new BufferedImage(size.width, size.height, + BufferedImage.TYPE_INT_ARGB_PRE); + Graphics2D g2d = bundledImage.createGraphics(); + + for (HasRect imageRect : imageRects) { + g2d.drawImage(imageRect.getImage(), imageRect.transform(), null); + } + g2d.dispose(); + + return bundledImage; + } +}
diff --git a/user/src/com/google/gwt/resources/rg/ImageResourceGenerator.java b/user/src/com/google/gwt/resources/rg/ImageResourceGenerator.java new file mode 100644 index 0000000..e9c38a5 --- /dev/null +++ b/user/src/com/google/gwt/resources/rg/ImageResourceGenerator.java
@@ -0,0 +1,267 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JClassType; +import com.google.gwt.core.ext.typeinfo.JMethod; +import com.google.gwt.core.ext.typeinfo.TypeOracle; +import com.google.gwt.resources.client.ImageResource.ImageOptions; +import com.google.gwt.resources.client.ImageResource.RepeatStyle; +import com.google.gwt.resources.client.impl.ImageResourcePrototype; +import com.google.gwt.resources.ext.ClientBundleFields; +import com.google.gwt.resources.ext.ClientBundleRequirements; +import com.google.gwt.resources.ext.ResourceContext; +import com.google.gwt.resources.ext.ResourceGeneratorUtil; +import com.google.gwt.resources.rg.ImageBundleBuilder.Arranger; +import com.google.gwt.resources.rg.ImageBundleBuilder.ImageRect; +import com.google.gwt.user.rebind.SourceWriter; +import com.google.gwt.user.rebind.StringSourceWriter; + +import java.awt.geom.AffineTransform; +import java.net.URL; +import java.util.EnumMap; +import java.util.HashMap; +import java.util.HashSet; +import java.util.IdentityHashMap; +import java.util.Map; +import java.util.Set; + +/** + * Builds an image strip for all ImageResources defined within an ClientBundle. + */ +public final class ImageResourceGenerator extends AbstractResourceGenerator { + private static final String[] DEFAULT_EXTENSIONS = new String[] { + ".png", ".jpg", ".gif", ".bmp"}; + private Map<String, ImageRect> imageRectsByName; + private Map<ImageRect, ImageBundleBuilder> buildersByImageRect; + private Map<RepeatStyle, ImageBundleBuilder> buildersByRepeatStyle; + private Map<ImageBundleBuilder, String[]> urlsByBuilder; + private Map<ImageRect, String[]> urlsByExternalImageRect; + private Map<ImageRect, ImageBundleBuilder> rtlImages; + + @Override + public String createAssignment(TreeLogger logger, ResourceContext context, + JMethod method) throws UnableToCompleteException { + String name = method.getName(); + + SourceWriter sw = new StringSourceWriter(); + sw.println("new " + ImageResourcePrototype.class.getName() + "("); + sw.indent(); + sw.println('"' + name + "\","); + + ImageRect rect = imageRectsByName.get(name); + assert rect != null : "No ImageRect ever computed for " + name; + + String[] urlExpressions; + { + ImageBundleBuilder builder = buildersByImageRect.get(rect); + if (builder == null) { + urlExpressions = urlsByExternalImageRect.get(rect); + } else { + urlExpressions = urlsByBuilder.get(builder); + } + } + assert urlExpressions != null : "No URL expression for " + name; + assert urlExpressions.length == 2; + + if (urlExpressions[1] == null) { + sw.println(urlExpressions[0] + ","); + } else { + sw.println("com.google.gwt.i18n.client.LocaleInfo.getCurrentLocale().isRTL() ?" + + urlExpressions[1] + " : " + urlExpressions[0] + ","); + } + sw.println(rect.getLeft() + ", " + rect.getTop() + ", " + rect.getWidth() + + ", " + rect.getHeight()); + + sw.outdent(); + sw.print(")"); + + return sw.toString(); + } + + @Override + public void createFields(TreeLogger logger, ResourceContext context, + ClientBundleFields fields) throws UnableToCompleteException { + + TypeOracle typeOracle = context.getGeneratorContext().getTypeOracle(); + JClassType stringType = typeOracle.findType(String.class.getName()); + assert stringType != null; + + Map<ImageBundleBuilder, String> prettyNames = new IdentityHashMap<ImageBundleBuilder, String>(); + + for (Map.Entry<RepeatStyle, ImageBundleBuilder> entry : buildersByRepeatStyle.entrySet()) { + RepeatStyle repeatStyle = entry.getKey(); + ImageBundleBuilder builder = entry.getValue(); + Arranger arranger; + + switch (repeatStyle) { + case None: + arranger = new ImageBundleBuilder.BestFitArranger(); + break; + case Horizontal: + arranger = new ImageBundleBuilder.VerticalArranger(); + break; + case Vertical: + arranger = new ImageBundleBuilder.HorizontalArranger(); + break; + case Both: + // This is taken care of when writing the external images; + continue; + default: + logger.log(TreeLogger.ERROR, "Unknown RepeatStyle" + repeatStyle); + throw new UnableToCompleteException(); + } + + String bundleUrlExpression = builder.writeBundledImage(logger.branch( + TreeLogger.DEBUG, "Writing image strip", null), context, arranger); + + if (bundleUrlExpression == null) { + continue; + } + + String prettyName = "imageUrl" + repeatStyle; + prettyNames.put(builder, prettyName); + String fieldName = fields.define(stringType, prettyName, + bundleUrlExpression, true, true); + String[] strings = {fieldName, null}; + urlsByBuilder.put(builder, strings); + } + + if (rtlImages.size() > 0) { + Set<ImageBundleBuilder> rtlBuilders = new HashSet<ImageBundleBuilder>(); + + for (Map.Entry<ImageRect, ImageBundleBuilder> entry : rtlImages.entrySet()) { + ImageRect rtlImage = entry.getKey(); + + AffineTransform tx = new AffineTransform(); + tx.setTransform(-1, 0, 0, 1, rtlImage.getWidth(), 0); + + rtlImage.setTransform(tx); + + if (buildersByImageRect.containsKey(rtlImage)) { + rtlBuilders.add(buildersByImageRect.get(rtlImage)); + } else { + String[] strings = urlsByExternalImageRect.get(rtlImage); + assert strings != null; + byte[] imageBytes = ImageBundleBuilder.toPng(logger, rtlImage); + strings[1] = context.deploy(rtlImage.getName() + "_rtl.png", + "image/png", imageBytes, false); + } + } + + for (ImageBundleBuilder builder : rtlBuilders) { + String bundleUrlExpression = builder.writeBundledImage(logger.branch( + TreeLogger.DEBUG, "Writing image strip", null), context, + new ImageBundleBuilder.IdentityArranger()); + + if (bundleUrlExpression == null) { + continue; + } + + String prettyName = prettyNames.get(builder); + String[] strings = urlsByBuilder.get(builder); + assert strings != null; + + strings[1] = fields.define(stringType, prettyName + "_rtl", + bundleUrlExpression, true, true); + } + } + } + + @Override + public void init(TreeLogger logger, ResourceContext context) { + imageRectsByName = new HashMap<String, ImageRect>(); + buildersByImageRect = new IdentityHashMap<ImageRect, ImageBundleBuilder>(); + buildersByRepeatStyle = new EnumMap<RepeatStyle, ImageBundleBuilder>( + RepeatStyle.class); + rtlImages = new IdentityHashMap<ImageRect, ImageBundleBuilder>(); + urlsByBuilder = new IdentityHashMap<ImageBundleBuilder, String[]>(); + urlsByExternalImageRect = new IdentityHashMap<ImageRect, String[]>(); + } + + @Override + public void prepare(TreeLogger logger, ResourceContext context, + ClientBundleRequirements requirements, JMethod method) + throws UnableToCompleteException { + URL[] resources = ResourceGeneratorUtil.findResources(logger, context, + method, DEFAULT_EXTENSIONS); + + if (resources.length != 1) { + logger.log(TreeLogger.ERROR, "Exactly one image may be specified", null); + throw new UnableToCompleteException(); + } + + ImageBundleBuilder builder = getBuilder(method); + URL resource = resources[0]; + String name = method.getName(); + + ImageRect rect; + try { + rect = builder.assimilate(logger, name, resource); + if (context.supportsDataUrls() + || getRepeatStyle(method) == RepeatStyle.Both) { + // Just use the calculated meta-data + builder.removeMapping(name); + rect.setPosition(0, 0); + throw new UnsuitableForStripException(rect); + } + buildersByImageRect.put(rect, builder); + } catch (UnsuitableForStripException e) { + // Add the image to the output as a separate resource + rect = e.getImageRect(); + byte[] imageBytes = ImageBundleBuilder.toPng(logger, rect); + String urlExpression = context.deploy(rect.getName() + ".png", + "image/png", imageBytes, false); + urlsByExternalImageRect.put(rect, new String[] {urlExpression, null}); + } + + imageRectsByName.put(name, rect); + + if (getFlipRtl(method)) { + rtlImages.put(rect, null); + } + } + + private ImageBundleBuilder getBuilder(JMethod method) { + RepeatStyle repeatStyle = getRepeatStyle(method); + ImageBundleBuilder builder = buildersByRepeatStyle.get(repeatStyle); + if (builder == null) { + builder = new ImageBundleBuilder(); + buildersByRepeatStyle.put(repeatStyle, builder); + } + return builder; + } + + private boolean getFlipRtl(JMethod method) { + ImageOptions options = method.getAnnotation(ImageOptions.class); + if (options == null) { + return false; + } else { + return options.flipRtl(); + } + } + + private RepeatStyle getRepeatStyle(JMethod method) { + ImageOptions options = method.getAnnotation(ImageOptions.class); + if (options == null) { + return RepeatStyle.None; + } else { + return options.repeatStyle(); + } + } +}
diff --git a/user/src/com/google/gwt/resources/rg/TextResourceGenerator.java b/user/src/com/google/gwt/resources/rg/TextResourceGenerator.java new file mode 100644 index 0000000..88b3d33 --- /dev/null +++ b/user/src/com/google/gwt/resources/rg/TextResourceGenerator.java
@@ -0,0 +1,80 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +import com.google.gwt.core.ext.Generator; +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JMethod; +import com.google.gwt.dev.util.Util; +import com.google.gwt.resources.client.TextResource; +import com.google.gwt.resources.ext.ResourceContext; +import com.google.gwt.resources.ext.ResourceGeneratorUtil; +import com.google.gwt.user.rebind.SourceWriter; +import com.google.gwt.user.rebind.StringSourceWriter; + +import java.net.URL; + +/** + * Provides implementations of TextResource. + */ +public final class TextResourceGenerator extends AbstractResourceGenerator { + + private static final String[] DEFAULT_EXTENSIONS = new String[] {".txt"}; + + @Override + public String createAssignment(TreeLogger logger, ResourceContext context, + JMethod method) throws UnableToCompleteException { + URL[] resources = ResourceGeneratorUtil.findResources(logger, context, + method, DEFAULT_EXTENSIONS); + + if (resources.length != 1) { + logger.log(TreeLogger.ERROR, "Exactly one resource must be specified", + null); + throw new UnableToCompleteException(); + } + + URL resource = resources[0]; + + SourceWriter sw = new StringSourceWriter(); + // Write the expression to create the subtype. + sw.println("new " + TextResource.class.getName() + "() {"); + sw.indent(); + + // Convenience when examining the generated code. + sw.println("// " + resource.toExternalForm()); + + sw.println("public String getText() {"); + sw.indent(); + + String toWrite = Util.readURLAsString(resource); + + sw.println("return \"" + Generator.escape(toWrite) + "\";"); + sw.outdent(); + sw.println("}"); + + sw.println("public String getName() {"); + sw.indent(); + sw.println("return \"" + method.getName() + "\";"); + sw.outdent(); + sw.println("}"); + + sw.outdent(); + sw.println("}"); + + return sw.toString(); + } +}
diff --git a/user/src/com/google/gwt/resources/rg/UnsuitableForStripException.java b/user/src/com/google/gwt/resources/rg/UnsuitableForStripException.java new file mode 100644 index 0000000..038dfa8 --- /dev/null +++ b/user/src/com/google/gwt/resources/rg/UnsuitableForStripException.java
@@ -0,0 +1,43 @@ +/* + * Copyright 2007 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +/** + * Indicates that an image is not suitable for being added to an image strip. + */ +class UnsuitableForStripException extends Exception { + + private static final long serialVersionUID = -1; + private final ImageBundleBuilder.ImageRect rect; + + public UnsuitableForStripException(ImageBundleBuilder.ImageRect rect) { + this.rect = rect; + } + + public UnsuitableForStripException(ImageBundleBuilder.ImageRect rect, String msg) { + super(msg); + this.rect = rect; + } + + public UnsuitableForStripException(String msg, Throwable cause) { + super(msg, cause); + this.rect = null; + } + + public ImageBundleBuilder.ImageRect getImageRect() { + return rect; + } +}
diff --git a/user/src/com/google/gwt/user/rebind/StringSourceWriter.java b/user/src/com/google/gwt/user/rebind/StringSourceWriter.java new file mode 100644 index 0000000..78a2cd5 --- /dev/null +++ b/user/src/com/google/gwt/user/rebind/StringSourceWriter.java
@@ -0,0 +1,99 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.user.rebind; + +import com.google.gwt.core.ext.TreeLogger; + +import java.io.PrintWriter; +import java.io.StringWriter; + +/** + * A SourceWriter that accumulates source and returns it in the + * {@link #toString()} method. + */ +public class StringSourceWriter implements SourceWriter { + + private final StringWriter buffer = new StringWriter(); + private int indentLevel = 0; + private String indentPrefix = ""; + private boolean needsIndent; + private final PrintWriter out = new PrintWriter(buffer); + + public void beginJavaDocComment() { + out.println("/**"); + indent(); + indentPrefix = " * "; + } + + /** + * This is a no-op. + */ + public void commit(TreeLogger logger) { + out.flush(); + } + + public void endJavaDocComment() { + out.println("*/"); + outdent(); + indentPrefix = ""; + } + + public void indent() { + indentLevel++; + } + + public void indentln(String s) { + indent(); + println(s); + outdent(); + } + + public void outdent() { + indentLevel = Math.max(indentLevel - 1, 0); + } + + public void print(String s) { + maybeIndent(); + out.print(s); + } + + public void println() { + maybeIndent(); + out.println(); + needsIndent = true; + } + + public void println(String s) { + print(s); + println(); + } + + @Override + public String toString() { + out.flush(); + return buffer.getBuffer().toString(); + } + + private void maybeIndent() { + if (needsIndent) { + needsIndent = false; + for (int i = 0; i < indentLevel; i++) { + out.print(" "); + out.print(indentPrefix); + } + } + } +}
diff --git a/user/test/com/google/gwt/resources/ResourcesSuite.java b/user/test/com/google/gwt/resources/ResourcesSuite.java new file mode 100644 index 0000000..79d9385 --- /dev/null +++ b/user/test/com/google/gwt/resources/ResourcesSuite.java
@@ -0,0 +1,46 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources; + +import com.google.gwt.junit.tools.GWTTestSuite; +import com.google.gwt.resources.client.CSSResourceTest; +import com.google.gwt.resources.client.ImageResourceTest; +import com.google.gwt.resources.client.NestedBundleTest; +import com.google.gwt.resources.client.TextResourceTest; +import com.google.gwt.resources.rg.CssNodeClonerTest; +import com.google.gwt.resources.rg.CssReorderTest; +import com.google.gwt.resources.rg.CssRtlTest; + +import junit.framework.Test; + +/** + * Tests the ClientBundle framework. + */ +public class ResourcesSuite { + public static Test suite() { + + GWTTestSuite suite = new GWTTestSuite("Test for com.google.gwt.resources"); + suite.addTestSuite(CSSResourceTest.class); + suite.addTestSuite(CssReorderTest.class); + suite.addTestSuite(CssRtlTest.class); + suite.addTestSuite(CssNodeClonerTest.class); + suite.addTestSuite(ImageResourceTest.class); + suite.addTestSuite(NestedBundleTest.class); + suite.addTestSuite(TextResourceTest.class); + + return suite; + } +}
diff --git a/user/test/com/google/gwt/resources/client/16x16.png b/user/test/com/google/gwt/resources/client/16x16.png new file mode 100644 index 0000000..77e06ba --- /dev/null +++ b/user/test/com/google/gwt/resources/client/16x16.png Binary files differ
diff --git a/user/test/com/google/gwt/resources/client/32x32.png b/user/test/com/google/gwt/resources/client/32x32.png new file mode 100644 index 0000000..55af260 --- /dev/null +++ b/user/test/com/google/gwt/resources/client/32x32.png Binary files differ
diff --git a/user/test/com/google/gwt/resources/client/64x64-dup.png b/user/test/com/google/gwt/resources/client/64x64-dup.png new file mode 100644 index 0000000..e437adc --- /dev/null +++ b/user/test/com/google/gwt/resources/client/64x64-dup.png Binary files differ
diff --git a/user/test/com/google/gwt/resources/client/64x64.png b/user/test/com/google/gwt/resources/client/64x64.png new file mode 100644 index 0000000..e437adc --- /dev/null +++ b/user/test/com/google/gwt/resources/client/64x64.png Binary files differ
diff --git a/user/test/com/google/gwt/resources/client/CSSResourceTest.java b/user/test/com/google/gwt/resources/client/CSSResourceTest.java new file mode 100644 index 0000000..dca1c2d --- /dev/null +++ b/user/test/com/google/gwt/resources/client/CSSResourceTest.java
@@ -0,0 +1,279 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +import com.google.gwt.core.client.GWT; +import com.google.gwt.junit.client.GWTTestCase; +import com.google.gwt.resources.client.CssResource.Import; +import com.google.gwt.resources.client.CssResource.ImportedWithPrefix; +import com.google.gwt.resources.client.CssResource.Shared; +import com.google.gwt.resources.client.CssResource.Strict; + +/** + * + */ +public class CSSResourceTest extends GWTTestCase { + + interface ConcatenatedResources extends ClientBundle { + @Source(value = {"concatenatedA.css", "concatenatedB.css"}) + CssResource css(); + } + + interface CssWithDefines extends CssResource { + double lengthFloat(); + + int lengthInt(); + + double percentFloat(); + + int percentInt(); + + double rawDouble(); + + float rawFloat(); + + int rawInt(); + } + + interface MyCssResource extends CssResource, MyNonCssResource { + @ClassName("replacement-not-java-ident") + String nameOverride(); + } + + interface MyCssResourceA extends MyCssResource, SharedClasses { + String local(); + + // This shouldn't make a difference + String replacement(); + } + + @ImportedWithPrefix("gwt-MyCssResourceB") + interface MyCssResourceB extends MyCssResource, SharedClasses { + String local(); + + String sharedOverrideClass(); + } + + /* + * Check type inheritance. + */ + interface MyCssResourceWithSprite extends MyCssResource { + String extraSpriteClass(); + + String multiClassA(); + + String multiClassB(); + } + + interface MyNonCssResource { + String nameOverride(); + + String replacement(); + } + + interface Resources extends ClientBundle { + Resources INSTANCE = GWT.create(Resources.class); + + @Source("siblingTestA.css") + MyCssResourceA a(); + + @Source("siblingTestB.css") + MyCssResourceB b(); + + @Source("test.css") + MyCssResourceWithSprite css(); + + @Source("32x32.png") + DataResource dataMethod(); + + // Test default extensions + CssWithDefines deftest(); + + @Source("unrelatedDescendants.css") + @Import(value = {MyCssResourceA.class, MyCssResourceB.class}) + @Strict + CssResource descendants(); + + @Source("16x16.png") + ImageResource spriteMethod(); + } + + interface SharedBase extends CssResource { + String unsharedClass(); + } + + @ImportedWithPrefix("gwt-Shared") + @Shared + interface SharedClasses extends SharedBase { + String sharedClass(); + + String sharedOverrideClass(); + } + + interface SiblingResources extends ClientBundle { + @Source("siblingTestA.css") + MyCssResourceA a(); + + @Source("siblingTestB.css") + MyCssResourceB b(); + } + + public static String red() { + return "orange"; + } + + @Override + public String getModuleName() { + return "com.google.gwt.resources.Resources"; + } + + public void report(String s) { + // Can be filled in if debugging. + System.out.println(s); + } + + public void testConcatenatedResource() { + ConcatenatedResources r = GWT.create(ConcatenatedResources.class); + String text = r.css().getText(); + assertTrue(text.contains(".partA")); + assertTrue(text.contains(".partB")); + } + + public void testCss() { + MyCssResourceWithSprite css = Resources.INSTANCE.css(); + String text = css.getText(); + report(text); + + // Check the sprite + assertTrue(text.contains("height:16px")); + assertTrue(text.contains("width:16px")); + + // Check the value() expansion + assertTrue(text.contains("offset-left:\"guard\" 16px !important;")); + assertTrue(text.contains("offset:16px 16px;")); + + // Make sure renaming works + assertFalse("replacement".equals(css.replacement())); + assertTrue(text.contains("." + css.replacement())); + assertTrue(text.contains("." + css.replacement() + ":after")); + assertTrue(text.contains("." + css.nameOverride())); + + // Make sure renaming for multi-class selectors (.foo.bar) works + assertFalse("multiClassA".equals(css.multiClassA())); + assertFalse("multiClassB".equals(css.multiClassB())); + assertTrue(text.contains("." + css.multiClassA() + "." + css.multiClassB())); + + // Check static if evaluation + assertTrue(text.contains("static:PASSED;")); + assertFalse(text.contains("FAIL")); + + // Check runtime if evaluation + assertTrue(text.contains("runtime:PASSED;")); + + // Check interestingly-named idents + assertTrue(text.contains("\\-some-wacky-extension")); + assertTrue(text.contains(".ns\\:tag")); + assertTrue(text.contains(".ns\\:tag:pseudo")); + + // Check escaped string values + assertTrue(text.contains("\"Hello\\\\\\\" world\"")); + + // Check values + assertFalse(text.contains("0.0;")); + assertFalse(text.contains("0.0px;")); + assertFalse(text.contains("0px;")); + assertTrue(text.contains("background-color:#fff;")); + assertTrue(text.contains("content:\"bar\";")); + + // Check invalid CSS values + assertTrue(text.contains("top:expression(document.compatMode==\"CSS1Compat\" ? documentElement.scrollTop:document.body.scrollTop \\ 2);")); + + // Check data URL expansion + assertTrue(text.contains(Resources.INSTANCE.dataMethod().getUrl())); + + // Check @eval expansion + assertTrue(text.contains(red() + ";")); + + // Check @def substitution + assertTrue(text.contains("50px")); + + // Check merging semantics + assertTrue(text.indexOf("static:PASSED") < text.indexOf("runtime:PASSED")); + assertTrue(text.indexOf("before:merge") != -1); + assertTrue(text.indexOf("before:merge") < text.indexOf("after:merge")); + assertTrue(text.indexOf(".may-combine,.may-combine2") != -1); + assertTrue(text.indexOf("merge:merge") != -1); + assertTrue(text.indexOf("merge:merge") < text.indexOf("may-not-combine")); + assertTrue(text.indexOf("may-not-combine") < text.indexOf("prevent:true")); + assertTrue(text.indexOf("prevent:true") < text.indexOf("prevent-merge:true")); + assertTrue(text.indexOf("prevent:true") < text.indexOf("may-not-combine2")); + + // Check commonly-used CSS3 constructs + assertTrue(text.contains("background-color:rgba(0,0,0,0.5);")); + } + + public void testDefines() { + Resources r = GWT.create(Resources.class); + CssWithDefines defines = r.deftest(); + + assertEquals(1, defines.rawInt()); + assertEquals(1.5F, defines.rawFloat()); + assertEquals(1.5, defines.rawDouble()); + + assertEquals(50, defines.lengthInt()); + assertEquals(1.5, defines.lengthFloat()); + + assertEquals(50, defines.percentInt()); + assertEquals(50.5, defines.percentFloat()); + } + + public void testMultipleBundles() { + Resources r1 = GWT.create(Resources.class); + SiblingResources r2 = GWT.create(SiblingResources.class); + + assertEquals(r1.a().replacement(), r2.a().replacement()); + assertEquals(r1.b().replacement(), r2.b().replacement()); + + assertEquals(r1.a().sharedClass(), r2.b().sharedClass()); + assertFalse(r1.a().sharedOverrideClass().equals( + r2.b().sharedOverrideClass())); + assertFalse(r1.a().unsharedClass().equals(r2.b().unsharedClass())); + + String text = r1.descendants().getText(); + report(text); + assertTrue(text.contains("." + r1.a().local() + " ." + r1.b().local())); + } + + public void testSiblingCSS() { + SiblingResources r = GWT.create(SiblingResources.class); + + assertFalse(r.a().replacement().equals(r.b().replacement())); + assertFalse(r.a().local().equals(r.b().local())); + + String a = r.a().getText(); + String b = r.b().getText(); + + report(a); + report(b); + + assertTrue(a.contains(".other")); + assertTrue(b.contains(".other")); + assertTrue(a.contains(r.a().local())); + assertTrue(b.contains(r.b().local())); + assertFalse(a.contains(r.b().local())); + assertFalse(b.contains(r.a().local())); + } +}
diff --git a/user/test/com/google/gwt/resources/client/ImageResourceTest.java b/user/test/com/google/gwt/resources/client/ImageResourceTest.java new file mode 100644 index 0000000..982af95 --- /dev/null +++ b/user/test/com/google/gwt/resources/client/ImageResourceTest.java
@@ -0,0 +1,130 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +import com.google.gwt.core.client.GWT; +import com.google.gwt.event.dom.client.ErrorEvent; +import com.google.gwt.event.dom.client.ErrorHandler; +import com.google.gwt.event.dom.client.LoadEvent; +import com.google.gwt.event.dom.client.LoadHandler; +import com.google.gwt.junit.client.GWTTestCase; +import com.google.gwt.resources.client.ImageResource.ImageOptions; +import com.google.gwt.resources.client.ImageResource.RepeatStyle; +import com.google.gwt.user.client.ui.Image; +import com.google.gwt.user.client.ui.RootPanel; + +/** + * Tests ImageResource generation. + */ +public class ImageResourceTest extends GWTTestCase { + static interface Resources extends ClientBundle { + @Source("16x16.png") + ImageResource i16x16(); + + @Source("16x16.png") + @ImageOptions(repeatStyle = RepeatStyle.Horizontal) + ImageResource i16x16Horizontal(); + + @Source("16x16.png") + @ImageOptions(repeatStyle = RepeatStyle.Vertical) + ImageResource i16x16Vertical(); + + @Source("32x32.png") + ImageResource i32x32(); + + @Source("32x32.png") + @ImageOptions(repeatStyle = RepeatStyle.Horizontal) + ImageResource i32x32Horizontal(); + + @Source("32x32.png") + @ImageOptions(repeatStyle = RepeatStyle.Vertical) + ImageResource i32x32Vertical(); + + @Source("64x64.png") + ImageResource i64x64(); + + @Source("64x64.png") + ImageResource i64x64Dup(); + + @Source("64x64-dup.png") + ImageResource i64x64Dup2(); + + // Test default filename lookup while we're at it + ImageResource largeLossless(); + + // Test default filename lookup while we're at it + ImageResource largeLossy(); + } + + @Override + public String getModuleName() { + return "com.google.gwt.resources.Resources"; + } + + public void testDedup() { + Resources r = GWT.create(Resources.class); + + ImageResource a = r.i64x64(); + ImageResource b = r.i64x64Dup(); + ImageResource c = r.i64x64Dup2(); + assertEquals(64, a.getHeight()); + assertEquals(64, a.getWidth()); + + assertEquals(a.getLeft(), b.getLeft()); + assertEquals(a.getLeft(), c.getLeft()); + + assertEquals(a.getLeft(), b.getTop()); + assertEquals(a.getLeft(), c.getTop()); + + // See if the size of the image strip is what we expect + Image i = new Image(a.getURL()); + i.addLoadHandler(new LoadHandler() { + public void onLoad(LoadEvent event) { + finishTest(); + } + }); + i.addErrorHandler(new ErrorHandler() { + public void onError(ErrorEvent event) { + fail("ErrorEvent"); + } + }); + + RootPanel.get().add(i); + delayTestFinish(500); + } + + public void testPacking() { + Resources r = GWT.create(Resources.class); + + ImageResource i64 = r.i64x64(); + ImageResource lossy = r.largeLossy(); + ImageResource lossless = r.largeLossless(); + + // The large, lossless image should be bundled + if (!i64.getURL().startsWith("data:")) { + assertEquals(i64.getURL(), lossless.getURL()); + } + + // Make sure that the large, lossy image isn't bundled with the rest + assertTrue(!i64.getURL().equals(lossy.getURL())); + + assertEquals(16, r.i16x16Vertical().getWidth()); + assertEquals(16, r.i16x16Vertical().getHeight()); + + assertEquals(16, r.i16x16Horizontal().getWidth()); + assertEquals(16, r.i16x16Horizontal().getHeight()); + } +}
diff --git a/user/test/com/google/gwt/resources/client/NestedBundleTest.java b/user/test/com/google/gwt/resources/client/NestedBundleTest.java new file mode 100644 index 0000000..09efa3d --- /dev/null +++ b/user/test/com/google/gwt/resources/client/NestedBundleTest.java
@@ -0,0 +1,63 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +import com.google.gwt.core.client.GWT; +import com.google.gwt.junit.client.GWTTestCase; +import com.google.gwt.resources.client.GwtCreateResource.ClassType; + +/** + * Verify that nested bundles work correctly. + */ +public class NestedBundleTest extends GWTTestCase { + + interface NestedBundle extends ClientBundle { + @Source("hello.txt") + TextResource hello(); + + NestedBundle nested(); + + GwtCreateResource<NestedBundle> nestedCreate(); + + @ClassType(NestedBundle.class) + GwtCreateResource<Object> nestedCreateWithOverride(); + } + + @Override + public String getModuleName() { + return "com.google.gwt.resources.Resources"; + } + + public void testNestedBundle() { + NestedBundle b = GWT.create(NestedBundle.class); + assertSame(b.hello(), b.nested().hello()); + } + + public void testNestedCreate() { + NestedBundle b = GWT.create(NestedBundle.class); + NestedBundle q = b.nestedCreate().create(); + NestedBundle r = b.nestedCreate().create(); + assertNotSame(q, r); + + assertSame(q.hello(), r.hello()); + } + + public void testNestedCreateOverride() { + NestedBundle b = GWT.create(NestedBundle.class); + Object o = b.nestedCreateWithOverride().create(); + assertTrue(o instanceof NestedBundle); + } +}
diff --git a/user/test/com/google/gwt/resources/client/TextResourceTest.java b/user/test/com/google/gwt/resources/client/TextResourceTest.java new file mode 100644 index 0000000..ffeaca8 --- /dev/null +++ b/user/test/com/google/gwt/resources/client/TextResourceTest.java
@@ -0,0 +1,80 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.client; + +import com.google.gwt.core.client.GWT; +import com.google.gwt.junit.client.GWTTestCase; + +/** + * Tests for TextResource assembly and use. + */ +public class TextResourceTest extends GWTTestCase { + + private static final String HELLO = "Hello World!"; + + static interface Resources extends ClientBundleWithLookup { + @Source("com/google/gwt/resources/client/hello.txt") + TextResource helloWorldAbsolute(); + + @Source("hello.txt") + ExternalTextResource helloWorldExternal(); + + @Source("hello.txt") + TextResource helloWorldRelative(); + } + + @Override + public String getModuleName() { + return "com.google.gwt.resources.Resources"; + } + + public void testExternal() throws ResourceException { + final Resources r = GWT.create(Resources.class); + + ResourceCallback<TextResource> c = new ResourceCallback<TextResource>() { + + public void onError(ResourceException e) { + e.printStackTrace(); + fail("Unable to fetch " + e.getResource().getName()); + } + + public void onSuccess(TextResource resource) { + assertEquals(r.helloWorldExternal().getName(), resource.getName()); + assertEquals(HELLO, resource.getText()); + finishTest(); + } + }; + + r.helloWorldExternal().getText(c); + delayTestFinish(2000); + } + + public void testInline() { + Resources r = GWT.create(Resources.class); + assertEquals(HELLO, r.helloWorldRelative().getText()); + assertEquals(HELLO, r.helloWorldAbsolute().getText()); + } + + public void testMeta() { + Resources r = GWT.create(Resources.class); + assertEquals("helloWorldAbsolute", r.helloWorldAbsolute().getName()); + assertEquals("helloWorldRelative", r.helloWorldRelative().getName()); + assertEquals("helloWorldExternal", r.helloWorldExternal().getName()); + + ResourcePrototype[] resources = r.getResources(); + assertEquals(3, resources.length); + } +}
diff --git a/user/test/com/google/gwt/resources/client/concatenatedA.css b/user/test/com/google/gwt/resources/client/concatenatedA.css new file mode 100644 index 0000000..6b1c69e --- /dev/null +++ b/user/test/com/google/gwt/resources/client/concatenatedA.css
@@ -0,0 +1,18 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +.partA { + background: blue; +} \ No newline at end of file
diff --git a/user/test/com/google/gwt/resources/client/concatenatedB.css b/user/test/com/google/gwt/resources/client/concatenatedB.css new file mode 100644 index 0000000..f0b53db --- /dev/null +++ b/user/test/com/google/gwt/resources/client/concatenatedB.css
@@ -0,0 +1,18 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +.partB { + background: blue; +} \ No newline at end of file
diff --git a/user/test/com/google/gwt/resources/client/deftest.css b/user/test/com/google/gwt/resources/client/deftest.css new file mode 100644 index 0000000..0db8a81 --- /dev/null +++ b/user/test/com/google/gwt/resources/client/deftest.css
@@ -0,0 +1,25 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ + + @def rawInt 1; + @def rawFloat 1.5; + @def rawDouble 1.5; + + @def percentInt 50%; + @def percentFloat 50.5%; + + @def lengthInt 50px; + @def lengthFloat 1.5px; \ No newline at end of file
diff --git a/user/test/com/google/gwt/resources/client/hello.txt b/user/test/com/google/gwt/resources/client/hello.txt new file mode 100644 index 0000000..c57eff5 --- /dev/null +++ b/user/test/com/google/gwt/resources/client/hello.txt
@@ -0,0 +1 @@ +Hello World! \ No newline at end of file
diff --git a/user/test/com/google/gwt/resources/client/largeLossless.png b/user/test/com/google/gwt/resources/client/largeLossless.png new file mode 100644 index 0000000..ca911e1 --- /dev/null +++ b/user/test/com/google/gwt/resources/client/largeLossless.png Binary files differ
diff --git a/user/test/com/google/gwt/resources/client/largeLossy.jpg b/user/test/com/google/gwt/resources/client/largeLossy.jpg new file mode 100644 index 0000000..398e08e --- /dev/null +++ b/user/test/com/google/gwt/resources/client/largeLossy.jpg Binary files differ
diff --git a/user/test/com/google/gwt/resources/client/siblingTestA.css b/user/test/com/google/gwt/resources/client/siblingTestA.css new file mode 100644 index 0000000..9a6711e --- /dev/null +++ b/user/test/com/google/gwt/resources/client/siblingTestA.css
@@ -0,0 +1,24 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ + +/* This is the first half of the sibling test. */ +.replacement { background:red; } +.replacement-not-java-ident {color: blue;} +.local {background: green; } +.other {background: blue; } +.unsharedClass {} +.sharedClass {} +.sharedOverrideClass {}
diff --git a/user/test/com/google/gwt/resources/client/siblingTestB.css b/user/test/com/google/gwt/resources/client/siblingTestB.css new file mode 100644 index 0000000..15f05f1 --- /dev/null +++ b/user/test/com/google/gwt/resources/client/siblingTestB.css
@@ -0,0 +1,24 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ + +/* This is the other half of the sibling test. */ +.other {background: blue; } +.replacement-not-java-ident {color: blue;} +.replacement { background:red; } +.local {background:green;} +.unsharedClass {} +.sharedClass {} +.sharedOverrideClass {}
diff --git a/user/test/com/google/gwt/resources/client/test.css b/user/test/com/google/gwt/resources/client/test.css new file mode 100644 index 0000000..ad420a5 --- /dev/null +++ b/user/test/com/google/gwt/resources/client/test.css
@@ -0,0 +1,210 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ +@def BIG 50px; +@def DIRECTION ltr; +@eval RED com.google.gwt.resources.client.CSSResourceTest.red(); +@url BACKGROUND dataMethod; + +/* Check @def expansion */ +@def SPRITEWIDTH value("spriteMethod.getWidth", "px"); +@def SPRITESIZE SPRITEWIDTH value("spriteMethod.getHeight", "px"); + +/* + * We'll use the token FAIL to indicate text that should never be seen in the output. + */ + +/* Test @sprite expansion */ +@sprite .spriteClass, .extraSpriteClass { + gwt-image: "spriteMethod"; + more: properties; +} + +.affectedBySprite { + offset-left: "guard" SPRITEWIDTH !important; + offset: SPRITESIZE; +} + +.blahA { + background-color: #000; +} + +.blahA[someAttribute="foo"][beer="baz"] { + background-color: #fff; +} + +/* Test value substitution */ +div { + border: BIG solid RED; + direction: DIRECTION; + background: BACKGROUND; +} + +div[foo="bar"] { + content: 'bar'; +} + +/* Test structural modifications */ +@if (false) { + div { + runtime: FAIL; + } +} @elif (true) { + div { + runtime: PASSED; + } +} @else { + div { + runtime: FAIL; + } +} + +@if CssResource.style obf OBF { + div { + static: PASSED; + } +} @elif CssResource.style pretty PRETTY { + div { + static: PASSED; + } +} @else { + div { + static: FAIL; + } +} + +/* Test named classes */ +.replacement { + color: red; +} + +.replacement:after { + content: "Hello\\\" world"; +} + +.replacement-not-java-ident { + color: blue; +} + +/* Test unusual tag, class, and property names and values */ +div { + \-some-wacky-extension : boo; + another-extension: \-bar; +} + +div { + filter: "alpha(opacity = 30)"; +} + +div-with-literal { + top: literal("expression(document.compatMode==\"CSS1Compat\" ? documentElement.scrollTop:document.body.scrollTop \\ 2)"); +} + +.ns\:tag { + border: red; +} + +.ns\:tag:pseudo { + content : "blah"; +} + +/* Test merging / promotion functions*/ + +.may-merge { + border: 0; +} + +.may-combine { + border: 0; +} + +/* Test merging around empty rules */ +.FAIL {} + +/* Make sure rules in @if and @media are respected */ +@media blah { + @if (true) { + .this-does-not-matter { + after: merge; + } + } +} + +.may-merge { + before: merge; +} + +.may-combine2 { + border: 0; +} + +.may-not-merge { + merge: merge; +} + +.may-not-combine { + combine: combine; + prevent-combine: true; +} + +/* Make sure rules in @if and @media are respected */ +@media blah { + @if (true) { + .may-not-merge-or-combine-because-of-this { + prevent: true; + } + } +} +.may-not-merge { + prevent-merge: true; +} + +.may-not-combine2 { + combine: combine; + prevent-combine: true; +} + +/* Ensure preservation of standard @rules */ + +@MEDIA print { + div { + media: no-merge; + } +} + +@page { + margin: 3cm; +} + +@page :left { + margin: 4cm; +} + +/* Ensure multi-class selectors fully obfuscate */ +.multiClassA { + border: 1px solid red; +} + +.multiClassB { + border: 1px solid blue; +} + +.multiClassA.multiClassB { + border: 1px solid blue; +} + +.css3Color { + background-color: rgba(0, 0, 0, 0.5); +}
diff --git a/user/test/com/google/gwt/resources/client/unrelatedDescendants.css b/user/test/com/google/gwt/resources/client/unrelatedDescendants.css new file mode 100644 index 0000000..637f3fc --- /dev/null +++ b/user/test/com/google/gwt/resources/client/unrelatedDescendants.css
@@ -0,0 +1,20 @@ +/* + * Copyright 2008 Google Inc. + * + * 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. + */ + +/* No @ImportWithPrefix followed by one with the annotation */ +.MyCssResourceA-local .gwt-MyCssResourceB-local { + background: green; +}
diff --git a/user/test/com/google/gwt/resources/rg/CssNodeClonerTest.java b/user/test/com/google/gwt/resources/rg/CssNodeClonerTest.java new file mode 100644 index 0000000..24c5042 --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/CssNodeClonerTest.java
@@ -0,0 +1,80 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.resources.css.GenerateCssAst; +import com.google.gwt.resources.css.ast.CssNode; +import com.google.gwt.resources.css.ast.CssNodeCloner; +import com.google.gwt.resources.css.ast.CssProperty; +import com.google.gwt.resources.css.ast.CssSelector; +import com.google.gwt.resources.css.ast.CssStylesheet; + +import java.net.URL; +import java.util.List; + +/** + * Tests the CssNodeCloner utility class. + */ +public class CssNodeClonerTest extends CssTestCase { + + public void testClone() throws UnableToCompleteException { + CssStylesheet sheet = GenerateCssAst.exec(TreeLogger.NULL, + new URL[] {getClass().getClassLoader().getResource( + "com/google/gwt/resources/client/test.css")}); + + CssStylesheet cloned = CssNodeCloner.clone(CssStylesheet.class, sheet); + + assertNotSame(sheet, cloned); + assertNoAliasing(cloned); + } + + public void testCloneList() throws UnableToCompleteException { + CssStylesheet sheet = GenerateCssAst.exec(TreeLogger.NULL, + new URL[] {getClass().getClassLoader().getResource( + "com/google/gwt/resources/client/test.css")}); + + List<CssNode> cloned = CssNodeCloner.clone(CssNode.class, sheet.getNodes()); + + assertEquals(sheet.getNodes().size(), cloned.size()); + + for (CssNode node : cloned) { + assertNoAliasing(node); + } + } + + public void testCloneProperty() { + CssProperty.IdentValue value = new CssProperty.IdentValue("value"); + CssProperty p = new CssProperty("name", value, true); + + CssProperty clone = CssNodeCloner.clone(CssProperty.class, p); + + assertNotSame(p, clone); + assertEquals(p.getName(), clone.getName()); + assertEquals(value.getIdent(), + clone.getValues().getValues().get(0).isIdentValue().getIdent()); + } + + public void testCloneSelector() { + CssSelector sel = new CssSelector("a , b"); + + CssSelector clone = CssNodeCloner.clone(CssSelector.class, sel); + + assertNotSame(sel, clone); + assertEquals(sel.getSelector(), clone.getSelector()); + } +}
diff --git a/user/test/com/google/gwt/resources/rg/CssReorderTest.java b/user/test/com/google/gwt/resources/rg/CssReorderTest.java new file mode 100644 index 0000000..2777548 --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/CssReorderTest.java
@@ -0,0 +1,43 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.resources.css.ast.CssVisitor; +import com.google.gwt.resources.rg.CssResourceGenerator.MergeIdenticalSelectorsVisitor; +import com.google.gwt.resources.rg.CssResourceGenerator.MergeRulesByContentVisitor; +import com.google.gwt.resources.rg.CssResourceGenerator.SplitRulesVisitor; + +/** + * Tests CSS reordering visitors. + */ +public class CssReorderTest extends CssTestCase { + public void testPropertyMerging() throws UnableToCompleteException { + test(TreeLogger.NULL, "propertyMerging", false, makeVisitors()); + } + + public void testSelectorMerging() throws UnableToCompleteException { + test(TreeLogger.NULL, "selectorMerging", false, makeVisitors()); + } + + private CssVisitor[] makeVisitors() { + return new CssVisitor[] { + new SplitRulesVisitor(), new AliasDetector(), + new MergeIdenticalSelectorsVisitor(), new AliasDetector(), + new MergeRulesByContentVisitor(), new AliasDetector()}; + } +}
diff --git a/user/test/com/google/gwt/resources/rg/CssRtlTest.java b/user/test/com/google/gwt/resources/rg/CssRtlTest.java new file mode 100644 index 0000000..ac0bc8e --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/CssRtlTest.java
@@ -0,0 +1,54 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.resources.css.ast.CssVisitor; +import com.google.gwt.resources.rg.CssResourceGenerator.RtlVisitor; + +/** + * This is a static test of the automatic RTL support. + */ +public class CssRtlTest extends CssTestCase { + public void testBackgroundProperties() throws UnableToCompleteException { + test(TreeLogger.NULL, "backgroundProperties", true, makeVisitors()); + } + + public void testCursorProperties() throws UnableToCompleteException { + test(TreeLogger.NULL, "cursorProperties", true, makeVisitors()); + } + + public void testDirectionUpdatedInBodyOnly() throws UnableToCompleteException { + test(TreeLogger.NULL, "directionProperty", true, makeVisitors()); + } + + public void testFourValuedProperties() throws UnableToCompleteException { + test(TreeLogger.NULL, "fourValuedProperties", true, makeVisitors()); + } + + public void testLeftRightProperties() throws UnableToCompleteException { + test(TreeLogger.NULL, "leftRightProperties", true, makeVisitors()); + } + + public void testNoFlip() throws UnableToCompleteException { + test(TreeLogger.NULL, "noflip", true, makeVisitors()); + } + + private CssVisitor[] makeVisitors() { + return new CssVisitor[] {new RtlVisitor(), new AliasDetector()}; + } +}
diff --git a/user/test/com/google/gwt/resources/rg/CssTestCase.java b/user/test/com/google/gwt/resources/rg/CssTestCase.java new file mode 100644 index 0000000..d66d66c --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/CssTestCase.java
@@ -0,0 +1,172 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ +package com.google.gwt.resources.rg; + +import com.google.gwt.core.ext.GeneratorContext; +import com.google.gwt.core.ext.TreeLogger; +import com.google.gwt.core.ext.UnableToCompleteException; +import com.google.gwt.core.ext.typeinfo.JClassType; +import com.google.gwt.resources.css.GenerateCssAst; +import com.google.gwt.resources.css.ast.CssNode; +import com.google.gwt.resources.css.ast.CssStylesheet; +import com.google.gwt.resources.css.ast.CssVisitor; +import com.google.gwt.resources.css.ast.HasNodes; +import com.google.gwt.resources.ext.ResourceContext; + +import junit.framework.TestCase; + +import java.net.URL; +import java.util.IdentityHashMap; +import java.util.List; +import java.util.Map; + +/** + * Contains functions for golden-output tests that are concerned with structural + * modifications to the CSS AST. + */ +class CssTestCase extends TestCase { + + /** + * Triggers an assertion if a CssNode is traversed more than once. + * + * @see CssTestCase#assertNoAliasing(CssNode) + */ + protected static class AliasDetector extends CssVisitor { + private final Map<CssNode, Void> seen = new IdentityHashMap<CssNode, Void>(); + + @Override + protected void doAccept(List<? extends CssNode> list) { + for (CssNode node : list) { + doAccept(node); + } + } + + @Override + protected void doAcceptWithInsertRemove(List<? extends CssNode> list) { + for (CssNode node : list) { + doAccept(node); + } + } + + @Override + protected <T extends CssNode> T doAccept(T node) { + assertFalse("Found repeated node " + node.toString(), + seen.containsKey(node)); + seen.put(node, null); + return super.doAccept(node); + } + } + + /** + * Total fake, no implementations. + */ + private static class FakeContext implements ResourceContext { + public String deploy(String suggestedFileName, String mimeType, + byte[] data, boolean xhrCompatible) throws UnableToCompleteException { + return null; + } + + public String deploy(URL resource, boolean xhrCompatible) + throws UnableToCompleteException { + return null; + } + + public GeneratorContext getGeneratorContext() { + return null; + } + + public String getImplementationSimpleSourceName() + throws IllegalStateException { + return null; + } + + public JClassType getClientBundleType() { + return null; + } + + public boolean supportsDataUrls() { + return true; + } + } + + /** + * Asserts that two CssNodes are identical. + */ + protected static <T extends CssNode & HasNodes> void assertEquals( + TreeLogger logger, T expected, T test) throws UnableToCompleteException { + String expectedCss = CssResourceGenerator.makeExpression(logger, + new FakeContext(), null, expected, false); + String testCss = CssResourceGenerator.makeExpression(logger, + new FakeContext(), null, test, false); + assertEquals(expectedCss, testCss); + } + + /** + * Ensure that no CssNode is traversed more than once due to AST errors. + */ + protected static void assertNoAliasing(CssNode node) { + (new AliasDetector()).accept(node); + } + + /** + * Compares the generated Java expressions for an input file, transformed in + * order by the specified visitors, and a golden-output file. + */ + private static void test(TreeLogger logger, URL test, URL expected, + CssVisitor... visitors) throws UnableToCompleteException { + + CssStylesheet expectedSheet = null; + CssStylesheet testSheet = null; + + try { + expectedSheet = GenerateCssAst.exec(logger, new URL[] {expected}); + testSheet = GenerateCssAst.exec(logger, new URL[] {test}); + } catch (UnableToCompleteException e) { + fail("Unable to parse stylesheet"); + } + + for (CssVisitor v : visitors) { + v.accept(testSheet); + } + + assertEquals(logger, expectedSheet, testSheet); + } + + /** + * Runs a test. + * + * @param testName is used to compute the test and expected resource paths. + * @param reversible if <code>true</code>, the test will attempt to transform + * the expected css into the test css + */ + protected void test(TreeLogger logger, String testName, boolean reversible, + CssVisitor... visitors) throws UnableToCompleteException { + String packagePath = getClass().getPackage().getName().replace('.', '/') + + "/"; + URL testUrl = getClass().getClassLoader().getResource( + packagePath + testName + "_test.css"); + assertNotNull("Cauld not find testUrl", testUrl); + URL expectedUrl = getClass().getClassLoader().getResource( + packagePath + testName + "_expected.css"); + assertNotNull("Cauld not find testUrl", expectedUrl); + + test(logger, testUrl, expectedUrl, visitors); + + if (reversible) { + test(logger, expectedUrl, testUrl, visitors); + } + } +}
diff --git a/user/test/com/google/gwt/resources/rg/backgroundProperties_expected.css b/user/test/com/google/gwt/resources/rg/backgroundProperties_expected.css new file mode 100644 index 0000000..ed77a6f --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/backgroundProperties_expected.css
@@ -0,0 +1,77 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +/* Tests swapping background positions */ +.selector1 { + background-position-x: 60%; +} + +.selector2 { + background-position-x: right; +} + +.selector3 { + background-position-x: left; +} + +.selector4 { + background-position: 60% 40%; +} + +.selector5 { + background-position: right top; +} + +.selector6 { + background-position: top left; +} + +.selector7 { + background: url("chess.png") gray 60% repeat fixed; +} + +/* Reported NPE bug */ +.selector8 { + background-position: 0 0; +} + +/* Tests below here should be unchanged */ + +.selector10 { + background-position-x: auto; +} + +.selector11 { + background-position-x: center; +} + +.selector12 { + background-position-y: 0; +} + +.selector13 { + background-position: 10px 40%; +} + +.selector14 { + background: url("chess.png") gray left 40% repeat fixed; +} + +/* This probably isn't valid, but try it anyway */ +.selector15 { + background: url("chess.png") gray center 40% left repeat fixed; +} +
diff --git a/user/test/com/google/gwt/resources/rg/backgroundProperties_test.css b/user/test/com/google/gwt/resources/rg/backgroundProperties_test.css new file mode 100644 index 0000000..9d3dd68 --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/backgroundProperties_test.css
@@ -0,0 +1,77 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +/* Tests swapping background positions */ +.selector1 { + background-position-x: 40%; +} + +.selector2 { + background-position-x: left; +} + +/* This isn't a defined property, but it appears to be in common use */ +.selector3 { + background-position-x: right; +} + +.selector4 { + background-position: 40% 40%; +} + +.selector5 { + background-position: left top; +} + +.selector6 { + background-position: top right; +} + +.selector7 { + background: url("chess.png") gray 40% repeat fixed; +} + +/* Reported NPE bug */ +.selector8 { + background-position: 0 0; +} + +/* Tests below here should be unchanged */ + +.selector10 { + background-position-x: auto; +} + +.selector11 { + background-position-x: center; +} + +.selector12 { + background-position-y: 0; +} + +.selector13 { + background-position: 10px 40%; +} + +.selector14 { + background: url("chess.png") gray right 40% repeat fixed; +} + +/* This probably isn't valid, but try it anyway */ +.selector15 { + background: url("chess.png") gray center 40% right repeat fixed; +}
diff --git a/user/test/com/google/gwt/resources/rg/cursorProperties_expected.css b/user/test/com/google/gwt/resources/rg/cursorProperties_expected.css new file mode 100644 index 0000000..1ccd0ec --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/cursorProperties_expected.css
@@ -0,0 +1,56 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +/* Tests swapping cursor directions */ +.selector { + cursor: nw-resize; +} + +.selector2 { + cursor: w-resize; +} + +.selector3 { + cursor: sw-resize; +} + +.selector4 { + cursor: se-resize; +} +.selector5 { + cursor: e-resize; +} + +.selector6 { + cursor: ne-resize; +} + +/* Below should be unchanged */ +.selector10 { + cursor: be-resize; +} + +.selector11 { + cursor: z-resize; +} + +.selector12 { + cursor: inherit; +} + +.selector13 { + cursor: no-resize; +}
diff --git a/user/test/com/google/gwt/resources/rg/cursorProperties_test.css b/user/test/com/google/gwt/resources/rg/cursorProperties_test.css new file mode 100644 index 0000000..39ed82f --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/cursorProperties_test.css
@@ -0,0 +1,56 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +/* Tests swapping cursor directions */ +.selector { + cursor: ne-resize; +} + +.selector2 { + cursor: e-resize; +} + +.selector3 { + cursor: se-resize; +} + +.selector4 { + cursor: sw-resize; +} +.selector5 { + cursor: w-resize; +} + +.selector6 { + cursor: nw-resize; +} + +/* Below should be unchanged */ +.selector10 { + cursor: be-resize; +} + +.selector11 { + cursor: z-resize; +} + +.selector12 { + cursor: inherit; +} + +.selector13 { + cursor: no-resize; +}
diff --git a/user/test/com/google/gwt/resources/rg/directionProperty_expected.css b/user/test/com/google/gwt/resources/rg/directionProperty_expected.css new file mode 100644 index 0000000..6be29cd --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/directionProperty_expected.css
@@ -0,0 +1,34 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +/* Only the direction property in the body selector should be updated. */ +body { + direction: rtl; +} + +/* These should be unchanged */ + +.selector1 { + direction: ltr; +} + +body .selector2 { + direction: rtl: +} + +* { + direction: inherit; +}
diff --git a/user/test/com/google/gwt/resources/rg/directionProperty_test.css b/user/test/com/google/gwt/resources/rg/directionProperty_test.css new file mode 100644 index 0000000..b137e14 --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/directionProperty_test.css
@@ -0,0 +1,34 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +/* Only the direction property in the body selector should be updated. */ +body { + direction: ltr; +} + +/* These should be unchanged */ + +.selector1 { + direction: ltr; +} + +body .selector2 { + direction: rtl: +} + +* { + direction: inherit; +}
diff --git a/user/test/com/google/gwt/resources/rg/fourValuedProperties_expected.css b/user/test/com/google/gwt/resources/rg/fourValuedProperties_expected.css new file mode 100644 index 0000000..0ab4b4e --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/fourValuedProperties_expected.css
@@ -0,0 +1,53 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +/* Tests border and margin properties with four values */ +.selector1 { + padding: 1px 4px 3px 2px; + margin: 1px 4px 3px 2px; +} + +.selector2 { + padding: 1px inherit 3px auto; + margin: 1px auto 3px inherit; +} + +.selector3 { + padding: 1px 'string' 3px 2px; +} + +.selector4 { + border-color: red yellow blue green; + border-style: solid double dashed dotted; + border-width: thin 0 thick medium; +} + +/* Nothing below here should be changed */ +.selector10 { + padding: 1px 2px 3px; +} + +.selector11 { + padding: 1px 2px; +} + +.selector12 { + padding: 1px; +} + +.selector13 { + border: thin solid red collapse; +}
diff --git a/user/test/com/google/gwt/resources/rg/fourValuedProperties_test.css b/user/test/com/google/gwt/resources/rg/fourValuedProperties_test.css new file mode 100644 index 0000000..ea7c2e7 --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/fourValuedProperties_test.css
@@ -0,0 +1,53 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +/* Tests border and margin properties with four values */ +.selector1 { + padding: 1px 2px 3px 4px; + margin: 1px 2px 3px 4px; +} + +.selector2 { + padding: 1px auto 3px inherit; + margin: 1px inherit 3px auto; +} + +.selector3 { + padding: 1px 2px 3px 'string'; +} + +.selector4 { + border-color: red green blue yellow; + border-style: solid dotted dashed double; + border-width: thin medium thick 0; +} + +/* Nothing below here should be changed */ +.selector10 { + padding: 1px 2px 3px; +} + +.selector11 { + padding: 1px 2px; +} + +.selector12 { + padding: 1px; +} + +.selector13 { + border: thin solid red collapse; +}
diff --git a/user/test/com/google/gwt/resources/rg/leftRightProperties_expected.css b/user/test/com/google/gwt/resources/rg/leftRightProperties_expected.css new file mode 100644 index 0000000..f39badc --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/leftRightProperties_expected.css
@@ -0,0 +1,61 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +/* A basic test for switching the left and right properties */ +.selector { + right: 1px; +} + +.selector2 { + left: 3px; +} + +.selector3 { + padding-left: 5px; + margin-right: 10px; +} + +.selector4 { + border-left-color: 1px solid blue; + border-right-color: red; +} + +.selector5 { + float: right; + clear: right; +} + +.selector6 { + float: left; + clear: left; +} + +.selector7 { + text-align: right; +} + +.selector8 { + page-break-after: right; +} + +.selector9 { + page-break-before: right; +} + +/* This is CSS3 syntax */ +.selector10 { + background: right 5px top 10px; +}
diff --git a/user/test/com/google/gwt/resources/rg/leftRightProperties_test.css b/user/test/com/google/gwt/resources/rg/leftRightProperties_test.css new file mode 100644 index 0000000..fc343af --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/leftRightProperties_test.css
@@ -0,0 +1,61 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +/* A basic test for switching the left and right properties */ +.selector { + left: 1px; +} + +.selector2 { + right: 3px; +} + +.selector3 { + padding-right: 5px; + margin-left: 10px; +} + +.selector4 { + border-right-color: 1px solid blue; + border-left-color: red; +} + +.selector5 { + float: left; + clear: left; +} + +.selector6 { + float: right; + clear: right; +} + +.selector7 { + text-align: left; +} + +.selector8 { + page-break-after: left; +} + +.selector9 { + page-break-before: left; +} + +/* This is CSS3 syntax */ +.selector10 { + background: left 5px top 10px; +}
diff --git a/user/test/com/google/gwt/resources/rg/noflip_expected.css b/user/test/com/google/gwt/resources/rg/noflip_expected.css new file mode 100644 index 0000000..8f2fcd4 --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/noflip_expected.css
@@ -0,0 +1,27 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +.selector1 { + right: 1px; +} + +/* The following should not be affected. */ + +@noflip { + .selector2 { + left: 1px; + } +}
diff --git a/user/test/com/google/gwt/resources/rg/noflip_test.css b/user/test/com/google/gwt/resources/rg/noflip_test.css new file mode 100644 index 0000000..059cf85 --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/noflip_test.css
@@ -0,0 +1,27 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +.selector1 { + left: 1px; +} + +/* The following should not be affected. */ + +@noflip { + .selector2 { + left: 1px; + } +}
diff --git a/user/test/com/google/gwt/resources/rg/propertyMerging_expected.css b/user/test/com/google/gwt/resources/rg/propertyMerging_expected.css new file mode 100644 index 0000000..e94e068 --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/propertyMerging_expected.css
@@ -0,0 +1,105 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +/* Tests merging selectors with identical properties */ +.a , .b { + group: one; +} +.c { + group: two; + border: green; +} + +.d{ + border: green; + group: two; +} + +.e , .e2 , .g { + group: five; +} + +.f { + unrelated: six; +} + +.noMergeExact1 { + group: three; + border: blue; +} + +.noMergeExactBlocker { + group: three; + border: thin; +} + +.noMergeExact2 { + group: three; + border: blue; +} + +.noMergePrefix1 { + group: four; + border: blue; +} + +.noMergePrefixBlocker { + group: four; + border-top: thin; +} + +.noMergePrefix2 { + group: four; + border: blue; +} + + +/* Should not merge across @if or @media blocks */ +.if { + group: if; +} + +.ifOk, .ifOk2 { + group2: ifOk; +} + +@if (ignored) { + .if2 { + group: if; + } +} + +.if3 { + group: if; +} + +.media { + group: media; +} + +.mediaOk , .mediaOk2 { + group2: mediaOk; +} + +@media print { + .media2 { + group: media; + } +} + +.media3 { + group: media; +}
diff --git a/user/test/com/google/gwt/resources/rg/propertyMerging_test.css b/user/test/com/google/gwt/resources/rg/propertyMerging_test.css new file mode 100644 index 0000000..0589ccf --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/propertyMerging_test.css
@@ -0,0 +1,122 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + +/* Tests merging selectors with identical properties */ +.a { + group: one; +} + +.b { + group: one; +} + +.c { + group: two; + border: green; +} + +.d{ + border: green; + group: two; +} + +.e , .e2 { + group: five; +} + +.f { + unrelated: six; +} + +.g { + group: five; +} + +.noMergeExact1 { + group: three; + border: blue; +} + +.noMergeExactBlocker { + group: three; + border: thin; +} + +.noMergeExact2 { + group: three; + border: blue; +} + +.noMergePrefix1 { + group: four; + border: blue; +} + +.noMergePrefixBlocker { + group: four; + border-top: thin; +} + +.noMergePrefix2 { + group: four; + border: blue; +} + +/* Should not merge across @if or @media blocks */ +.if { + group: if; +} + +.ifOk { + group2: ifOk; +} + +@if (ignored) { + .if2 { + group: if; + } +} + +.ifOk2 { + group2: ifOk; +} + +.if3 { + group: if; +} + +.media { + group: media; +} + +.mediaOk { + group2: mediaOk; +} + +@media print { + .media2 { + group: media; + } +} + +.mediaOk2 { + group2: mediaOk; +} + + +.media3 { + group: media; +}
diff --git a/user/test/com/google/gwt/resources/rg/selectorMerging_expected.css b/user/test/com/google/gwt/resources/rg/selectorMerging_expected.css new file mode 100644 index 0000000..c48b61f --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/selectorMerging_expected.css
@@ -0,0 +1,72 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + + /* Tests merging adjacent rules with identical selectors */ +a { + prop: value; foo: bar; +} + +c { + prop: value; +} + +aNonBlocker { + random: other; +} + +b { + border-left: 1px; +} + +bBlocker { + border: solid; +} + +b { + border-right: 2px; +} + +/* Test blocking across @if rules. */ +if { + if1 : true; + if5 : true; +} + +@if (true) { + if { + if3 : true; + } +} + +if { + if3-block: false; +} + +/* Test blocking across @media rules. */ +media { + media1 : true; + media5 : true; +} + +@if (true) { + media { + media3 : true; + } +} + +media { + media3-block : false; +}
diff --git a/user/test/com/google/gwt/resources/rg/selectorMerging_test.css b/user/test/com/google/gwt/resources/rg/selectorMerging_test.css new file mode 100644 index 0000000..fd5225c --- /dev/null +++ b/user/test/com/google/gwt/resources/rg/selectorMerging_test.css
@@ -0,0 +1,78 @@ +/* + * Copyright 2009 Google Inc. + * + * 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. + */ + + /* Tests merging adjacent rules with identical selectors */ +a , c { + prop: value; +} + +aNonBlocker { + random: other; +} + +a { + foo: bar; +} + +b { + border-left: 1px; +} + +bBlocker { + border: solid; +} + +b { + border-right: 2px; +} + +/* Test blocking across @if rules. */ +if { + if1 : true; +} + +@if (true) { + if { + if3 : true; + } +} + +if { + if5 : true; +} + +if { + if3-block : false; +} + +/* Test blocking across @media rules. */ +media { + media1 : true; +} + +@if (true) { + media { + media3 : true; + } +} + +media { + media5 : true; +} + +media { + media3-block : false; +}
