StyleWriter (Omakase CSS Parser 1.9.1-SNAPSHOT API)

java.lang.Object
- com.salesforce.omakase.writer.StyleWriter

All Implemented Interfaces:: DependentPlugin, Plugin

public final class StyleWriter
extends Object
implements DependentPlugin

The main class for writing processed CSS content.

To use, add an instance of this class via Omakase.Request.use(Plugin...).

Examples:


 StyleWriter verbose = StyleWriter.verbose();
 Omakase.source(input).use(verbose).process();
 String css = verbose.write();


 StyleWriter compressed = StyleWriter.compressed();
 Omakase.source(input).use(compressed).process();
 String css = compressed.write();


 StyleWriter verbose = StyleWriter.verbose();
 Omakase.source(input).use(verbose).process();
 verbose.writeTo(System.out);


 String classSelector = StyleWriter.inline().writeSingle(new ClassSelector("test"));

Unless otherwise specified, WriterMode.INLINE will be used.

By default this will not write out CSS comments, however you can change that behavior with writeAllComments(boolean).

Constructor Summary

Constructors
Constructor and Description
`StyleWriter()` Creates a new `StyleWriter` instance using `WriterMode.INLINE`.
`StyleWriter(WriterMode mode)` Creates a new `StyleWriter` instance using the given `WriterMode`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<T extends Writable> StyleWriter`	`addCustomWriter(Class<T> writable, CustomWriter<T> writer)` Overrides the writing of a unit with the given `CustomWriter` instance.
`void`	`appendComments(Iterable<Comment> comments, StyleAppendable appendable)` Utility method for assisting with writing comments.
`static StyleWriter`	`compressed()` Creates a new `StyleWriter` with `WriterMode.COMPRESSED` mode.
`int`	`countAtCurrentDepth()` Gets the count of the number of peer units previously written out at the current depth level.
`StyleWriter`	`decrementDepth()` Decrements the stack depth.
`void`	`dependencies(PluginRegistry registry)` Registers plugin dependencies.
`StyleWriter`	`incrementDepth()` Increments the stack depth.
`static StyleWriter`	`inline()` Creates a new `StyleWriter` with `WriterMode.INLINE` mode.
`boolean`	`isCompressed()` Gets whether the current `WriterMode` is `WriterMode.COMPRESSED`.
`boolean`	`isFirstAtCurrentDepth()` Gets whether no peer units have been written out at the current depth level.
`boolean`	`isInline()` Gets whether the current `WriterMode` is `WriterMode.INLINE`.
`boolean`	`isVerbose()` Gets whether the current `WriterMode` is `WriterMode.VERBOSE`.
`WriterMode`	`mode()` Gets the `WriterMode`.
`StyleWriter`	`mode(WriterMode mode)` Sets the `WriterMode`.
`boolean`	`shouldWriteAllComments()` Gets whether all comments will be written out.
`boolean`	`shouldWriteAnnotatedComments()` Returns whether comments with annotations should be written out, even if `shouldWriteAllComments()` is false.
`boolean`	`shouldWriteBangComments()` Returns whether comments starting with '!' should be written out, even if `shouldWriteAllComments()` is false.
`String`	`toString()`
`static StyleWriter`	`verbose()` Creates a new `StyleWriter` with `WriterMode.VERBOSE` mode.
`String`	`write()` Writes the entire processed stylesheet to a string.
`StyleWriter`	`writeAllComments(boolean writeComments)` Sets whether all comments will be written out.
`StyleWriter`	`writeAnnotatedComments(boolean writeAnnotatedComments)` Sets whether comments with annotations should be written out, even if `shouldWriteAllComments()` is false.
`StyleWriter`	`writeBangComments(boolean writeBangComments)` Returns whether comments starting with '!' should be written out, even if `shouldWriteAllComments()` is false.
`<T extends Writable> void`	`writeInner(T writable, StyleAppendable appendable)` Writes the given syntax unit to the given `StyleAppendable`, taking into account any `CustomWriter` overrides specified on this `StyleWriter`.
`<T extends Writable> void`	`writeInner(T writable, StyleAppendable appendable, boolean useOverrides)` Writes the given syntax unit to the given `StyleAppendable`.
`String`	`writeSingle(Writable writable)` The easiest way to get the output of a single `Writable` instance.
`void`	`writeTo(Appendable appendable)` Writes the entire processed stylesheet to the given `Appendable`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - StyleWriter
```
public StyleWriter()
```
    Creates a new StyleWriter instance using WriterMode.INLINE.
  - StyleWriter
```
public StyleWriter(WriterMode mode)
```
    Creates a new StyleWriter instance using the given WriterMode.
    
    Parameters:
    
    mode - The WriterMode to use.
- Method Detail
  - dependencies
```
public void dependencies(PluginRegistry registry)
```
    Description copied from interface: DependentPlugin
    
    Registers plugin dependencies.
    Any plugins you add to the registry in this method will be ordered before this plugin itself.
    Keep in mind that only one instance of a plugin can be added in a single parsing operation. You can use PluginRegistry.require(Class), PluginRegistry.require(Class, Supplier) and PluginRegistry.retrieve(Class) to assist in scenarios where a plugin instance may have already been added.
    Dependencies to include can range from refinement dependencies such as SelectorPlugin and MediaPlugin to other custom plugins.
    
    Specified by:
    
    dependencies in interface DependentPlugin
    
    Parameters:
    
    registry - The PluginRegistry instance.
    
    See Also:
    
    PluginRegistry.require(Class), PluginRegistry.require(Class, Supplier), PluginRegistry.retrieve(Class)
  - mode
```
public StyleWriter mode(WriterMode mode)
```
    Sets the WriterMode.
    
    Parameters:
    
    mode - The new WriterMode.
    
    Returns:
    
    this, for chaining.
  - mode
```
public WriterMode mode()
```
    Gets the WriterMode.
    
    Returns:
    
    The writer mode.
  - isVerbose
```
public boolean isVerbose()
```
    Gets whether the current WriterMode is WriterMode.VERBOSE.
    
    Returns:
    
    True if the current WriterMode is verbose.
  - isInline
```
public boolean isInline()
```
    Gets whether the current WriterMode is WriterMode.INLINE.
    
    Returns:
    
    True if the current WriterMode is inline.
  - isCompressed
```
public boolean isCompressed()
```
    Gets whether the current WriterMode is WriterMode.COMPRESSED.
    
    Returns:
    
    True if the current WriterMode is compressed.
  - writeAllComments
```
public StyleWriter writeAllComments(boolean writeComments)
```
    Sets whether all comments will be written out.
    
    Parameters:
    
    writeComments - Whether all comments should be written out.
    
    Returns:
    
    this, for chaining.
  - shouldWriteAllComments
```
public boolean shouldWriteAllComments()
```
    Gets whether all comments will be written out.
    
    Returns:
    
    True if comments will be written out.
  - writeAnnotatedComments
```
public StyleWriter writeAnnotatedComments(boolean writeAnnotatedComments)
```
    Sets whether comments with annotations should be written out, even if shouldWriteAllComments() is false. This can be useful to preserve annotations across parsing operations.
    
    Parameters:
    
    writeAnnotatedComments - Whether comments with annotations should be written out.
    
    Returns:
    
    this, for chaining.
  - shouldWriteAnnotatedComments
```
public boolean shouldWriteAnnotatedComments()
```
    Returns whether comments with annotations should be written out, even if shouldWriteAllComments() is false. This can be useful to preserve annotations across parsing operations.
    
    Returns:
    
    True if annotated comments should always be written out.
  - writeBangComments
```
public StyleWriter writeBangComments(boolean writeBangComments)
```
    Returns whether comments starting with '!' should be written out, even if shouldWriteAllComments() is false. There must not be any whitespace between the comment open and the bang. This may be useful for preserving copyrights.
    
    Parameters:
    
    writeBangComments - Whether comments with bangs should be written out.
    
    Returns:
    
    this, for chaining.
  - shouldWriteBangComments
```
public boolean shouldWriteBangComments()
```
    Returns whether comments starting with '!' should be written out, even if shouldWriteAllComments() is false. There must not be any whitespace between the comment open and the bang. This may be useful for preserving copyrights.
    
    Returns:
    
    True if annotated comments should always be written out.
  - addCustomWriter
```
public <T extends Writable> StyleWriter addCustomWriter(Class<T> writable,
                                                        CustomWriter<T> writer)
