scrivito_sdk 0.60.0 → 0.65.0.rc1

data/lib/scrivito/backend/obj_data_from_rest.rb

@@ -0,0 +1,64 @@
+module Scrivito
+module Backend
+
+class ObjDataFromRest < ObjData
+  def initialize(data)
+    @data = data
+  end
+
+  def raw_value_and_type_of(attribute_name)
+    return [value_of_widget_pool, nil] if attribute_name == '_widget_pool'
+
+    if attribute_data = @data[attribute_name]
+      if attribute_name.starts_with?('_')
+        [attribute_data, nil]
+      else
+        type = attribute_data[0]
+        [legacy_compatible(attribute_data[1], type), type]
+      end
+    else
+      [nil, nil]
+    end
+  end
+
+  def attribute_names_for_comparison
+    @data.keys
+  end
+
+  def to_h
+    @data
+  end
+
+  private
+
+  def legacy_compatible(value, type)
+    if type == "linklist"
+      value.map(&method(:legacy_link))
+    elsif type == "link"
+      legacy_link(value)
+    else
+      value
+    end
+  end
+
+  def legacy_link(link)
+    return link unless link["obj_id"]
+
+    transformed = link.dup
+    transformed["destination"] = transformed.delete("obj_id")
+
+    transformed
+  end
+
+  def value_of_widget_pool
+    if widget_pool = @data['_widget_pool']
+      # using Hash#merge to "map" to a new Hash
+      widget_pool.merge(widget_pool) do |id, raw_widget_data|
+        self.class.new(raw_widget_data)
+      end
+    end
+  end
+end
+
+end
+end

data/lib/scrivito/backend/obj_load.rb

@@ -0,0 +1,45 @@
+module Scrivito
+module Backend
+
+module ObjLoad
+class << self
+
+  def load(revision, ids)
+    cache = Backend::ObjDataCache.view_for_revision(revision)
+
+    missing_ids = []
+    results_from_cache = ids.map do |id|
+      result = cache.read_obj(id)
+
+      missing_ids << id unless result
+
+      result
+    end
+
+    overall_results =
+      if missing_ids.blank?
+        results_from_cache
+      else
+        results_from_backend = revision.obj_mget_request(missing_ids)
+
+        results_from_backend.each do |result|
+          if result
+            cache.write_obj(result["_id"], result)
+          end
+        end
+
+        results_from_cache.map do |result|
+          result || results_from_backend.shift
+        end
+      end
+
+    overall_results.map do |raw_data|
+      Backend::ObjDataFromRest.new(raw_data) if raw_data
+    end
+  end
+
+end
+end
+
+end
+end

data/lib/scrivito/backend/obj_query.rb

@@ -0,0 +1,63 @@
+module Scrivito
+module Backend
+
+module ObjQuery
+class << self
+
+  def query(revision, index, keys)
+    cache = Backend::ObjDataCache.view_for_revision(revision)
+
+    missing_keys = []
+    ids_from_cache = keys.map do |key|
+      result = cache.read_index(index.id, key)
+
+      missing_keys << key unless result
+
+      result
+    end
+
+    if missing_keys.blank?
+      return load_nested_ids(revision, ids_from_cache)
+    end
+
+    backend_ids = revision.obj_search_request(index.query(missing_keys))
+
+    all_obj_datas = load_nested_ids(revision, ids_from_cache + [backend_ids])
+
+    cache_obj_datas = all_obj_datas[0..-2]
+    backend_obj_datas = all_obj_datas.last
+
+    grouped_backend_results = index.group_by(missing_keys, backend_obj_datas)
+
+    grouped_backend_results.each_with_index do |result, i|
+      ids = result.map { |obj_data| obj_data.value_of("_id") }
+      cache.write_index(index.id, missing_keys[i], ids)
+    end
+
+    cache_obj_datas.map do |obj_datas|
+      obj_datas || grouped_backend_results.shift
+    end
+  end
+
+  private
+
+  # nested_ids is a list containing elements that are either lists of ids or nil
+  # returns a corresponding list
+  # containing elements that are either lists of obj_datas or nil
+  def load_nested_ids(revision, nested_ids)
+    all_ids = nested_ids.inject([]) do |list, ids|
+      ids ? list + ids : list
+    end
+
+    all_obj_datas = Backend::ObjLoad.load(revision, all_ids)
+
+    nested_ids.map do |ids|
+      all_obj_datas.shift(ids.length) if ids
+    end
+  end
+
+end
+end
+
+end
+end

