scrivito_sdk 1.0.0 → 1.1.0.rc1

data/lib/scrivito/cms_backend.rb

@@ -1,51 +1,4 @@
-require 'addressable/uri'
-
 module Scrivito
-
-  class ContentServiceObjQueries
-    def initialize(queries)
-      @queries = queries
-      @open_queries = queries.dup
-      @results = {}
-    end
-
-    def open_queries
-      @open_queries[0..99]
-    end
-
-    def handle_response(response)
-      objs = {}
-      response["objs"].each do |obj|
-        objs[obj["_id"].first] = obj
-      end
-
-      queries_to_delete = []
-      response["results"].each_with_index do |response, i|
-        query = @open_queries[i]
-        if response["continuation_handle"]
-          query[:continuation_handle] = response["continuation_handle"]
-        else
-          queries_to_delete << i
-        end
-        result = (@results[query.__id__] ||= [])
-        response["refs"].each do |obj_ref|
-          id = obj_ref["id"]
-          # TODO fetch missing ObjData from Service
-          result << (objs[id] or raise "Data for Obj with id #{id} missing!")
-        end
-      end
-      queries_to_delete.reverse_each {|i| @open_queries.delete_at(i) }
-    end
-
-    def results
-      @queries.map {|query| @results[query.__id__] || [] }
-    end
-
-    def finished?
-      open_queries.empty?
-    end
-  end
-
   class CmsBackend
     VALID_INDEX_NAMES = %w[id path ppath permalink].freeze
 
@@ -55,12 +8,9 @@ module Scrivito
       end
     end
 
-    attr_accessor :die_content_service
-
     def initialize
       @query_counter = 0
       @caching = true
-      @die_content_service = true
     end
 
     def begin_caching
@@ -68,12 +18,12 @@ module Scrivito
     end
 
     def end_caching
-      CmsDataCache.cache.clear
+      CmsDataCache.clear_request_cache
       @caching = false
     end
 
     def clear_cache
-      CmsDataCache.cache.clear
+      CmsDataCache.clear_request_cache
     end
 
     def caching?
@@ -90,125 +40,76 @@ module Scrivito
     end
 
     def find_workspace_data_from_cache(id)
-      if die_content_service
-        cached_workspace_state = CmsDataCache.read_workspace_state(id)
-        cached_data_tag = cached_workspace_state.try(:second)
-        cached_content_state_id = cached_workspace_state.try(:first)
-
-        if cached_data_tag && cached_content_state_id
-          if raw_workspace_data = fetch_cached_data_by_tag(cached_data_tag)
-            build_workspace_data(raw_workspace_data, cached_content_state_id)
-          end
+      cached_workspace_state = CmsDataCache.read_workspace_state(id)
+      cached_data_tag = cached_workspace_state.try(:second)
+      cached_content_state_id = cached_workspace_state.try(:first)
+
+      if cached_data_tag && cached_content_state_id
+        if raw_workspace_data = fetch_cached_data_by_tag(cached_data_tag)
+          build_workspace_data(raw_workspace_data, cached_content_state_id)
         end
-      else
-        WorkspaceDataFromService.find_from_cache(id)
       end
     end
 
     def find_workspace_data_by_id(id, timeout=nil)
       options = timeout ? {timeout: timeout} : {}
 
-      if die_content_service
-        begin
-          cached_workspace_state = CmsDataCache.read_workspace_state(id)
+      cached_workspace_state = CmsDataCache.read_workspace_state(id)
 
-          cached_csid = cached_workspace_state.try(:first)
-          cached_workspace_data_tag = cached_workspace_state.try(:second)
+      cached_csid = cached_workspace_state.try(:first)
+      cached_workspace_data_tag = cached_workspace_state.try(:second)
 
-          changes = CmsRestApi.get("/workspaces/#{id}/changes", {from: cached_csid}, options)
+      changes = CmsRestApi.get("/workspaces/#{id}/changes", {from: cached_csid}, options)
 
-          update_obj_cache(id, cached_csid, changes)
+      update_obj_cache(id, cached_csid, changes)
 
-          raw_workspace_data, workspace_data_tag = update_workspace_cache(
-              id, cached_workspace_data_tag, changes["workspace"], options)
-
-          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
+      raw_workspace_data, workspace_data_tag = update_workspace_cache(
+          id, cached_workspace_data_tag, changes["workspace"], options)
 
-          return build_workspace_data(raw_workspace_data, current_csid)
+      current_csid = changes["current"]
+      current_workspace_state = [current_csid, workspace_data_tag]
 
