scrivito_sdk 0.12.0

data/lib/scrivito/rate_limit_exceeded.rb

@@ -0,0 +1,5 @@
+module Scrivito
+  class RateLimitExceeded < CommunicationError
+
+  end
+end

data/lib/scrivito/revision.rb

@@ -0,0 +1,9 @@
+module Scrivito
+
+class Revision < Struct.new(:id, :content_state, :workspace)
+  def initialize(options)
+    super(*options.values_at(:id, :content_state, :workspace))
+  end
+end
+
+end

data/lib/scrivito/string_tagging.rb

@@ -0,0 +1,18 @@
+module Scrivito
+
+  # adds flavour to strings
+  module StringTagging
+
+    # html flavour
+    def self.tag_as_html(string)
+      unless string.blank?
+        class << string
+          include Scrivito::HtmlString
+        end
+      end
+      string
+    end
+
+  end
+
+end

data/lib/scrivito/text_link.rb

@@ -0,0 +1,52 @@
+module Scrivito
+
+class TextLink
+
+  def initialize(link_data)
+    @data = link_data
+  end
+
+  def query_and_fragment
+    query = @data["query"]
+    fragment = @data["fragment"]
+
+    str = ''
+    str << "?#{query}" if query.present?
+    str << "##{fragment}" if fragment.present?
+    str
+  end
+
+  def internal?
+    !url
+  end
+
+  def external_url
+    url =~ /(external:)?(.*)/
+    $2
+  end
+
+  def obj_id
+    @data["destination"]
+  end
+
+  def html_attribute_snippet
+    tag_name = @data["tag_name"]
+    title = @data["title"]
+    target = @data["target"]
+
+    parts = []
+    parts << %{alt="#{title}"} if tag_name == 'img' || tag_name == 'input'
+    parts << %{title="#{title}"} if (tag_name == 'a' || tag_name == 'link') && title.present?
+    parts << %{target="#{target}"} if target.present?
+    parts.join(' ')
+  end
+
+  private
+
+  def url
+    @data["url"]
+  end
+
+end
+
+end

data/lib/scrivito/text_link_conversion.rb