data/lib/scrivito/backend/parent_path_index.rb

@@ -0,0 +1,21 @@
+module Scrivito
+module Backend
+
+module ParentPathIndex
+class << self
+
+  include Backend::Index
+
+  def id
+    "ppath"
+  end
+
+  def query(keys)
+    [{:field => "_parent_path", :operator => :equals, :value => keys}]
+  end
+
+end
+end
+
+end
+end

data/lib/scrivito/backend/path_index.rb

@@ -0,0 +1,27 @@
+module Scrivito
+module Backend
+
+module PathIndex
+class << self
+
+  include Backend::Index
+
+  def id
+    "path"
+  end
+
+  def query(keys)
+    [{:field => "_path", :operator => :equals, :value => keys}]
+  end
+
+  def group_by_multiple(paths, obj_datas)
+    paths.map do |path|
+      obj_datas.select { |obj_data| obj_data.value_of("_path") == path }
+    end
+  end
+
+end
+end
+
+end
+end

data/lib/scrivito/backend/permalink_index.rb

@@ -0,0 +1,17 @@
+module Scrivito
+module Backend
+  class PermalinkIndex
+    class << self
+      include Backend::Index
+
+      def id
+        "permalink"
+      end
+
+      def query(keys)
+        [{ field: '_permalink', operator: :equals, value: keys }]
+      end
+    end
+  end
+end
+end

data/lib/scrivito/basic_obj.rb

@@ -55,11 +55,20 @@ module Scrivito
     end
 
     #
-    # Create a new {Scrivito::BasicObj Obj} in the cms
+    # Create a new {Scrivito::BasicObj Obj} in the CMS.
     #
-    # This allows you to set the different attributes types of an obj by
-    # providing a hash with the attributes names as key and the values you want
-    # to set as values
+    # @api public
+    #
+    # This allows you to set the different attributes types of an obj by providing a hash with the
+    # attributes names as key and the values you want to set as values. It also considers the
+    # defaults set via {Scrivito::AttributeContent::ClassMethods#default_for Obj.default_for}.
+    #
+    # @param [Hash] attributes for the new obj
+    # @param [Hash] context in which the object creating should happen
+    # @option context [Scrivito::User] :scrivito_user current visitor
+    # @return [Obj] the newly created {Scrivito::BasicObj Obj}
+    #
+    # @see Scrivito::AttributeContent::ClassMethods#default_for
     #
     # @example Reference lists have to be provided as an Array of {Scrivito::BasicObj Objs}
     #   Obj.create(:reference_list => [other_obj])
@@ -107,14 +116,11 @@ module Scrivito
     #   # Clear a widget field
     #   obj.update(:widgets => [])
     #
-    # @api public
-    # @param [Hash] attributes
-    # @return [Obj] the newly created {Scrivito::BasicObj Obj}
-    #
-    def self.create(attributes = {})
+    def self.create(attributes = {}, context = {})
       if obj_class = extract_obj_class_from_attributes(attributes)
-        obj_class.create(attributes)
+        obj_class.create(attributes, context)
       else
+        attributes = build_attributes_with_defaults(attributes, context)
         attributes = prepare_attributes_for_instantiation(attributes)
         api_attributes, widget_properties = prepare_attributes_for_rest_api(attributes)
         json = Workspace.current.api_request(:post, '/objs', obj: api_attributes)
@@ -604,42 +610,59 @@ module Scrivito
       read_attribute('_last_changed')
     end
 
-    def new?(revision=Workspace.current.base_revision)
-      return false unless revision
+    def new?(revision=workspace.base_revision)
+      quick_modification(revision) == "new"
+    end
 
-      if read_attribute('_modification') != 'deleted'
-        cms_data_for_revision(revision).nil?
-      else
-        false
-      end
+    def deleted?(revision=workspace.base_revision)
+      quick_modification(revision) == "deleted"
     end
 
-    def deleted?(revision=Workspace.current.base_revision)
-      return false unless revision
+    def modification(revision=workspace.base_revision)
+      quick_modification = quick_modification(revision)
 