-        rescue Scrivito::ClientError => client_error
-          if client_error.http_code == 404
-            return nil
-          else
-            raise
-          end
-        end
+      if current_workspace_state != cached_workspace_state
+        CmsDataCache.write_workspace_state(id, current_workspace_state)
       end
 
-      workspace_data_from_cache = find_workspace_data_from_cache(id)
-      from_content_state_id = workspace_data_from_cache.try(:content_state_id)
-
-      request_params = {:workspace_id => id}
-      request_params[:content_state_id] = from_content_state_id if from_content_state_id
-
-      raw_data = ContentService.query('workspaces/query', request_params, options)
-
-      if raw_workspace_data = raw_data['workspace']
-        workspace_data = WorkspaceDataFromService.new(raw_workspace_data)
-        if from_content_state_id != workspace_data.content_state_id
-          workspace_data.store_in_cache_and_create_content_state
-        end
-        workspace_data
+      build_workspace_data(raw_workspace_data, current_csid)
+    rescue Scrivito::ClientError => client_error
+      if client_error.http_code == 404
+        nil
+      else
+        raise
       end
     end
 
     def find_obj_data_by(revision, index, keys)
       index = index.to_s
 
-      if die_content_service
-        obj_datas =
-          if index == "id"
-            obj_datas = Backend::ObjLoad.load(revision, keys)
-            obj_datas.map { |obj_data| obj_data ? [obj_data] : [] }
-          else
-            index_implementation = Backend::Index.by_name(index)
-            Backend::ObjQuery.query(revision, index_implementation, keys)
-          end
-
-        return obj_datas
-      end
-
-      assert_valid_index_name(index)
-      raw_data = find_raw_data_from_cache_or_database_by(revision, index, keys)
-
-      raw_data.map do |raw_result|
-        raw_result.each_with_object([]) do |raw_data, result|
-          result << ObjDataFromService.new(raw_data)
-        end
+      if index == "id"
+        obj_datas = Backend::ObjLoad.load(revision, keys)
+        obj_datas.map { |obj_data| obj_data ? [obj_data] : [] }
+      else
+        index_implementation = Backend::Index.by_name(index)
+        Backend::ObjQuery.query(revision, index_implementation, keys)
       end
     end
 
-    def find_blob_data(id, access, verb, transformation_definition)
-      if blob_data = find_blob_data_from_cache(id, access, verb, transformation_definition)
+    def find_blob_data(id, access, verb, options = {})
+      if blob_data = find_blob_data_from_cache(id, access, verb, options)
         blob_data
       else
         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 = request_blob_datas_from_backend(id, options)
+        store_blob_datas_in_cache(id, options, 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)
+    def find_blob_data_from_cache(id, access, verb, options)
+      cache_key = blob_data_cache_key(normalize_blob_id(id), access, verb, options)
       CmsDataCache.cache.read(cache_key)
     end
 
-    def find_blob_metadata(id, url)
-      if blob_metadata = fetch_blob_metadata_from_cache(id)
-        blob_metadata
-      else
-        blob_metadata = request_blob_metadata_from_s3(url)
-        store_blob_metadata_in_cache(id, blob_metadata)
-        blob_metadata
-      end
-    end
-
     def find_binary_meta_data(blob_id)
       blob_id = normalize_blob_id(blob_id)
       cache_key = "binary_meta_data/#{blob_id}"
@@ -224,30 +125,16 @@ module Scrivito
     def search_objs(workspace, params)
       cache_index = 'search'
       cache_key = params.to_param
+      cache = Backend::ObjDataCache.view_for_revision(workspace.revision)
 
-      if die_content_service
-        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_not_updatable(cache_index, cache_key, result)
-
-        return result
+      if hit = cache.read_index(cache_index, cache_key)
+        return hit
       end
 
-      content_state = workspace.revision.content_state
-
-      if result = fetch_search_result_from_cache(content_state, cache_index, cache_key)
-        result
-      else
-        request_search_result_from_backend(workspace, params).tap do |result|
-          store_search_result_in_cache(content_state, cache_index, cache_key, result)
-        end
-      end
+      result = request_search_result_from_backend(workspace, params)
+      persistent = !result.delete('tentative')
+      cache.write_index_not_updatable(cache_index, cache_key, result, persistent: persistent)
+      result
     end
 
     def create_obj(workspace_id, attributes)
