scrivito_sdk 0.65.2 → 0.66.0.rc1

data/lib/scrivito/basic_widget.rb

@@ -21,13 +21,13 @@ class BasicWidget
   # to ensure that only a special type of widget can be added to a specific
   # container. An example for this is a +TabGroupWidget+ that should
   # contain widgets of the +TabWidget+ type only, and, vice versa, a +TabWidget+
-  # should only be contained in a +TabGroupWidget+. A value of +nil+ means that
+  # should only be contained in a +TabGroupWidget+. A value of +NilClass+ means that
   # no additional restrictions are applied.
   #
   # This method only further restricts the list of valid classes defined
   # by means of {AttributeContent#valid_widget_classes_for}.
   #
-  # @return [Array<String, Symbol, Class>, nil]
+  # @return [NilClass, Array<Class>]
   #
   # @example
   #   class TabGroupWidget < Widget
@@ -46,8 +46,9 @@ class BasicWidget
   end
 
   def self.valid_inside_container?(container_class)
-    valid_container_classes.nil? ||
-      valid_container_classes.map(&:to_s).include?(container_class.name)
+    computed_classes = assert_classes(valid_container_classes, '.valid_container_classes')
+
+    computed_classes.nil? || computed_classes.include?(container_class)
   end
 
   attr_accessor :container, :container_attribute_name
@@ -202,7 +203,6 @@ class BasicWidget
   #   Please use {Scrivito::BasicObj#revert Obj#revert} to restore them.
   #
   # @raise [ScrivitoError] If the current workspace is +published+.
-  # @raise [ScrivitoError] If the current workspace is the +rtc+ workspace.
   # @raise [ScrivitoError] If the +Widget+ is +new+.
   # @raise [ScrivitoError] If the +Widget+ is +deleted+.
   #

data/lib/scrivito/binary.rb

@@ -4,11 +4,13 @@ module Scrivito
 # The Binary class represents the data stored in a binary attribute of an Obj
 # or Widget
 class Binary
-  attr_reader :id
+  attr_reader :id, :transformation_definition
 
-  def initialize(id, public_content)
+  def initialize(id, is_public, transformation_definition = nil, original = nil)
     @id = id
-    @public_content = public_content
+    @is_public = !!is_public
+    @transformation_definition = transformation_definition
+    @original = original
   end
 
   # @api public
@@ -17,21 +19,35 @@ class Binary
   # been published yet.
   # @return [Boolean]
   def private?
-    !public_content?
+    !@is_public
+  end
+
+  def public?
+    @is_public
   end
 
   # @api public
-  # The URL where this binary data is accessible and can be downloaded using an
-  # HTTP GET request. Note that urls for private content will have an
-  # expiration time in order to protect them.
-  # Therefore the url returned here should be accessed immediately after it has been returned (i.e. within a couple of minutes).
-  # When accessed after they have expired, an error will occur.
-  # The urls should not be used for long-term-storage (i.e. they are no longer accessible hours or days after they have been generated).
-  # @return [String] the URL under which this content is available
+  # The URL for accessing the binary data and downloading it using an HTTP GET request.
+  #
+  # @note URLs for private content have an expiration time in order to protect them.
+  #   Therefore, the URL should be accessed immediately after it has been returned
+  #   (i.e. within a couple of minutes). Accessing it after expiration causes an error.
+  #
+  # The URLs should not be used for long-term storage since they are no longer
+  # accessible hours or days after they have been generated.
+  # @return [String] the URL at which this content is available.
   def url
     find_url('get')
   end
 
+  def url_from_cache
+    blob_data = CmsBackend.instance
+      .find_blob_data_from_cache(id, access_type, 'get', transformation_definition)
+    if blob_data
+      blob_data['url']
+    end
+  end
+
   # @api public
   # the filename of this binary data, for example "my_image.jpg"
   # @return [String] the filename of binary
@@ -53,6 +69,121 @@ class Binary
     headers[:content_length].to_i
   end
 