@@ -0,0 +1,52 @@
+module Scrivito
+
+class TextLinkConversion
+
+  def initialize(text_links)
+    @text_links = text_links
+  end
+
+  def convert(html)
+    return html unless @text_links
+
+    if html
+      html.gsub(%r{<?\binternallink:(\d+)\b>?(['"]?)}) do
+        link = @text_links[$1]
+        postfix = $2
+        if link
+          attach_snippet("#{convert_link(link)}#{postfix}", link)
+        else
+          "#__text_link_missing#{postfix}"
+        end
+      end
+    end
+  end
+
+  private
+
+  def convert_link(link)
+    link.internal? ? convert_internal_link(link) : convert_external_link(link)
+  end
+
+  def attach_snippet(text, link)
+    snippet = link.html_attribute_snippet
+    if snippet.present?
+      "#{text} #{snippet}"
+    else
+      text
+    end
+  end
+
+  def convert_internal_link(link)
+    if link.obj_id
+      "objid:#{link.obj_id}#{link.query_and_fragment}"
+    end
+  end
+
+  def convert_external_link(link)
+    link.external_url
+  end
+
+end
+
+end

data/lib/scrivito/type_computer.rb

@@ -0,0 +1,34 @@
+module Scrivito
+
+class TypeComputer
+  def initialize(base_class, fallback_class)
+    @base_class, @fallback_class = base_class, fallback_class
+    @type_cache = {}
+  end
+
+  def compute_type(obj_class)
+    @type_cache.fetch(obj_class) { calculate_type(obj_class) }
+  end
+
+  def special_class?(klass)
+    klass == @base_class || klass == @fallback_class
+  end
+
+  private
+
+  def calculate_type(obj_class)
+    load_class(obj_class) || @fallback_class
+  end
+
+  def load_class(obj_class)
+    klass = obj_class.constantize
+    klass if inherits_from_base?(klass)
+  rescue NameError
+  end
+
+  def inherits_from_base?(klass)
+    klass.ancestors.include?(@base_class) && klass != @base_class
+  end
+end
+
+end

data/lib/scrivito/widget_field_params.rb

@@ -0,0 +1,61 @@
+module Scrivito
+
+class WidgetFieldParams
+  class UnknownWidgetAction < ScrivitoError
+  end
+
+  attr_reader :pool_params
+
+  def initialize
+    @pool_params = {}
+  end
+
+  def convert(params)
+    widget_ids = []
+
+    params.each do |widget_id_or_spec|
+      if widget_id_or_spec.is_a?(Hash)
+        action, spec = parse_action_and_spec(widget_id_or_spec)
+        case action
+        when 'create' then widget_ids << create_widget(spec)
+        when 'copy' then widget_ids << copy_widget(*spec.values_at(:src_obj_id, :src_widget_id))
+        else raise UnknownWidgetAction
+        end
+      else
+        widget_ids << widget_id_or_spec
+      end
+    end
+
+    {'list' => widget_ids.map { |widget_id| {'widget' => widget_id} }}
+  end
+
+  private
+
+  def parse_action_and_spec(params)
+    action, spec = params.flatten
+    [action.to_s, spec.with_indifferent_access]
+  end
+
+  def create_widget(params)
+    widget_pool_id = BasicObj.generate_widget_pool_id
+    # At the moment the 'create' action supports only the '_obj_class' field.
+    @pool_params[widget_pool_id] = {'_obj_class' => params['_obj_class']}
+    widget_pool_id
+  end
+
+  def copy_widget(src_obj_id, src_widget_id)
+    src_obj_content = CmsRestApi.get("workspaces/#{Workspace.current.id}/objs/#{src_obj_id}")
+    widget_params = src_obj_content['_widget_pool']["#{src_widget_id}"]
+
+    raise ResourceNotFound, "could not find widget with id #{src_widget_id}" unless widget_params
+
+    src_widget = BasicObj.find(src_obj_id).widget_from_pool(src_widget_id)
+    widget_params.delete_if { |field_name, _| src_widget.type_of_attribute(field_name) == 'widget' }
+
+    widget_pool_id = BasicObj.generate_widget_pool_id
+    @pool_params[widget_pool_id] = widget_params
+    widget_pool_id
+  end
+end
+
+end

data/lib/scrivito/widget_garbage_collection.rb

@@ -0,0 +1,97 @@
+module Scrivito
+
+class WidgetGarbageCollection
+
+  # @param [BasicObj] obj the Obj that the update applies to
+  # @param [Hash] update the keys are content objects (Obj or Widget)
+  #   and the values are their update params.
+  #   update params are accepted in the same format as accepted by Obj.create or Obj#update.
+  #   each content object must either be the obj itself or a widget that lives inside the obj.
+  def initialize(obj, update)
+    if update.blank?
+      raise ScrivitoError, "blank update!"
+    end
+
+    update.keys.each do |content|
+      if content.is_a?(BasicObj)
+        raise "invalid obj given" unless content == obj
+      elsif content.is_a?(BasicWidget)
+        raise "invalid widget given" unless content.obj == obj
+      else
+        raise "invalid key"
+      end
+    end
+
+    @update = update
+    @obj = obj
+  end
+
+  # @return [Array] list containing the widgets that are no longer needed after the update.
+  def widgets_to_delete
+    dereferenced = []
+    newreferenced = []
+
+    @update.each do |content, params|
+      (deref, newref) = changed_references_from(content, params)
+      dereferenced += deref
+      newreferenced += newref
+    end
+
+    deleted_by_dereference = dereferenced - newreferenced
+
+    recursivly_deleted = []
+    deleted_by_dereference.each do |widget|
+      recursivly_deleted += all_widgets_contained_in_except(widget, newreferenced)
+    end
+
+    # we dont want to slow dont every request by scanning for orphans, so
+    # we only do this when widgets are being deleted
+    if deleted_by_dereference.present?
+      orphans = @obj.all_widgets_from_pool - @obj.contained_widgets - newreferenced
+    else
+      orphans = []
+    end
+
+    deleted_by_dereference + recursivly_deleted + orphans
+  end
+
+  private
+
+  def all_widgets_contained_in_except(widget, exceptions)
+    widget_children = widget.referenced_widgets - exceptions
+
+    widget_descendants = widget_children.map do |child|
+      all_widgets_contained_in_except(child, exceptions)
+    end.flatten
+
+    widget_children + widget_descendants
+  end
+
+  def changed_references_from(content, params)
+    dereferenced_ids = []
+    newreferenced_ids = []
+
+    if content.kind_of?(BasicWidget) && !content.persisted?
+      params.each_value do |value|
+        if value.kind_of?(Array)
+          newreferenced_ids += value.select { |v| v.kind_of?(BasicWidget) }
+        end
+      end
+    else
+      params.each do |key, value|
+        if content.type_of_attribute(key) == "widget"
+          current = content[key]
+          new = value
+
+          dereferenced_ids += current - new
+          newreferenced_ids += new - current
+        end
+      end
+    end
+
+    [dereferenced_ids, newreferenced_ids]
+  end
+
+end
+
+end

data/lib/scrivito/workspace.rb

@@ -0,0 +1,222 @@
+module Scrivito
+
+# This class represents a CMS workspace
+# @api public
+class Workspace
+  PUBLISHED_ID = 'published'
+
+  extend ActiveModel::Naming
+
+  include ModelIdentity
+
+  # Set the currently used workspace
+  # @api public
+  # @param [Scrivito::Workspace] workspace
+  def self.current=(workspace)
+    @current = workspace
+  end
+
+  def self.current_using_proc=(workspace_proc)
+    @current = workspace_proc
+  end
+
+  # Returns the currently used workspace
+  # @api public
+  # @return [Scrivito::Workspace]
+  def self.current
+    if @current.respond_to? :call
+      @current = @current.call
+    else
+      @current ||= default
+    end
+  end
+
+  # Returns all the workspaces
+  # @api public
+  # @return [Array<Scrivito::Workspace>]
+  def self.all
+    result_json = CmsRestApi.get('/workspaces')
+
+    result_json['results'].map do |workspace_json|
+      Workspace.find(workspace_json['id'])
+    end
+  end
+
+  def self.default
+    published
+  end
+
+  def self.published
+    cache.fetch(PUBLISHED_ID) do
+      cache[PUBLISHED_ID] = find(PUBLISHED_ID)
+    end
+  end
+
+  # Find a workspace by its id
+  # @api public
+  # @param [String] id
+  # @return [Scrivito::Workspace]
+  # @raise [Scrivito::ResourceNotFound]
+  def self.find(id)
+    if workspace_data = CmsBackend.instance.find_workspace_data_by_id(id)
+      Workspace.new workspace_data
+    else
+      raise ResourceNotFound, "Could not find #{self} with id #{id}"
+    end
+  end
+
+  # Find a workspace by its title.
+  # If multiple workspaces share the same title, one of them is returned.
+  # If no workspace with the given title can be found, nil is returned.
+  # @api public
+  # @param [String] title
+  # @return [Scrivito::Workspace]
+  def self.find_by_title(title)
+    all.detect { |workspace| workspace.title == title }
+  end
+
+  delegate :content_state, :base_revision_id, :base_content_state, to: :data
+
+  # Create a new workspace
+  # @api public
+  # @param [Hash] attributes
+  # @return [Scrivito::Workspace]
+  def self.create(attributes)
+    workspace_json = CmsRestApi.post("/workspaces", workspace: attributes)
+
+    self.find(workspace_json["id"])
+  end
+
+  # reloads the current workspace to reflect any changes to it that may have happened concurrently
+  # since it was loaded
+  # @api public
+  def self.reload
+    id = current.id
+    self.current_using_proc = proc { find(id) }
+  end
+
+  def self.cache
+    @cache ||= {}
+  end
+
+  def initialize(workspace_data)
+    @workspace_data = workspace_data
+  end
+
+  # Reloads this workspace to reflect any changes to it that may have happened concurrently since
+  # it was loaded
+  # @api public
+  def reload
+    @workspace_data = CmsBackend.instance.find_workspace_data_by_id(self.id)
+    @revision = @base_revision = nil
+  end
+
+  # Updates this workspace's attributes
+  # @api public
+  # @param [Hash] attributes
+  # @return [Scrivito::Workspace]
+  def update(attributes)
+    CmsRestApi.put(backend_url, workspace: attributes)
+
+    self.reload
+  end
+
+  # Destroy this workspace
+  # @api public
+  def destroy
+    reset_workspace_if_current
+    CmsRestApi.delete(backend_url)
+  end
+
+  # Publish the changes of this workspace
+  # @api public
+  def publish
+    CmsRestApi.put("#{backend_url}/publish", {})
+
+    reset_workspace_if_current
+  end
+
+  # Rebases the current workspace on the published content
+  # @api public
+  def rebase
+    CmsRestApi.put("#{backend_url}/rebase", {})
+
+    self.reload
+  end
+
+  # Returns the id of the workspace
+  # @api public
+  # @return [String]
+  def id
+    @workspace_data.id
+  end
+
+  def revision_id
+    @workspace_data.revision_id
+  end
+
+  # Returns the title of the workspace
+  # @api public
+  # @return [String]
+  def title
+    @workspace_data.title
+  end
+
+  def data
+    @workspace_data
+  end
+
+  def published?
+    self.id == 'published'
+  end
+
+  def rtc?
+    self.id == 'rtc'
+  end
+
+  def revision
+    @revision ||= Revision.new(id: revision_id, content_state: content_state, workspace: self)
+  end
+
+  def base_revision
+    if base_revision_id
+      @base_revision ||= Revision.new(id: base_revision_id, content_state: base_content_state)
+    end
+  end
+
+  def as_current(&block)
+    old_workspace = Workspace.current
+
+    begin
+      Workspace.current = self
+
+      yield
+    ensure
+      Workspace.current = old_workspace
+    end
+  end
+
+  def assert_revertable
+    raise ScrivitoError, 'published workspace is not modifiable' if published?
+    raise ScrivitoError, 'rtc workspace may contain attribute and class changes' if rtc?
+  end
+
+  def inspect
+    "<#{self.class} id=\"#{id}\" title=\"#{title}\">"
+  end
+
+  private
+
+  def backend_url
+    "/workspaces/#{id}"
+  end
+
+  def reset_workspace_if_current
+    if Workspace.current == self
+      Workspace.current = Workspace.default
+    end
+  end
+
+end
+
+end