scrivito_sdk 0.12.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 24c7dcabf5aef63eb33bcdd0a13f588c3be4c524
+  data.tar.gz: 1461028fb468bed23183f63921081cb0560d213c
+SHA512:
+  metadata.gz: 0251875fb48fdabcd26e4d0cef5e743218e8f4606c47cbc778a7d0bf02a83e278c3b3aafbc6ec647830c8b0c99e22abe32f6b8b6b2c01d794864596485317027
+  data.tar.gz: ebfe1320eaf24a181166a5d40620e31580ec4249795150da9a86ee2c4e6eb918e4fc3f6b58820254a25657cc56f34930d51d33c9cc1aa1502795024a52c0fea9

data/.yardopts

@@ -0,0 +1,5 @@
+--hide-void-return
+--protected
+--private
+--non-transitive-tag api
+--api public

data/README

@@ -0,0 +1,6 @@
+= Scrivito SDK
+
+The Scrivito SDK makes CMS objects maintained by means of the cloud-based Scrivito CMS available to your Rails application.
+It offers easy-to-use functionality for rendering CMS content, doing searches, etc.
+
+For more information about Scrivito, please visit {http://scrivito.com/}.

data/app/controllers/cms_controller.rb

@@ -0,0 +1,7 @@
+# This controller inherits all of its behavior from
+# {Scrivito::DefaultCmsController}.
+#
+# {CmsController} is referenced by the Scrivito routes.
+# @api public
+class CmsController < Scrivito::DefaultCmsController
+end

data/app/controllers/scrivito/blobs_controller.rb

@@ -0,0 +1,10 @@
+module Scrivito
+
+class BlobsController < WebserviceController
+  def upload_permission
+    permission = CmsRestApi.task_unaware_request(:get, 'blobs/upload_permission')
+    render json: permission
+  end
+end
+
+end

data/app/controllers/scrivito/default_cms_controller.rb

@@ -0,0 +1,61 @@
+module Scrivito
+
+  # This controller provides some default includes ({CmsAccessible}),
+  # before filters (+load_object+, among others), and actions to simplify
+  # CMS object handling. It should never be used directly, but only as a
+  # super class to {CmsController}.
+  # @api public
+  class DefaultCmsController < ApplicationController
+    include CmsAccessible
+
+    before_filter :load_object
+    before_filter :authorize_editor, only: [:show_widget, :widget_details]
+
+    # Default Action. Delivers files directly if {BasicObj#binary?}.
+    # Otherwise the view is rendered.
+    # @api public
+    def index
+      deliver_file if @obj.binary?
+    end
+
+    def show_widget
+      widget = load_widget
+      render layout: false, locals: {widget: widget}
+    end
+
+    def widget_details
+      widget = load_widget
+      template_path = "#{widget.obj_class_name.underscore}/details"
+      render template_path, layout: false, locals: {widget: widget}
+    end
+
+    # This method indicates if this controller should be used automatically when an Obj is
+    # requested via the Scrivito's standard routes. It returns true by default.
+    #
+    # Overwrite it to return false if you do want your controller to be excluded from Obj dispatching.
+    #
+    # You may also implement a method with the name {use_for_obj_dispatch?} in controllers not
+    # descending from {DefaultCmsController} to include them in Obj dispatching.
+    #
+    # @see Obj#controller_name
+    # @api public
+    def self.use_for_obj_dispatch?
+      true
+    end
+
+    private
+
+    def authorize_editor
+      head(:forbidden) unless editing_context.authenticated_editor?
+    end
+
+    def editing_context
+      request.env[EditingContextMiddleware::ENVKEY] || EditingContext.new
+    end
+
+    def load_widget
+      @obj.widget_from_pool(params[:widget_id])
+    end
+  end
+
+end

data/app/controllers/scrivito/objs_controller.rb

@@ -0,0 +1,200 @@
+module Scrivito
+
+  class ObjsController < WebserviceController
+    before_filter :ensure_identical_selected_and_visible_workspace, only: [:create, :update, :copy,
+        :duplicate, :page_class_selection, :create_widget, :widget_class_selection, :copy_widget]
+
+    def create
+      created_obj = task_unaware_request(:post,
+        "workspaces/#{Workspace.current.id}/objs",
+        {obj: obj_params}
+      )
+      render json: created_obj
+    end
+
+    def details
+      load_object
+      render json: {markup: render_to_string(@obj.details_view_path, layout: false)}
+    end
+
+    def update
+      load_object
+      changed_obj = task_unaware_request(:put,
+        "workspaces/#{Workspace.current.id}/objs/#{params[:id]}",
+        {obj: obj_params}
+      )
+      render json: changed_obj
+    end
+
+    def destroy
+      in_selected_workspace { load_object.destroy }
+      render_empty_json
+    end
+
+    def revert
+      in_selected_workspace { load_object.revert }
+      render_empty_json
+    end
+
+    def restore
+      in_selected_workspace { Obj.restore(params[:id]) }
+      render_empty_json
+    end
+
+    def mark_resolved
+      in_selected_workspace { load_object.mark_resolved }
+      render_empty_json
+    end
+
+    def copy
+      render json: copy_obj(get_obj_attributes(params[:id]), params[:parent_path])
+    end
+
+    def duplicate
+      attributes = get_obj_attributes(params[:id])
+
+      render json: copy_obj(attributes, parent_path(attributes['_path']))
+    end
+
+    def page_class_selection
+      valid_page_classes = Obj.valid_page_classes_beneath(params[:parent_path]) ||
+          Obj.descendants
+      valid_page_classes.map!(&:to_s)
+
+      page_class_names = valid_page_classes.map do |page_class_name|
+        begin
+          markup = render_to_string("#{page_class_name.underscore}/thumbnail")
+          {name: page_class_name, markup: markup}
+        rescue ActionView::MissingTemplate
+        end
+      end
+
+      render json: page_class_names.compact
+    end
+
+    def widget_class_selection
+      load_object
+      valid_widget_classes = @obj.valid_widget_classes_for(params[:field_name]) ||
+          Widget.descendants
+      valid_widget_classes.map!(&:to_s)
+
+      widgets_classes = valid_widget_classes.map do |widget_class_name|
+        template_path = "#{widget_class_name.underscore}/thumbnail"
+        markup = begin
+          render_to_string(template_path, layout: false)
+        rescue ActionView::MissingTemplate
+          render_to_string('scrivito/widget_thumbnail', layout: false,
+              locals: {widget_class_name: widget_class_name, template_path: template_path})
+        end
+        {name: widget_class_name, markup: markup}
+      end
+
+      render json: widgets_classes
+    end
+
+    def create_widget
+      load_object
+      widget_pool_id = BasicObj.generate_widget_pool_id
+
+      task_unaware_request(:put, "workspaces/#{Workspace.current.id}/objs/#{params[:id]}",
+          {obj: {_widget_pool: {widget_pool_id => {_obj_class: params[:obj_class]}}}})
+
+      Workspace.reload
+      @obj.reload
+
+      @widget = @obj.widget_from_pool(widget_pool_id)
+
+      render json: {markup: render_to_string(layout: false)}
+    end
+
+    def copy_widget
+      load_object
+      new_widget_id = @obj.copy_widget_from(params[:src_obj_id], params[:src_widget_id])
+
+      Workspace.reload
+      @obj.reload
+
+      @widget = @obj.widget_from_pool(new_widget_id)
+
+      render json: {markup: render_to_string(layout: false)}
+    end
+
+    def search
+      in_selected_workspace do
+        query = MultiJson.decode(params[:query]).with_indifferent_access
+        search_builder = ObjSearchBuilder.new(query)
+        enumerator = search_builder.build
+
+        if params[:query_action] == 'size'
+          result = { total: enumerator.size }
+        else
+          batch = enumerator.load_batch
+
+          result = {
+            total: enumerator.size,
+            hits: batch
+          }
+        end
+
+        render json: result
+      end
+    rescue ObjSearchEnumerator::UnregisteredObjFormat => e
+      render json: { error: e.message }, status: :not_found
+    end
+
+    private
+
+    def load_object
+      @obj = Obj.find(params[:id])
+    end
+
+    def ensure_identical_selected_and_visible_workspace
+      if editing_context.selected_workspace != editing_context.visible_workspace
+        raise ScrivitoError, "selected and visible workspace are not identical"
+      end
+    end
+
+    def obj_params
+      @obj_params ||= ObjParamsParser.new(request.host, request.port).parse(@obj, params[:obj])
+    end
+
+    def copy_obj(attributes, target_path=nil)
+      copied_attributes = attributes.except!('id', '_id', '_permalink')
+      copied_attributes['_path'] = "#{target_path}/#{SecureRandom.hex(6)}"
+
+      task_unaware_request(:post, "workspaces/#{Workspace.current.id}/objs", obj: copied_attributes)
+    end
+
+    def get_obj_attributes(id)
+      task_unaware_request(:get, "workspaces/#{Workspace.current.id}/objs/#{id}")
+    end
+
+    def parent_path(path)
+      path.split('/')[0..-2].join('/')
+    end
+
+    def current_page
+      Obj.find(params[:current_page_id]) if params[:current_page_id].present?
+    end
+    helper_method :current_page
+
+    delegate :task_unaware_request, to: CmsRestApi
+
+    private
+
+    def editing_context
+      request.env[EditingContextMiddleware::ENVKEY] || EditingContext.new
+    end
+
+    def in_selected_workspace
+      editing_context.selected_workspace.as_current do
+        yield
+      end
+    end
+
+    def render_empty_json
+      render json: {}
+    end
+  end
+
+end

data/app/controllers/scrivito/tasks_controller.rb

@@ -0,0 +1,11 @@
+module Scrivito
+
+  class TasksController < WebserviceController
+
+    def show
+      render json: CmsRestApi.task_unaware_request(:get, "tasks/#{params[:id]}")
+    end
+
+  end
+
+end

data/app/controllers/scrivito/webservice_controller.rb

@@ -0,0 +1,36 @@
+module Scrivito
+
+class WebserviceController < ActionController::Base
+  rescue_from ClientError do |exception|
+    render json: {error: exception.message}, status: exception.http_code
+  end
+
+  before_filter :merge_correctly_parsed_json_params
+  before_filter :authorize
+
+  private
+
+  def authorize
+    unless allow_access?
+      render text: 'Forbidden', status: 403
+    end
+  end
+
+  # If +true+, allow access to ObjsController, else deny access.
+  # See {Scrivito::Configuration.editing_auth} for details.
+  # @return [Bool]
+  def allow_access?
+    Configuration.editing_auth_callback.call(request.env)
+  end
+
+  # Workaround for https://github.com/rails/rails/issues/8832
+  def merge_correctly_parsed_json_params
+    if request.format.json?
+      body = request.body.read
+      request.body.rewind
+      params.merge!(ActiveSupport::JSON.decode(body)) if body.present?
+    end
+  end
+end
+
+end

data/app/controllers/scrivito/workspaces_controller.rb

@@ -0,0 +1,41 @@
+module Scrivito
+
+  class WorkspacesController < WebserviceController
+    def index
+      render json: CmsRestApi.task_unaware_request(:get, 'workspaces')
+    end
+
+    def create
+      render json: CmsRestApi.task_unaware_request(:post, 'workspaces', {
+        workspace: workspace_params,
+      })
+    end
+
+    def update
+      render json: CmsRestApi.task_unaware_request(:put, "workspaces/#{params[:id]}", {
+        workspace: workspace_params,
+      })
+    end
+
+    def destroy
+      render json: CmsRestApi.task_unaware_request(:delete, "workspaces/#{params[:id]}")
+    end
+
+    def publish
+      render json: CmsRestApi.task_unaware_request(:put, "workspaces/#{params[:id]}/publish", {})
+    end
+
+    def rebase
+      render json: CmsRestApi.task_unaware_request(:put, "workspaces/#{params[:id]}/rebase", {})
+    end
+
+    private
+
+    def workspace_params
+      raise "Required parameter 'workspace' is missing." unless params[:workspace].present?
+      raise "Parameter 'workspace' is not a hash." unless params[:workspace].is_a?(Hash)
+      params[:workspace]
+    end
+  end
+
+end

data/app/helpers/cms_helper.rb

@@ -0,0 +1,7 @@
+# {CmsHelper} is a wrapper around {Scrivito::DefaultCmsHelper}.
+# It can be replaced in your application in order to add or
+# modify helpers.
+# @api public
+module CmsHelper
+  include Scrivito::DefaultCmsHelper
+end

data/app/helpers/cms_routing_helper.rb

@@ -0,0 +1,7 @@
+# {CmsRoutingHelper} is a wrapper around {Scrivito::DefaultCmsRoutingHelper}.
+# It can be replaced in your application in order to add or
+# modify helpers.
+# @api public
+module CmsRoutingHelper
+  include Scrivito::DefaultCmsRoutingHelper
+end

data/app/helpers/scrivito/cms_asset_helper.rb

@@ -0,0 +1,103 @@
+module Scrivito
+
+  # This module contains helpers that can be used to reference images and other assets stored in the CMS.
+  #
+  # @api public
+  module CmsAssetHelper
+
+    # Calculates an HTML image tag for an image stored in the CMS.
+    #
+    # @note There are two different signatures of this method: the first one generates an HTML image tag with no
+    #   inplace editing possible, the second one generated an HTML image tag for inplace editing.
+    #
+    # @overload cms_image_tag target, tag_options={}
+    #   @note If you do not specify an HTML +alt+ attribute, the helper method will use +target+'s +display_title+.
+    #   Calculates HTML image tag (no inplace editing possible).
+    #
+    #   @param [Obj, Link] target Target containing image stored in CMS.
+    #   @param [Hash] tag_options Additional HTML attributes for the tag.
+    #
+    #   @example
+    #     cms_image_tag @target
+    #     cms_image_tag @target, alt: 'Interesting picture', class: 'my_image'
+    #
+    # @overload cms_image_tag obj, linklist, tag_options={}, editing_options={}
+    #   @note If you do not specify an HTML +alt+ attribute, the helper method will use +display_title+ of the target object.
+    #   Calculates HTML image tag for inplace editing.
+    #
+    #   @param [Obj] obj Obj with an attribute of type +LinkList+.
+    #   @param [String, Symbol] linklist Name of +LinkList+ attribute, which contains the image.
+    #   @param [Hash] tag_options Additional HTML attributes for the tag.
+    #
+    #   @param [Hash] editing_options Additional options for inplace editing.
+    #   @option editing_options [String] :placeholder ('/assets/scrivito/image_placeholder.png') URL or path to image to be displayed if target is missing.
+    #
+    #   @example
+    #     cms_image_tag @obj, :my_linklist
+    #     cms_image_tag @obj, :my_linklist, alt: 'Interesting picture', class: 'my_image'
+    #     cms_image_tag @obj, :my_linklist, {}, placeholder: image_path('my_placeholder.png')
+    #     cms_image_tag @obj, :my_linklist, {class: 'my_image'}, placeholder: 'http://placehold.it/350x150'
+    #
+    # @return [String] HTML image tag
+    # @api public
+    def cms_image_tag(*args)
+      if args.second.nil? || args.second.is_a?(Hash)
+        # Backwards compatibility.
+        target = args.first
+
+        tag_options = args.second || {}
+        tag_options.symbolize_keys!
+        tag_options[:src] = cms_path(target)
+        tag_options[:alt] ||= display_title(target)
+
+        tag('img', tag_options)
+      else
+        obj             = args.first
+        field_name      = args.second
+        tag_options     = args.third || {}
+        editing_options = args.fourth || {}
+
+        cms_tag('img', obj, field_name, cms_image_tag_options(obj, field_name,
+            tag_options.symbolize_keys, editing_options.symbolize_keys))
+      end
+
+    end
+
+    private
+
+    def cms_image_tag_options(obj, field_name, tag_options, editing_options)
+      tag_options.reverse_merge(src: cms_image_tag_src(obj, field_name, editing_options),
+          alt: cms_image_tag_alt(obj, field_name))
+    end
+
+    def cms_image_tag_src(obj, field_name, editing_options)
+      cms_image_tag_path(obj, field_name) || editing_options[:placeholder] ||
+          image_path('scrivito/image_placeholder.png')
+    end
+
+    def cms_image_tag_alt(obj, field_name)
+      display_title(obj[field_name])
+    end
+
+    def cms_image_tag_path(obj, field_name)
+      field_type = obj.type_of_attribute(field_name)
+      field_value = obj[field_name]
+
+      case field_type
+      when 'reference' then field_value && cms_path(field_value)
+      when 'linklist'
+        path = cms_path(field_value)
+        path == DefaultCmsRoutingHelper::LINK_TO_EMPTY_LINKLIST ? nil : path
+      end
+    end
+
+    def display_title(target)
+      if target.respond_to?(:display_title)
+        return target.display_title
+      elsif target.respond_to?(:first) && target.first.respond_to?(:display_title)
+        return target.first.display_title
+      end
+    end
+
+  end
+end