```
    Overrides the writing of a unit with the given CustomWriter instance. See CustomWriter for more details on overriding.
    
    Type Parameters:
    
    T - The Type of unit being overridden.
    
    Parameters:
    
    writable - The class of the unit to override.
    
    writer - The CustomWriter override.
    
    Returns:
    
    this, for chaining.
  - write
```
public String write()
```
    Writes the entire processed stylesheet to a string.
    
    Returns:
    
    The CSS output.
  - writeTo
```
public void writeTo(Appendable appendable)
             throws IOException
```
    Writes the entire processed stylesheet to the given Appendable.
    
    Parameters:
    
    appendable - Write the processed CSS source code to this appendable.
    
    Throws:
    
    IOException - If an I/O error occurs.
  - writeInner
```
public <T extends Writable> void writeInner(T writable,
                                            StyleAppendable appendable)
                                     throws IOException
```
    Writes the given syntax unit to the given StyleAppendable, taking into account any CustomWriter overrides specified on this StyleWriter.
    Note that the unit will only be written if Writable.isWritable() returns true. This may be false if the unit is detached/destroyed, for example.
    This is usually used within implementations of Writable.write(StyleWriter, StyleAppendable) to write inner units. To write a single, arbitrary syntax unit use writeSingle(Writable) instead. Do not call this method from within a CustomWriter.
    This will automatically handle writing out comments and orphaned comments if the given writable is a Syntax unit, if applicable according to the current options.
    
    Type Parameters:
    
    T - Type of the unit to write.
    
    Parameters:
    
    writable - The unit to write.
    
    appendable - Write the unit's output to this StyleAppendable.
    
    Throws:
    
    IOException - If an I/O error occurs.
  - writeInner
```
public <T extends Writable> void writeInner(T writable,
                                            StyleAppendable appendable,
                                            boolean useOverrides)
                                     throws IOException