+  #
+  # Returns a transformed {Scrivito::Binary}.
+  #
+  # @api beta
+  #
+  # Calling this method will not change the binary, but instead return a copy of it,
+  # transformed using the +definition+.
+  #
+  # If the original binary has already been transformed, then the returned binary will be a
+  # combination of the transformations. Thus the transformations can be chained (see examples).
+  #
+  # The transformed data is calculated "lazily", so calling {Scrivito::Binary#transform} will not
+  # trigger any calculation. The calculation will be triggered only if data is accessed, for example
+  # via {Scrivito::Binary#url}.
+  #
+  # @param [Hash] definition transformation definition
+  #
+  # @option definition [Fixnum,String] :width The width in pixels of the output image. Must be a
+  #   positive integer.
+  #
+  #   If only this dimension is specified, the other dimension will be calculated automatically to
+  #   preserve the aspect ratio of the input image.
+  #
+  #   If the +fit+ parameter is set to +:clip+, then the actual output one of width and height may
+  #   be equal to or less than the dimensions you specify to prevent distortion.
+  #
+  #   If neither +width+ nor +height+ is given, the width and height of the input image
+  #   will be used.
+  #
+  #   The maximum output image size width + height = 4096 pixels. The given width and height may be
+  #   adjusted to accomodate this limit. The output image will never be larger than the source
+  #   image, i.e. the given width and height may be adjusted to keep the output image from exceeding
+  #   the dimensions of the input image.
+  #
+  #   When the given width and height are adjusted, the aspect ratio is preserved.
+  #
+  # @option definition [Fixnum,String] :height The height in pixels of the output image. Must be a
+  #   positive integer.
+  #
+  #   If only this dimension is specified, the other dimension will be calculated automatically to
+  #   preserve the aspect ratio of the input image.
+  #
+  #   If the +fit+ parameter is set to +:clip+, then the actual output one of width and height may
+  #   be equal to or less than the dimensions you specify to prevent distortion.
+  #
+  #   If neither +width+ nor +height+ is given, the width and height of the input image
+  #   will be used.
+  #
+  #   The maximum output image size width + height = 4096 pixels. The given width and height may be
+  #   adjusted to accomodate this limit. The output image will never be larger than the source
+  #   image, i.e. the given width and height may be adjusted to keep the output image from exceeding
+  #   the dimensions of the input image.
+  #
+  #   When the given width and height are adjusted, the aspect ratio is preserved.
+  #
+  # @option definition [Symbol,String] :fit Controls how the tranformed image is fitted to the
+  #   given width and heigth. Valid values are +:clip+ and +:crop+. The default value is +:clip+.
+  #
+  #   If set to +:clip+ it resizes the image to fit within the width and height boundaries without
+  #   cropping or distorting the image. The resulting image is assured to match one of the
+  #   constraining dimensions, while the other dimension is altered to maintain the same aspect
+  #   ratio of the input image.
+  #
+  #   If set to +:crop+ it resizes the image to fill the given width and height and preserves the
+  #   aspect ration by cropping any excess image data. The resulting image will match both the given
+  #   width and height without distorting the image. The crop is done centered, i.e. the center of
+  #   the image is preserved.
+  #
+  # @option definition [Fixnum,String] :quality Controls the output quality of lossy file formats.
+  #   Applies when the format is +"jpg"+. Valid values are in the range from +0+ to +100+.
+  #   The default value is +75+.
+  #
+  # @return [Scrivito::Binary] transformed binary
+  #
+  # @example Crop image to fit into 50 x 50 pixel square
+  #   @obj.blob.transform(width: 50, height: 50, fit: :crop)
+  #
+  # @example Convert image to a low quality JPEG
+  #   @obj.blob.transform(quality: 25)
+  #
+  # @example Combine the both transformations
+  #   @obj.blob.transform(width: 50, height: 50, fit: :crop).transform(quality: 25)
+  #
+  def transform(definition)
+    self.class.new(id, public?, (transformation_definition || {}).merge(definition), original)
+  end
+
+  #
+  # Returns whether a binary is transformed.
+  # @api beta
+  #
+  def transformed?
+    !!transformation_definition
+  end
+
+  #
+  # Returns the transformation original of a binary.
+  #
+  # @api beta
+  #
+  # If a binary is a result of a transformation, then its original binary is returned.
+  # Otherwise +self+.
+  #
+  # @return [Scrivito::Binary] original binary
+  #
+  # @example
+  #   @obj.blob.id # => "abc123"
+  #   @obj.blob.original.id # => "abc123"
+  #   @obj.blob.transform(width: 50).original.id # => "abc123"
+  #   @obj.blob.transform(width: 50).transform(height: 50).original.id # => "abc123"
+  #
+  def original
+    @original || self
+  end
+
   private
 
   def public_content?
