Scrivito 0.90.0 Release Notes

Items added or changed after the release of RC 1 are marked with [0.90.0.rc2] or [0.90.0.rc3], repectively.

Improvements

New API for defining and selecting editors

The JavaScript API now provides a more concise way to define an editor for in-place editing:

Copy
scrivito.define_editor("editor_name", {
  can_edit: function(element) {
    // 1. Check whether the editor is suitable for editing the element.
  },
  activate: function(element) {
    // 2. Activate the editor.
  }
});

The UI calls can_edit to determine whether the editor is capable of editing the given element. If the callback returns a truthy value, activate is called to activate the editor.

We also provided a new API for specifying the editor to use for a particular field:

Copy
scrivito.select_editor(function(element, editor) {
  if ($(element).is(".my_field")) {
    editor.use("my_editor"); // Use "my_editor" if CSS class is "my_field".
  }

  if ($(element).is(".restricted_field")) {
    editor.disable(); // Disable editing if CSS class is "restricted_field".
  }
});

If the select_editor callback specifies the editor to use, the UI checks whether this editor exists and, if it does, as mentioned above, calls its can_edit method to determine whether the editor is suitable for editing the field. If it is, the UI activates the editor by calling its activate method.

Call the disable method of an editor to completely prevent the field from being edited, regardless of any subsequent calls to use.

There is more detailed documentation on using and defining editors.

One helper to render them all

The scrivito_tag view helper now renders attributes for which dedicated helpers were needed previously. Therefore, these dedicated helpers were removed, namely scrivito_edit_enum, scrivito_edit_multienum, scrivito_edit_reference, scrivito_edit_referencelist, scrivito_edit_link, and scrivito_edit_linklist. When upgrading to this SDK version, calls to them should be replaced with calls to the scrivito_tag helper:

Copy
# Instead of

<%= scrivito_edit_enum @obj, :my_enum %>
<%= scrivito_edit_multienum @obj, :my_multienum %>
<%= scrivito_edit_reference @obj, :my_reference %>
<%= scrivito_edit_referencelist @obj, :my_referencelist %>
<%= scrivito_edit_link @obj, :my_link %>
<%= scrivito_edit_linklist @obj, :my_linklist %>

# you should now simply write

<%= scrivito_tag :div, @obj, :my_enum %>
<%= scrivito_tag :div, @obj, :my_multienum %>
<%= scrivito_tag :div, @obj, :my_reference %>
<%= scrivito_tag :div, @obj, :my_referencelist %>
<%= scrivito_tag :div, @obj, :my_link %>
<%= scrivito_tag :div, @obj, :my_linklist %>

The helpers were removed because they are no longer required for activating the corresponding editors. Instead, the editors are now activated by default for the attribute types concerned.

Previously, these helpers were also needed to have the attribute values rendered in preview mode. However, the scrivito_tag helper does not yet provide this functionality and doesn't render markup equivalent to the markup the removed helpers produced. In most cases, though, you probably haven't used those helpers in views responsible for displaying the preview. But if you did and wish to stick to the formatting previously provided by these helpers, you might want to define them in your application:

Copy
def scrivito_edit_enum(obj_or_widget, attribute_name, options = {})
  scrivito_tag(:div, obj_or_widget, attribute_name, options)
end
Copy
def scrivito_edit_multienum(obj_or_widget, attribute_name, options = {})
  scrivito_tag(:div, obj_or_widget, attribute_name, options) do
    obj_or_widget[attribute_name].join(", ")
  end
end
Copy
def scrivito_edit_reference(obj_or_widget, attribute_name, options = {})
  scrivito_tag(:div, obj_or_widget, attribute_name, options) do
    obj_or_widget[attribute_name].try(:description_for_editor)
  end
end
Copy
def scrivito_edit_referencelist(obj_or_widget, attribute_name, options = {})
  referencelist = obj_or_widget[attribute_name]
  scrivito_tag(:div, obj_or_widget, attribute_name, options) do
    if referencelist.any?
      content_tag(:ul) do
        capture do
          referencelist.each do |reference|
            li = content_tag(:li) do
              content_tag(:span, reference.description_for_editor, class: "list-content")
            end
            concat li
          end
        end
      end
    end
  end