@@ -303,164 +190,52 @@ module Scrivito
       end
     end
 
-    def fetch_search_result_from_cache(content_state, cache_index, cache_key)
-      content_state.find_obj_data(cache_index, cache_key) if caching?
-    end
-
     def request_search_result_from_backend(workspace, params)
+      params = params.merge(consistent_with: workspace.content_state_id)
       CmsRestApi.get("workspaces/#{workspace.id}/objs/search", params)
     end
 
-    def store_search_result_in_cache(content_state, cache_index, cache_key, result)
-      content_state.save_obj_data(cache_index, cache_key, result) if caching?
-    end
-
-    def request_blob_datas_from_backend(id, transformation_definition)
+    def request_blob_datas_from_backend(id, options)
       @query_counter += 1
-      if transformation_definition
+      case
+      when transformation_definition = options[:transformation_definition]
         CmsRestApi.get("blobs/#{id}/transform", transformation: transformation_definition)
+      when options[:no_cache]
+        CmsRestApi.get("blobs/#{id}/no_cache")
       else
         CmsRestApi.get("blobs/#{id}")
       end
     end
 
-    def store_blob_datas_in_cache(id, transformation_definition, blob_datas)
+    def store_blob_datas_in_cache(id, options, blob_datas)
       %w[public_access private_access].each do |access|
         %w[get head].each do |verb|
-          blob_data = blob_datas[access][verb]
-          cache_key = blob_data_cache_key(id, access, verb, transformation_definition)
-          CmsDataCache.cache.write(cache_key, blob_data, blob_data['maxage'])
+          if access_blob_data = blob_datas[access]
+            if blob_data = access_blob_data[verb]
+              cache_key = blob_data_cache_key(id, access, verb, options)
+              CmsDataCache.cache.write(cache_key, blob_data, expires_in: blob_data['maxage'])
+            end
+          end
         end
       end
     end
 
-    def blob_data_cache_key(id, access, verb, transformation_definition)
+    def blob_data_cache_key(id, access, verb, options)
       cache_key = "blob_data/#{id}/#{access}/#{verb}"
-      cache_key << "/#{transformation_definition.to_query}" if transformation_definition
-      cache_key
-    end
-
-    def normalize_blob_id(id)
-      CmsRestApi.normalize_path_component(id)
-    end
 
-    def fetch_blob_metadata_from_cache(id)
-      CmsDataCache.cache.read(blob_metadata_cache_key(id))
-    end
-
-    def request_blob_metadata_from_s3(url)
-      uri = URI.parse(url)
-      retried = false
-      begin
-        response = ConnectionManager.request(uri, Net::HTTP::Head.new(uri))
-        @query_counter += 1
-      rescue NetworkError
-        raise if retried
-        retried = true
-        retry
+      if transformation_definition = options[:transformation_definition]
+        cache_key << "/#{transformation_definition.to_query}"
       end
 
-      raise ScrivitoError, "S3 responded with #{response.code}" unless response.code == '200'
-
-      {
-        content_length: response['content-length'],
-        content_type:   response['content-type'],
-        cache_control:  response['cache-control'],
-      }
-    end
-
-    def store_blob_metadata_in_cache(id, blob_metadata)
-      max_age = blob_metadata.delete(:cache_control) =~ /max-age=(.*),/ && $1
-      max_age = max_age.to_i if max_age
-      CmsDataCache.cache.write(blob_metadata_cache_key(id), blob_metadata, max_age)
-    end
-
-    def blob_metadata_cache_key(id)
-      "blob_metadata/#{id}"
-    end
-
-    def find_raw_data_from_cache_or_database_by(revision, index, keys)
-      keys_from_database = []
-      # load results from cache
-      results_from_cache = keys.map do |key|
-        find_raw_data_from_cache_by(revision, index, key).tap do |objs|
-          keys_from_database << key unless objs
-        end
+      if options[:no_cache]
+        cache_key << '/no_cache'
       end
 