@@ -64,11 +195,21 @@ class Binary
   end
 
   def find_url(verb)
-    CmsBackend.instance.find_blob_data(@id, access_type, verb)['url']
+    CmsBackend.instance.find_blob_data(id, access_type, verb, transformation_definition)['url']
+  rescue ClientError => e
+    case e.backend_code
+    when 'binary.unprocessable.image.transform.source_too_large',
+          'binary.unprocessable.image.transform.source_type_invalid'
+      raise TransformationSourceError.new(e.message, e.backend_code)
+    when 'binary.unprocessable.image.transform.invalid_config'
+      raise TransformationDefinitionError.new(e.message, e.backend_code)
+    else
+      raise e
+    end
   end
 
   def access_type
-    public_content? ? 'public_access' : 'private_access'
+    public? ? 'public_access' : 'private_access'
   end
 end
 

data/lib/scrivito/binary_param_verifier.rb

@@ -0,0 +1,31 @@
+module Scrivito
+
+module BinaryParamVerifier
+  InvalidSignature = Class.new(StandardError)
+
+  class << self
+    def verify(params)
+      params = message_verifier.verify(params)
+      expires = DateAttribute.parse(params['expires'])
+      raise InvalidSignature if expires && expires < Time.zone.now
+      Binary.new(params['binary_id'], expires.nil?, params['transformation_definition'])
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      raise InvalidSignature
+    end
+
+    def generate(binary)
+      params = {binary_id: binary.id, transformation_definition: binary.transformation_definition}
+      params[:expires] = DateAttribute.serialize(Time.zone.now + 1.hour) if binary.private?
+      message_verifier.generate(params)
+    end
+
+    private
+
+    def message_verifier
+      ActiveSupport::MessageVerifier.new(
+        Rails.application.secrets.secret_key_base, serializer: JSON)
+    end
+  end
+end
+
+end

data/lib/scrivito/binary_rewrite.rb

@@ -0,0 +1,35 @@
+module Scrivito
+  #
+  # This module lets you change the URL of a binary CMS object for the purpose of
+  # fetching the binary data from a different location (e.g. via a proxy or from a mirror).
+  #
+  #
+  # @api public
+  #
+  module BinaryRewrite
+    def self.call(request, url)
+      change_url_callback = request.env["SCRIVITO_BINARY_URL_CALLBACK"]
+      url = change_url_callback.call(url) if change_url_callback
+      url
+    end
+    #
+    # You can, for example, have the URLs of images, etc., point to your desired
+    # domain instead of to the CDN Scrivito uses.
+    #
+    # @api public
+    #
+    # @param request [ActionDispatch::Request]
+    # @param block [Proc] block change default CDN url of current binary obj
+    #
+    # @example
+    #   Scrivito::BinaryRewrite.enable_for(request) do |binary_url|
+    #     binary_url.sub(
+    #       "https://scrivito-public-cdn.s3-eu-west-1.amazonaws.com/",
+    #       "https://my.reverse.proxy.com/")
+    #   end
+    #
+    def self.enable_for(request, &block)
+      request.env["SCRIVITO_BINARY_URL_CALLBACK"] = block
+    end
+  end
+end

data/lib/scrivito/cache_middleware.rb

@@ -7,6 +7,7 @@ class CacheMiddleware
 
   def call(env)
     clear_caches
+    clear_runtime
 
     @app.call(env)
   end
@@ -14,6 +15,10 @@ class CacheMiddleware
 
   private
 
+  def clear_runtime
+    Scrivito::LogSubscriber.reset_runtime
+  end
+
   def clear_caches
     Workspace.cache.clear
     CmsBackend.instance.clear_cache

data/lib/scrivito/child_list_tag.rb

@@ -65,9 +65,9 @@ class ChildListTag < Struct.new(:tag_name, :obj, :field_name, :view)
     # @return [String] The rendered html tag
     #
     # @example Render a <div> tag containing the text "random content" and assigns the tag a css class called +very_important+.
-    #   <%= list.tag :div, class: "very_important" do %>
-    #     random content
-    #   <% end %>
+    #   list.tag(:div, class: "very_important") do
+    #     "random content"
+    #   end
     #
     def tag(tag_name, html_options = {}, &block)
       raise '"list.tag" can only be called once per iteration!' if @rendered