```
    Writes the given syntax unit to the given StyleAppendable.
    Note that the unit will only be written if Writable.isWritable() returns true. This may be false if the unit is detached/destroyed, for example.
    This method can be used by CustomWriters to write out the unit as normal. To write a single, isolated object use writeSingle(Writable) instead.
    This will automatically handle writing out comments and orphaned comments if the given writable is a Syntax unit, if applicable according to the current options.
    
    Type Parameters:
    
    T - Type of the unit to write.
    
    Parameters:
    
    writable - The unit to write.
    
    appendable - Write the unit's output to this StyleAppendable.
    
    useOverrides - If true, custom writers can alter the output behavior. Must always be false if calling this method from a custom writer.
    
    Throws:
    
    IOException - If an I/O error occurs.
  - writeSingle
```
public String writeSingle(Writable writable)
```
    The easiest way to get the output of a single Writable instance.
    This method is for writing disjoint units only. Examples would be for usage in test classes or in cases where you are operating on a single, isolated CSS unit as opposed to a whole CSS source.
    If you are implementing Writable.write(StyleWriter, StyleAppendable) then most of the time the method you want to use is writeInner(Writable, StyleAppendable), passing in the same StyleAppendable that you were given.
    
    Parameters:
    
    writable - The Writable instance, e.g., a Syntax unit.
    
    Returns:
    
    The output CSS code for the given unit.
  - appendComments
```
public void appendComments(Iterable<Comment> comments,
                           StyleAppendable appendable)
                    throws IOException
```
    Utility method for assisting with writing comments.
    
    Parameters:
    
    comments - The comments to write.
    
    appendable - Write the unit's output to this StyleAppendable.
    
    Throws:
    
    IOException - If an I/O error occurs.
    
    See Also:
    
    Syntax.writesOwnComments(), Syntax.writesOwnOrphanedComments()
  - incrementDepth
```
public StyleWriter incrementDepth()
```
    Increments the stack depth.
    This is usually handled automatically internally, however you may want to call this when writing out inner objects at an artificially deeper depth level. If you do so, be sure to call decrementDepth() at the end.
    
    Returns:
    
    this, for chaining.
  - decrementDepth
```
public StyleWriter decrementDepth()
```
    Decrements the stack depth.
    This is usually handled automatically internally. See incrementDepth() for details on when you may want to use this manually.
    
    Returns:
    
    this, for chaining.
  - countAtCurrentDepth
```
public int countAtCurrentDepth()
```
    Gets the count of the number of peer units previously written out at the current depth level. Units that return false from Writable.isWritable() are not included.
    
    Returns:
    
    The number of peers previously written out at the current depth level.
  - isFirstAtCurrentDepth
```
public boolean isFirstAtCurrentDepth()
```
    Gets whether no peer units have been written out at the current depth level.
    The depth level is incremented every time writeInner(Writable, StyleAppendable) inner is called. For example, two rules within a stylesheet are at the same depth level, two selectors within a rule, two declarations within a rule, etc...
    This is usually used when something should be written only for the first unit in a collection, or conversely for all units but the first.
    
    Returns:
    
    True if no peer units have been written out at the current depth level.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - verbose
```
public static StyleWriter verbose()
```
    Creates a new StyleWriter with WriterMode.VERBOSE mode.
    
    Returns:
    
    The new StyleWriter instance.
  - inline
```
public static StyleWriter inline()
```
    Creates a new StyleWriter with WriterMode.INLINE mode.
    
    Returns:
    
    The new StyleWriter instance.
  - compressed
```
public static StyleWriter compressed()
```
    Creates a new StyleWriter with WriterMode.COMPRESSED mode.
    
    Returns:
    
    The new StyleWriter instance.

Class StyleWriter

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

StyleWriter

StyleWriter

Method Detail

dependencies

mode

mode

isVerbose

isInline

isCompressed

writeAllComments

shouldWriteAllComments

writeAnnotatedComments

shouldWriteAnnotatedComments

writeBangComments

shouldWriteBangComments

addCustomWriter

write

writeTo

writeInner

writeInner

writeSingle

appendComments

incrementDepth

decrementDepth

countAtCurrentDepth

isFirstAtCurrentDepth

toString

verbose

inline

compressed