-      # load cache misses from database and store them in cache
-      results_from_database =
-          find_raw_data_from_database_by(revision, index, keys_from_database)
-      keys_from_database.each_with_index do |key, key_number|
-        store_raw_data_list_in_cache(revision, index, key, results_from_database[key_number])
-      end
-
-      # combine the results
-      results_from_cache.map do |objs_from_cache|
-        objs_from_cache || results_from_database.shift
-      end
-    end
-
-    def find_raw_data_from_cache_by(revision, index, key)
-      ContentStateCaching.find_obj_data(revision.content_state, index, key) if caching?
-    end
-
-    def find_raw_data_from_database_by(revision, index, keys)
-      return [] if keys.blank?
-      instrumenter = ActiveSupport::Notifications.instrumenter
-      instrumenter.instrument(
-        "cms_load.scrivito", :name => "Obj Load", :index => index, :keys => keys
-      ) do
-        @query_counter += 1
-        queries = ContentServiceObjQueries.new(keys.map {|key| {:type => index, :param => key} })
-        queries.handle_response(request_content_service(queries, revision)) until queries.finished?
-        queries.results
-      end
-    end
-
-    def request_content_service(queries, revision)
-      ContentService.query('objs/query', content_service_request_params(queries, revision))
-    end
-
-    def content_service_request_params(queries, revision)
-      params = {
-        queries: queries.open_queries,
-        revision_id: revision.id,
-        include_deleted: true
-      }
-
-      # A base revision doesn't have a directly corresponding workspace. Instead it uses its
-      # derivative workspace as fallback to access the contents. Thus fallback workspace of a base
-      # revision may not be used for backend requests.
-      params[:workspace_id] = revision.workspace.id unless revision.base?
-
-      params
-    end
-
-    UNIQUE_INDICES = [:id, :path, :permalink].freeze
-
-    def store_raw_data_list_in_cache(revision, index, key, raw_data_list)
-      raw_data_list.each do |values|
-        UNIQUE_INDICES.each do |unique_index|
-          unique_index_values = values["_#{unique_index}"]
-          if unique_index_values.present?
-            store_item_in_cache(revision, unique_index, unique_index_values.first, [values])
-          end
-        end
-      end
-      unless UNIQUE_INDICES.include?(index)
-        store_item_in_cache(revision, index, key, raw_data_list)
-      end
-    end
-
-    def store_item_in_cache(revision, index, key, item)
-      ContentStateCaching.store_obj_data(revision.content_state, index, key, item)
+      cache_key
     end
 
-    def assert_valid_index_name(index)
-      raise ArgumentError, "invalid index name '#{index}'" unless VALID_INDEX_NAMES.include?(index)
+    def normalize_blob_id(id)
+      CmsRestApi.normalize_path_component(id)
     end
-
   end
-
 end

data/lib/scrivito/cms_data_cache.rb

@@ -21,19 +21,17 @@ module CmsDataCache
       @first_level_cache ||= Cache::FileStore.new(path: @cache_path, next_store: second_level_cache)
     end
 