data/lib/scrivito/cms_backend.rb

@@ -90,30 +90,36 @@ module Scrivito
 
     def find_workspace_data_by_id(id)
       if die_content_service
-        from_csid  = CmsDataCache.read_workspace_csid(id)
+        begin
+          cached_workspace_state = CmsDataCache.read_workspace_state(id)
 
-        changes = CmsRestApi.get("/workspaces/#{id}/changes", from: from_csid)
+          cached_csid = cached_workspace_state.try(:first)
+          cached_workspace_data_tag = cached_workspace_state.try(:second)
 
-        objs = changes["objs"]
-        if objs.present?
-          if objs != "*"
-            last_state = Backend::ContentStateNode.find(from_csid)
+          changes = CmsRestApi.get("/workspaces/#{id}/changes", from: cached_csid)
 
-            successor_state = changes["to"]
-            current_state = last_state.create_successor(successor_state, objs)
-          end
+          update_obj_cache(id, cached_csid, changes)
 
-          # TODO what if workspace data is missing?
-          # have the backend team include a new key `current`
-          current_csid = changes["workspace"]["content_state_id"]
-          CmsDataCache.write_workspace_csid(id, current_csid)
-        end
+          workspace_data, workspace_data_tag = update_workspace_cache(
+              id, cached_workspace_data_tag, changes["workspace"])
 
-        # TODO what if workspace data is missing?
-        # implement workspace data caching
-        workspace_data = changes["workspace"]
+          current_csid = changes["current"]
+          current_workspace_state = [current_csid, workspace_data_tag]
+
+          if current_workspace_state != cached_workspace_state
+            CmsDataCache.write_workspace_state(id, current_workspace_state)
+          end
 
-        return WorkspaceData.new(workspace_data)
+          return WorkspaceData.new(workspace_data.merge(
+              "content_state_id" => current_csid))
+
+        rescue Scrivito::ClientError => client_error
+          if client_error.http_code == 404
+            return nil
+          else
+            raise
+          end
+        end
       end
 
       workspace_data_from_cache = WorkspaceDataFromService.find_from_cache(id)
@@ -168,17 +174,22 @@ module Scrivito
       end
     end
 
-    def find_blob_data(id, access, verb)
-      id = Addressable::URI.normalize_component(id, Addressable::URI::CharacterClasses::UNRESERVED)
-      if blob_data = fetch_blob_data_from_cache(id, access, verb)
+    def find_blob_data(id, access, verb, transformation_definition)
+      if blob_data = find_blob_data_from_cache(id, access, verb, transformation_definition)
         blob_data
       else
-        blob_datas = request_blob_datas_from_backend(id)
-        store_blob_datas_in_cache(id, blob_datas)
+        id = normalize_blob_id(id)
+        blob_datas = request_blob_datas_from_backend(id, transformation_definition)
+        store_blob_datas_in_cache(id, transformation_definition, blob_datas)
         blob_datas[access][verb]
       end
     end
 
+    def find_blob_data_from_cache(id, access, verb, transformation_definition)
+      cache_key = blob_data_cache_key(normalize_blob_id(id), access, verb, transformation_definition)
+      CmsDataCache.cache.read(cache_key)
+    end
+
     def find_blob_metadata(id, url)
       if blob_metadata = fetch_blob_metadata_from_cache(id)
         blob_metadata
@@ -190,14 +201,24 @@ module Scrivito
     end
 
     def search_objs(workspace, params)
+      cache_index = 'search'
+      cache_key = params.to_param
+
       if die_content_service
-        # TODO caching
-        return request_search_result_from_backend(workspace, params)
+        cache = Backend::ObjDataCache.view_for_revision(workspace.revision)
+
+        if hit = cache.read_index(cache_index, cache_key)
+          return hit
+        end
+
+        result = request_search_result_from_backend(workspace, params)
+
+        cache.write_index(cache_index, cache_key, result)
+
+        return result
       end
 
       content_state = workspace.revision.content_state
-      cache_index = 'search'
-      cache_key = params.to_param
 
       if result = fetch_search_result_from_cache(content_state, cache_index, cache_key)
         result