-      if read_attribute('_modification') == 'deleted'
-        cms_data_for_revision(revision).present?
+      if ObjData === quick_modification
+        if data_from_cms == quick_modification
+          Modification::UNMODIFIED
+        else
+          Modification::EDITED
+        end
+      else
+        quick_modification
       end
     end
 
-    def modification(revision=workspace.base_revision)
+    # similar to modification, but faster if you are only interested in
+    # "new" and "deleted".
+    # this method sometimes does not return a string, but an instance of
+    # ObjData instead. this indicates that the modification is either
+    # UNMODIFIED or EDITED. Which one it is can be determined by comparing
+    # the returned ObjData.
+    def quick_modification(revision)
       return Modification::UNMODIFIED unless revision
-      return read_attribute('_modification') if revision == workspace.base_revision
-
-      if deleted?(revision)
-        Modification::DELETED
-      elsif new?(revision)
-        Modification::NEW
-      else # Edited
-        obj_data_from_revision = cms_data_for_revision(revision)
-        if obj_data_from_revision.present?
-          if data_from_cms == obj_data_from_revision
-            Modification::UNMODIFIED
-          else
-            Modification::EDITED
-          end
+
+      modification_attr = read_attribute('_modification')
+
+      return modification_attr if revision == workspace.base_revision
+
+      data_for_comparison = cms_data_for_revision(revision)
+
+      if data_for_comparison.present?
+        if modification_attr == 'deleted'
+          # Obj exists in comparison revision, but not in current
+          Modification::DELETED
         else
+          # Obj exists in both revisions, leave the actual comparions
+          # up to the caller
+          data_for_comparison
+        end
+      else
+        if modification_attr == "deleted"
+          # Obj does not exist in either revision
           Modification::UNMODIFIED
+        else
+          # Obj exists in current, but not in comparision revision
+          Modification::NEW
         end
       end
     end
@@ -883,8 +906,13 @@ module Scrivito
     private
 
     def cms_data_for_revision(revision)
-      if revision
-        CmsBackend.instance.find_obj_data_by(revision, "id", [id]).first.first
+      return nil unless revision
+
+      result = CmsBackend.instance.find_obj_data_by(revision, "id", [id])
+      obj_data = result.first.first
+
+      if obj_data && obj_data.value_of("_modification") != "deleted"
+        obj_data
       end
     end
 
@@ -1006,7 +1034,7 @@ module Scrivito
             .generate_widget_pool_changes(widget_pool_attributes)
           serialized_attributes
         else
-          serializer = AttributeSerializer.new
+          serializer = AttributeSerializer.new(obj_attributes['_obj_class'] || name)
           serialized_attributes = serialize_obj_attributes(serializer, obj_attributes)
           serialized_attributes['_widget_pool'] =
             serialize_widget_pool_attributes(serializer, widget_pool_attributes)

data/lib/scrivito/basic_widget.rb

@@ -83,11 +83,27 @@ class BasicWidget
     @attribute_cache = {}
   end
 
-  def self.new(attributes = {})
+  #
+  # Creates a new {Scrivito::BasicWidget Widget}.
+  #
+  # @api public
+  #
+  # It also considers the defaults set via
+  # {Scrivito::AttributeContent::ClassMethods#default_for Widget.default_for}.
+  #
+  # @param [Hash] attributes for the new widget
+  # @param [Hash] context in which the object creating should happen
+  # @option context [Scrivito::User] :scrivito_user current visitor
+  # @return [Widget] the newly created {Scrivito::BasicWidget Widget}
+  #
+  # @see Scrivito::BasicWidget.new
+  # @see Scrivito::AttributeContent::ClassMethods#default_for
+  #
+  def self.new(attributes = {}, context = {})
     if obj_class = extract_obj_class_from_attributes(attributes)
-      obj_class.new(attributes)
+      obj_class.new(attributes, context)
     else
-      super
+      super(build_attributes_with_defaults(attributes, context))
     end
   end
 

data/lib/scrivito/cache_middleware.rb

@@ -6,11 +6,17 @@ class CacheMiddleware
   end
 
   def call(env)
-    CmsBackend.instance.begin_caching
+    clear_caches
+
     @app.call(env)
-  ensure
-    CmsBackend.instance.end_caching
+  end
+
+
+  private
+
+  def clear_caches
     Workspace.cache.clear
+    CmsBackend.instance.clear_cache
   end
 end