Feature map - Automate
The best way to view a feature map is on the Start Screen in Tag. There is an interactive graph view and links to all the described apps. Download Tag now to see how it works.
Some of the feature map content related to the Automate app is included below. A list of all feature maps can be found here.
Automate app features
The Automate app offers the widest range of features for any app in Tag. It is the only app that can run pipelines, which is a major source of no-code power.
It can also run logic instructions like the Scribe app does, however there are two key differences:
- The Scribe app has more advanced logic+text functionality, and is able to generate more complex word processing (*.docx) documents
- The Automate app supports a wider range of logic+other functionality, and can generate other document formats including HTML, vector graphics, XML data and more
How are standards used?
The Automate app has support for all open standards supported by Tag, including data, expressions, logic, rich text, vector graphics and pipelines.
This app also lets you open and view files of all recognized document formats.
standards
The Automate app supports six kinds of open standards.
Data standards are used to define how data fields are structured, how data instructions can be reused and available data sources.
Expression standards address features such as paths, math and functions.
Rich text standards define word processing content, format, layout and conversion.
Graphics standards describe how to build graphics logically using common shapes, clever paint, coordinate paths and more.
Logic standards address powerful features like creating content and data, templates, variables and processing rules.
Finally, pipeline standards define pipelines using step containers, steps and behavior rules.
Automate app samples
Click on the arrow icon (hover your mouse over the "samples" topic in the feature graph) to review a list of all samples that work in the Automate app.
If you find a sample of interest, you can jump directly to the Samples app to download it.
export html
Generate website content using logic and data.
How does it work?
HTML is an important format for websites and much more. Tag provides a way to create it dynamically in a way that can be combined with traditional static website content.
Logic can be used to create HTML objects like paragraphs, lists and tables. Inline instructions like bold and italic are also available.
Fragments or sections of HTML that you generate using Tag can be inserted into most existing websites. Visual editors like WordPress and Squarespace usually provide a way insert HTML code. More complex custom websites also (typically) have the ability to integrate chunks of HTML from external sources.
An example of this, is listing product info synchronized with your current data, perhaps including multiple products or services. If your product information changes regularly, this can be a great way to keep your website up to date with minimal effort.
On Windows can preview HTML results using an embedded web browser. This will be available on Macs in a future release.
More info
export svg
Generate vector graphics using logic and data.
How does it work?
SVG is an undiscovered gem for many people. The idea of generating graphic images using logic instructions is unexpected, and compelling.
Logic can be used to create graphic objects like shapes, paths and text. The SVG standard defines a rich set of instructions for defining graphics logically.
SVG includes some advanced effects, such as printing text within a shape, or along a curve or path. These effects can be used to create a logo or other promotional material that supports your brand.
The editing space is current very simple, and you must enter the SVG instructions manually. In the future Tag will provide menus for you to quickly choose from the available options.
On Windows can preview SVG results using an embedded web browser. This will be available on Macs in a future release.
More info
google-api
Tag has built-in support for calling Google API web services.
How does it work?
The pipeline editor lets you insert standard or extension steps into a pipeline. The tag:google extension step allows your pipelines to call Google API.
These calls are similar to Web-API calls made in the Connect app, however they require more advanced authentication.
First you need a Google Cloud project that enables specific APIs to call. There are many to choose from which provide access to other Google services like Drive, Docs, Sheets and more. Each API defines a scope (permission) that the caller must have to proceed.
The first time a pipeline is run that calls Google API for a particular scope, the user will be prompted for permission. You must be logged in to Google in a browser. A login form will display in the browser that lets you grant the pipeline whatever permissions are required. This is the same mechanism that mobile apps use to securely access Google.
The result returned by an API can vary. Calls to the Sheets API can return CSV and other APIs have options to return XML, while in most cases results are returned using JSON. The XML+JSON editor lets you view results, and convert to other formats if possible.
More info
logic+other
Generate a variety of document types using logic and data.
How does it work?
Tag provides a no-code way to use logic to generate many document types. You can insert data, transform it, make chunks of text conditional, perform looping, sorting and more.
This feature is similar to logic+text, in that named templates are used to organize content and logic. The expression editor also works the same way to define logic. However, the editing space is much simpler and doesn't have any text-related tools.
The main editing area is a simple tree that intermixes logic instructions and objects defined by other standards. Common examples of this include HTML (website content) and SVG graphics.
It is possible to generate almost any document type that is based on XML. In this respect, the scope of this feature is far larger than what is described in Tag documentation like this.
More info
pipeline
Automate tasks by combining predefined steps.
How does it work?
Pipeline documents (*.xpl) automate tasks by defining steps that work together. The mechanics are defined by a powerful open standard called XProc.
Tag provides a no-code editor for pipelines that makes it easy to combine useful steps. Typically steps accept input from the previous step, do something with it, and pass the result on to another step. Many other combinations are possible.
For example, consider the following 3 step pipeline. Step 1 loads a file from your computer, step 2 modifies it in some way, and step 3 saves the result to a new file.
There are many predefined steps defined by XProc, including several that generate or modify content/data. The most common file formats used include XML (including all formats based on XML of which there are many), JSON and text. ZIP and other non-text formats can be processed as well.
Tag defines additional custom steps that let you read SQL databases, convert between common file formats, and more.
Pipelines can call other chunks of logic to handle more complex tasks. This includes logic files (p:xslt), web APIs (p:http-request), SQL databases (Tag only - tag:sql), Google API (tag:google) and predefined web API connectors (tag:connector).
More info
view files
The Automate app can display many file types. When possible, multiple view modes are provided for each file.
How does it work?
Some types are displayed using a no-code editor or viewer (XSLT, XSL-FO, XProc, RNG, CSV and DOCX).
Other types are displayed using an embedded Windows-only web browser (HTML, SVG, XHTML).
JSON and all XML-based types are displayed using a no-code tree editor.
All text-based files (including most of the above) are displayed using a text editor.
Finally, some types have specialized viewers (images, Microsoft Access, PDF, XQuery and ZIP).
connectors
Web APIs can be called from pipelines and forms.
How does it work?
The Connect app lets you save the instructions to call a web API as a connector. The tag:connector extension step allows pipelines to call remote web APIs from within Tag.
The result returned by a web API is usually JSON. In pipelines this is handled like any JSON content and displays to the user as a tree. It can be saved to a file or converted to XML for further processing.
When importing web APIs into Scribe forms, the data can be mapped to specific form fields using expressions. This works the same way as mapping from XML, and displays the input JSON to the user as a tree.
More info
data setup
Data setup uses instructions to describe your data.
How does it work?
There are 2 main open standards that let you define data. XML Schema is widely used and very powerful, although it is often criticized for being overly complex. RELAX NG (RNG) is an alternative that has it all in the name - "relax".
The rules defined by RNG are generally simpler, and more intuitive for most human users. It can't handle some complex (e.g., scientific) XML structures, but it can handle the vast majority of what's needed by business documents.
Tag uses RNG to describe data and includes a no-code editor to create it. The editor lets you build a tree structure for data, where branches contain information about datatype (string, number, date, etc.) and settings like required/optional. It also lets you list valid string values for a field, which can be used to fill pick lists in a form.
It is possible to use XML Schemas in Tag in some cases. This support is expected to improve over time.
More info
docx export
Generate content for popular word processors.
How does it work?
Word processing files named *.docx use an open standard (Office Open XML) that is widely recognized. In particular, this is the preferred format for Microsoft Word.
While this standard uses XML, it is notoriously difficult to generate content with due to a non-hierarchical internal structure. Tag's approach is to generate content using XSL-FO, which has an excellent internal structure, and then convert the result to *.docx for final editing in your favorite word processor.
This is not an exhaustive solution, and only uses a subset of rich text instructions from either open standard. However, this subset covers the 20% of functionality used by 80% of most document types.
One added benefit to this approach, is that you can use inherited properties in ways that work processors won't let you. For example, you can change the font once at the table level and have that setting apply to all text within the table.
The Scribe app uses *.docx as its preferred output format. The Automate app provides it as an option when generating logic+text.
More info
expr editor
Provides 4 ways to edit expressions.
How does it work?
Expressions are used in many places in Tag. They are critical for defining logic and pipelines, by deciding true/false conditions, performing math, calculating values and more.
Due to this importance, Tag includes a no-code expression editor that has 3 point-and-click panels and 1 text panel that shows raw XPath syntax.
The quick values panel lists common expressions in a tree (e.g., insert a source data value). For some datatypes additional options appear in the tree (e.g., format a date).
The basic panel builds true/false expressions such as those used in if and choose/when instructions. It includes menus to select left and right values and a compare option between them.
The advanced panel includes a more extensive menu to create and combine expression parts. It supports for-loops, sequences, arrays, maps, functions and more.
More info
logic+text
Generate word processing documents using logic and data
How does it work?
Tag provides a no-code way to use logic to generate content. You can insert data, transform it, make chunks of text conditional, perform looping, sorting and more.
Rich text is defined using blocks of text (paragraphs), lists, images and tables. Sections of text within blocks can be styled (bold, inline) or used to insert computed phrases.
The main editing area is like a word processor, with additional buttons to insert and edit logic. Logic bubbles are used to define logic and wrap freely within text like small images.
Logic is defined primarily using an expression editor, which lets you access attached data using a tree.
Content and logic are organized within named templates. The editor displays one template at a time, and you can call templates as much as you want from one another.
More info
logic bubbles
Logic bubbles embed instructions within rich text.
How do they work?
When mixing logic with rich text, authors need the freedom to insert detailed instructions at any point in the content (e.g., only insert a phrase/paragraph/section if the test expression returns true, insert a data value).
Logic bubbles represent any instruction, and float within rich text just like small images. You can freely type around them and even copy/paste like normal text.
When you click on a bubble more options appear. Some bubbles let you open the expression editor, while others open the call-template dialog.
Logic bubbles are only applicable for logic embedded within rich text. The Scribe app uses them extensively, while the Automate app also uses them when you combine logic and rich text.
More info
sql query
SQL databases can be called from pipelines and forms.
How does it work?
The pipeline editor lets you insert standard or extension steps into a pipeline. The tag:sql extension step allows pipelines to call remote SQL databases from within Tag.
The pipeline editor includes a no-code SQL query builder that explores database tables and columns. Options are provided to create common queries, or you can paste and/or edit manually using JDBC SQL syntax.
The SQL database type must be known. Tag currently supports three common types (Microsoft SQL Server, MySQL and Microsoft Access), and more will be added over time.
The result returned by a SQL query is converted into XML that describes rows and columns (CSV data is handled the same way). The XML+JSON editor lets you view query results, and convert to other formats if possible.
When importing into pipelines the result is treated like XML data. When importing into Scribe forms, the data can be mapped to specific form fields.
More info
xml+json
A data editor that supports multiple formats.
How does it work?
There are several pipeline steps that access external data including web APIs and SQL databases. The Scribe and Connect apps also provide ways to import data in a similar way.
The XML+JSON editor was created to handle this data in a consistent way. It contains 3 views of the same data using 3 formats (XML, JSON and text), where the text view always shows raw markup. The XML and JSON views use a tree to display data and work much the same.
When moving between XML and JSON formats, data is automatically converted. There are 2 ways to convert either way (XPath and Jackson) which can handle many situations. Note that there are some XML documents (e.g., XHTML) which do not convert properly to JSON using the Jackson approach.
A common scenario is converting JSON returned by a web API to XML, which can be processed further by pipeline or logic instructions. XML offers a much wider range of processing options, which makes this functionality quite important.