@@ -208,34 +229,39 @@ module Scrivito
       end
     end
 
-    def find_obj_class_data_by_name(revision, name)
-      find_all_obj_class_data(revision).find { |obj_class_data| obj_class_data.name == name }
-    end
+    private
 
-    def find_all_obj_class_data(revision)
-      content_state = revision.content_state
-      if obj_classes_data = fetch_obj_classes_data_from_cache(content_state)
-        obj_classes_data
+    def update_workspace_cache(id, cached_data_tag, changed_workspace)
+      if changed_workspace
+        workspace_data = changed_workspace
       else
-        request_obj_classes_data_from_backend(revision).tap do |obj_classes_data|
-          store_obj_classes_data_in_cache(content_state, obj_classes_data)
+        cached_workspace_data = CmsDataCache.read_data_from_tag(cached_data_tag)
+
+        if cached_workspace_data
+          workspace_data = cached_workspace_data
+          workspace_data_tag = cached_data_tag
+        else
+          workspace_data = CmsRestApi.get("/workspaces/#{id}")
         end
       end
-    end
 
-    private
+      workspace_data_tag ||= CmsDataCache.write_data_to_tag(workspace_data)
 
-    def fetch_obj_classes_data_from_cache(content_state)
-      ContentStateCaching.find_obj_classes_data(content_state) if caching?
+      [workspace_data, workspace_data_tag]
     end
 
-    def request_obj_classes_data_from_backend(revision)
-      response = CmsRestApi.get("revisions/#{revision.id}/obj_classes", include_inactive: true)
-      response['results'].map { |raw_data| ObjClassData.new(raw_data) }
-    end
+    def update_obj_cache(workspace_id, cached_csid, changes)
+      objs = changes["objs"]
+      if objs.present? && objs != "*"
+        last_state = Backend::ContentStateNode.find(cached_csid)
+        changes_index = Backend::ObjDataCache.changes_index_from(objs)
+        successor = last_state.create_successor(changes["to"], changes_index)
 
-    def store_obj_classes_data_in_cache(content_state, obj_classes_data)
-      ContentStateCaching.store_obj_classes_data(content_state, obj_classes_data) if caching?
+        cache = Backend::ObjDataCache.view_for_workspace(workspace_id, successor)
+        changes_index.each do |id, tag|
+          cache.write_obj_tag(id, tag)
+        end
+      end
     end
 
     def fetch_search_result_from_cache(content_state, cache_index, cache_key)
@@ -250,27 +276,33 @@ module Scrivito
       content_state.save_obj_data(cache_index, cache_key, result) if caching?
     end
 
-    def fetch_blob_data_from_cache(id, access, verb)
-      CmsDataCache.cache.read(blob_data_cache_key(id, access, verb))
-    end
-
-    def request_blob_datas_from_backend(id)
+    def request_blob_datas_from_backend(id, transformation_definition)
       @query_counter += 1
-      CmsRestApi.get("blobs/#{id}")
+      if transformation_definition
+        CmsRestApi.get("blobs/#{id}/transform", transformation: transformation_definition)
+      else
+        CmsRestApi.get("blobs/#{id}")
+      end
     end
 
-    def store_blob_datas_in_cache(id, blob_datas)
+    def store_blob_datas_in_cache(id, transformation_definition, blob_datas)
       %w[public_access private_access].each do |access|
         %w[get head].each do |verb|
           blob_data = blob_datas[access][verb]
-          CmsDataCache.cache.write(blob_data_cache_key(id, access, verb),
-            blob_data, blob_data['maxage'])
+          cache_key = blob_data_cache_key(id, access, verb, transformation_definition)
+          CmsDataCache.cache.write(cache_key, blob_data, blob_data['maxage'])
         end
       end
     end
 
-    def blob_data_cache_key(id, access, verb)
-      "blob_data/#{id}/#{access}/#{verb}"
+    def blob_data_cache_key(id, access, verb, transformation_definition)
+      cache_key = "blob_data/#{id}/#{access}/#{verb}"
+      cache_key << "/#{transformation_definition.to_query}" if transformation_definition
+      cache_key
+    end
+
+    def normalize_blob_id(id)
+      Addressable::URI.normalize_component(id, Addressable::URI::CharacterClasses::UNRESERVED)
     end
 
     def fetch_blob_metadata_from_cache(id)