+    def clear_request_cache
+      cache.clear
+    end
+
     def second_level_cache=(cache_store)
       clear_cache_chain
       @second_level_cache = cache_store
     end
 
     SCHEMA = {
-      # CONTENT SERVICE
-      content_state:      'content/#{content_state_id}',
-      obj_data:           'content/#{content_state_id}/obj/#{index}/#{key}',
-      workspace_data:     'workspace/#{workspace_id}',
-
-      # REST API
-      obj_data_rest:      'obj/#{cache_id}/#{index}/#{key}',
+      obj_data:           'obj/#{cache_id}/#{index}/#{key}',
       content_state_node: 'csn/#{content_state_id}',
       workspace_state:    'wrkstt/#{workspace_id}',
       tag_data:           'tagd/#{tag}'
@@ -51,11 +49,11 @@ module CmsDataCache
       END
 
       class_eval(<<-END, __FILE__, __LINE__ + 1)
-        def write_#{name}(#{params_code}, data)
+        def write_#{name}(#{params_code}, data, **options)
           if data == nil
             raise InternalError, "tried to write nil into #{schema}"
           end
-          cache.write("#{schema}", data)
+          cache.write("#{schema}", data, **options)
         end
       END
 

data/lib/scrivito/cms_dispatch_controller.rb

@@ -8,17 +8,8 @@ module Scrivito
     def process(action)
       CmsEnv.new(env).load
 
-      if !obj_not_found? && action == 'legacy'
-        if Scrivito::Configuration.legacy_routing
-          action = 'index'
-        else
-          redirect_to scrivito_path(loaded_obj), status: :moved_permanently
-          return self.response
-        end
-      end
-
       if obj_not_found? && editing_context.workspace_changed?
-        redirect_to :scrivito_root
+        redirect_to "/"
         return self.response
       end
 

data/lib/scrivito/cms_field_tag.rb

@@ -33,7 +33,8 @@ class CmsFieldTag < Struct.new(:view, :tag_name, :obj_or_widget, :editing_option
       end
       view.safe_join(rendered_widgets)
     else
-      block_given? ? view.capture { yield } : view.scrivito_value(default_content)
+      attribute_renderer = AttributeValueRenderer.new(view)
+      block_given? ? view.capture { yield } : attribute_renderer.render(default_content, field_type)
     end
   end
 

data/lib/scrivito/cms_rest_api.rb

@@ -1,3 +1,5 @@
+require 'addressable/uri'
+
 module Scrivito
 
   # Provides a simple wrapper for the CMS Rest API.

data/lib/scrivito/cms_routing.rb

@@ -1,13 +1,9 @@
 module Scrivito
 
-class CmsRouting < Struct.new(:request, :main_app, :scrivito_engine, :image_options)
+class CmsRouting < Struct.new(:request, :context, :scrivito_engine, :image_options)
   LINK_TO_EMPTY_LINKLIST = "#__empty_linklist"
   LINK_TO_EMPTY_BLOB = "#__empty_blob"
 
-  def self.match_protocol(url, request)
-    request.ssl? && !url.starts_with?('https') ? url.gsub(/^http/, 'https') : url
-  end
-
   def path_or_url(target, path_or_url, options = {})
     if needs_editing_context?(target)
       path_or_url_needs_editing_context(target, path_or_url, options)
@@ -26,13 +22,14 @@ class CmsRouting < Struct.new(:request, :main_app, :scrivito_engine, :image_opti
             begin
               uri = URI.parse($2)
               options.merge!(extract_query(uri))
-              options['anchor'] = uri.fragment
+              options[:anchor] = uri.fragment
             rescue
             end
           end
 
           if editing_context.display_mode == 'editing'
-            id_path_or_url_for_objs(obj, :path, options)
+            options[:id] = obj.id
+            scrivito_engine.base_id_path(options)
           else
             path_or_url(obj, :path, options)
           end
@@ -70,41 +67,48 @@ class CmsRouting < Struct.new(:request, :main_app, :scrivito_engine, :image_opti
   end
 
   def path_or_url_for_links(link, path_or_url, options)
-    url = basic_url_or_path_for_link(link, path_or_url,
-      Rack::Utils.parse_nested_query(link.query).merge(options))
+    parsed_options = Rack::Utils.parse_nested_query(link.query)
+    combined_options = parsed_options.symbolize_keys.merge(options)
+
+    url = basic_url_or_path_for_link(link, path_or_url, combined_options)
     url = url + "##{link.fragment}" if link.fragment.present?
     url
   end
 
   def path_or_url_for_objs(obj, path_or_url, options)
     permalink = obj.permalink
-    if permalink
-      main_app
-        .public_send("scrivito_permalink_#{path_or_url}", options.merge(:permalink => permalink))
-    elsif homepage?(obj)
-      main_app.public_send("scrivito_root_#{path_or_url}", options)
+    if permalink && route_defined?(:permalink)
+      use_route(:permalink, path_or_url, options.merge(:permalink => permalink))
+    elsif homepage?(obj) && route_defined?(:homepage)
+      use_route(:homepage, path_or_url, options)
     elsif obj.binary?
       binary_obj_url(obj) || LINK_TO_EMPTY_BLOB
-    else
+    elsif route_defined?(:slug_id)
       slug = obj.slug.present? ? obj.slug.sub(/^\//, '') : nil
       id_path_or_url_for_objs(obj, path_or_url, options.merge(slug: slug))
+    else
+      raise ScrivitoError, "The required scrivito route 'slug_id' is not defined. "\
+        "Please add a 'slug_id' definition to your routes.rb. See the documentation"\
+        " of 'scrivito_route' for further details."
     end
   end
 
   def id_path_or_url_for_objs(obj, path_or_url, options)
-    method_name = if Scrivito::Configuration.legacy_routing
-      "cms_legacy_id_#{path_or_url}"
-    else
-      "cms_id_#{path_or_url}"
-    end
-
     options[:id] = obj.id
 
     # Options must have the key slug.
     # Otherwise Rails will use the slug from current request params.
     options[:slug] ||= nil
 
-    main_app.public_send(method_name, options)
+    use_route(:slug_id, path_or_url, options)
+  end
+
+  def route_defined?(name)
+    Route.defined?(context._routes, name)
+  end
+
+  def use_route(name, path_or_url, options)
+    Route.find(context._routes, name).generate(context, path_or_url, options)
   end
 
   def homepage?(obj)