end
Copy
def scrivito_edit_link(obj_or_widget, attribute_name, options = {})
  link = obj_or_widget[attribute_name] || Scrivito::Link.new(url: "")
  scrivito_tag(:div, obj_or_widget, attribute_name, options) do
    content_tag(:ul) do
      content_tag(:li) do
        content_tag(:span, class: "list-content") do
          query = link.query.present? ? "?#{link.query}" : ""
          fragment = link.fragment.present? ? "##{link.fragment}" : ""
          url = link.internal? ? scrivito_path(link).sub(/\?.*/, "#{query}#{fragment}") : link.url
          description = link.internal? ? link.obj.description_for_editor : link.url
          "#{link.title} #{link_to(description, url, target: :_blank)}".html_safe
        end
      end
    end
  end
end
Copy
def scrivito_edit_linklist(obj_or_widget, attribute_name, options = {})
  linklist = obj_or_widget[attribute_name]
  scrivito_tag(:div, obj_or_widget, attribute_name, options) do
    if linklist.any?
      content_tag(:ul) do
        capture do
          linklist.each do |link|
            li = content_tag(:li) do
              content_tag(:span, class: "list-content") do
                query = link.query.present? ? "?#{link.query}" : ""
                fragment = link.fragment.present? ? "##{link.fragment}" : ""
                url = link.internal? ? scrivito_path(link).sub(/\?.*/, "#{query}#{fragment}") : link.url
                description = link.internal? ? link.obj.description_for_editor : link.url
                "#{link.title} #{link_to(description, url, target: :_blank)}".html_safe
              end
            end
            concat li
          end
        end
      end
    end
  end
end

Breaking changes

Scrivito now raises an error if the scrivito_tag helper is used to render an attribute that doesn't exist.


We unified the naming of the data attributes recognized by Scrivito's in-place editors.

Scrivito's editors can be configured through various HTML data attributes. These attributes weren't named consistently in the past. From this release on, all data attributes recognized by Scrivito editors are prefixed with data-scrivito-editors-:

Deprecated Renamed to
data-autosave data-scrivito-editors-autosave
data-date-format data-scrivito-editors-date-format
data-filter-context data-scrivito-editors-filter-context
data-filters data-scrivito-editors-filters
data-max data-scrivito-editors-max
data-min data-scrivito-editors-min
data-newlines data-scrivito-editors-multiline*
data-placeholder data-scrivito-editors-placeholder
data-reload data-scrivito-editors-reload
data-step data-scrivito-editors-step
data-time-format data-scrivito-editors-time-format
data-values not used

*On this occasion, we also renamed data-newlines (now deprecated) to data-scrivito-editors-multiline. Please refer to the documentation for the complete list of available data attributes.


We also streamlined the naming of Scrivito Editors. The Redactor WYSIWYG editor can now be made available using the editor: 'redactor' option of the scrivito_tag helper, but you might also continue using the default editor: 'html'. For not being chained to Redactor, use html to activate the primary WYSIWYG HTML editor, which is going to be the Medium Editor from one of the upcoming releases.

If you have been using scrivito.editors.html_editor.redactor.options in your JavaScript, please update to scrivito.editors.redactor_editor.options.


Because of buggy and cumbersome behavior, Scrivito no longer lets you set empty strings as selectable values of enum or multienum attributes.

Further improvements and changes

We added an alternative HTML editor to the collection of Scrivito Editors. You can now offer the MediumEditor to website editors for even more WYSIWYG convenience.

Just request the new medium editor in your scrivito_tag:

Copy
scrivito_tag(my_obj_or_widget, :my_html_attribute, {}, editor: :medium)

Workspaces now have a published? method. It lets you determine for a specific working copy whether it is the published one or not. In addition, the published class method was provided for retrieving the workspace that represents the published content. For example, you can now write the following code to retrieve all editable working copies:

Copy
editable_workspaces = Scrivito::Workspace.all.reject(&:published?)
# or
editable_workspaces = Scrivito::Workspace.all - [Scrivito::Workspace.published]

[0.90.0.rc2] In the JavaScript API, the present, disabled, and execute callbacks that can be specified in $.scrivito("menu").add, $.scrivito("menu").update or $.scrivito("menu").replace are no longer provided with the DOM element concerned since this element can be derived from the context.

Bugfixes

We fixed a bug in the scrivito_details_for helper that occurred when it was called outside of a view, e.g. in a helper. In such cases, the return value of the block was not rendered.

The "Click to edit" placeholders are now always clickable in Chrome.

The JavaScript search API (scrivito.obj_where) had a bug that caused searches by date to take account of the year only. For example, searching for all CMS objects changed after May 5, 2015 returned all CMS objects changed in 2015. This bug has been fixed.

[0.90.0.rc3] We fixed the problem that in-place editors weren't activated again on pages after the details view, which used the same editors, had been opened.

More great blog posts from Andreas Viebke