scrivito_sdk 0.12.0

data/lib/scrivito/content_service.rb

@@ -0,0 +1,118 @@
+require 'timeout'
+require 'net/http'
+
+module Scrivito
+class ContentService
+  class RateLimitExceeded < StandardError
+    def initialize(retry_after)
+      @retry_after = retry_after
+    end
+
+    attr_reader :retry_after
+  end
+
+  class MaxSleepTimeReached < StandardError
+  end
+
+  class Delay
+    def initialize
+      @sleep_count = 0
+      @total_sleep_time = 0
+    end
+
+    def next_sleep_time(min_sleep = 0)
+      sleep_time = [2 ** @sleep_count * 0.5, min_sleep.to_f].max
+      @total_sleep_time += sleep_time
+      raise MaxSleepTimeReached if @total_sleep_time > 40
+      @sleep_count += 1
+      sleep_time
+    end
+  end
+
+  class << self
+    @next_request_not_before = nil
+
+    def query(path, payload, options={})
+      timeout = options.fetch(:timeout, ConnectionManager::DEFAULT_TIMEOUT)
+      retry_until_timeout_on_rate_limit_exceeded do
+        request = build_request(path, payload)
+        if @next_request_not_before && @next_request_not_before > (now = Time.now)
+          sleep @next_request_not_before - now
+        end
+
+        response = nil
+        retry_once_on_network_error do
+          response = connection_manager.request(request, timeout)
+        end
+        handle_response(response)
+      end
+    end
+
+    # for tests only
+    def forget_retry_after
+      @next_request_not_before = nil
+    end
+
+    def connection_manager
+      ConnectionManager.instance
+    end
+
+    private
+
+    def retry_once_on_network_error
+      retried = false
+      begin
+        yield
+      rescue NetworkError => e
+        raise e if retried
+        retried = true
+        retry
+      end
+    end
+
+    def retry_until_timeout_on_rate_limit_exceeded
+      delay = Delay.new
+      begin
+        yield
+      rescue RateLimitExceeded => e
+        begin
+          sleep delay.next_sleep_time(e.retry_after)
+        rescue MaxSleepTimeReached
+          raise ::Scrivito::RateLimitExceeded.new('rate limit exceeded', 429)
+        end
+        retry
+      end
+    end
+
+    def build_request(path, payload)
+      url = "#{Configuration.endpoint_uri.path}/#{path}".squeeze('/')
+      request = Net::HTTP::Post.new(url, request_headers)
+      request.basic_auth('api_token', Configuration.api_key)
+      request.body = MultiJson.dump(payload)
+      request
+    end
+
+    def handle_response(response)
+      if response.code.first == '2'
+        retry_after = response["Retry-After"]
+        @next_request_not_before = retry_after ? Time.now + retry_after.to_f : nil
+        MultiJson.load(response.body)
+      elsif response.code == "429"
+        raise RateLimitExceeded.new(response["Retry-After"])
+      elsif response.code == '403'
+        raise AccessDenied.new(response.body)
+      else
+        raise NetworkError.new("Server responded with status code #{response.code}", response.code)
+      end
+    end
+
+    def request_headers
+      {
+        'Accept'       => 'application/json',
+        'Content-Type' => 'application/json',
+      }
+    end
+  end
+
+end
+end

data/lib/scrivito/content_state.rb

@@ -0,0 +1,109 @@
+module Scrivito
+
+# This class represents a single instance of a content state.
+# Basically a content state has three important characteristics: cache with obj datas,
+# changes representing changed objs and ways they has been changed and an ancestor content state.
+class ContentState < Struct.new(:content_state_id, :changes, :changes_index, :from_content_state_id)
+  class << self
+    private :new
+
+    # Creates a new content state with given changes and ancestor (optional).
+    def create(attributes)
+      new(attributes).tap do |content_state|
+        content_state.index_changes!
+        CmsCacheStorage.write_content_state(content_state.content_state_id, content_state.to_hash)
+      end
+    end
+
+    # Finds a previously saved content state.
+    # Returns nil if not found.
+    def find(content_state_id)
+      if content_state_data = CmsCacheStorage.read_content_state(content_state_id)
+        new(content_state_data)
+      end
+    end
+
+    # Fetches an existing workspace.
+    # If not found creates a new one and returns it.
+    def find_or_create(content_state_id)
+      find(content_state_id) || create(content_state_id: content_state_id)
+    end
+  end
+
+  def initialize(attributes)
+    super(*attributes.symbolize_keys.values_at(:content_state_id, :changes, :changes_index,
+        :from_content_state_id))
+  end
+
+  # Stores arbitrary data in cache.
+  # Cache key is build from given index and key.
+  def save_obj_data(index, key, data)
+    CmsCacheStorage.write_obj_data(content_state_id, index, key, data)
+  end
+
+  # Fetches previously stored arbitrary data from cache.
+  # Returns nil if nothing found.
+  # Cache key is build from given index and key.
+  def find_obj_data(index, key)
+    CmsCacheStorage.read_obj_data(content_state_id, index, key)
+  end
+
+  # Fetches and caches the ancestor.
+  # Returns nil if there is no ancestor.
+  def from_content_state
+    @from_content_state ||= self.class.find(from_content_state_id)
+  end
+
+  # Determines whether given data is still up-to-date for given index and key.
+  def has_changes_for?(index, key, data)
+    case index
+    when 'id'
+      id_index.include?(key)
+    when 'path'
+      path_index.include?(key) || data.first && id_index.include?(data.first['_id'].first)
+    when 'ppath'
+      ppath_index.include?(key) || data.find { |d| id_index.include?(d['_id'].first) }
+    end
+  end
+
+  # Computes for a given changes feed a set of access-efficient indexes.
+  def index_changes!
+    id_index, path_index, ppath_index = Set.new, Set.new, Set.new
+    if changes.present?
+      changes.each do |hash|
+        id_index.add(hash['id'])
+        if path = hash['modified_path']
+          path_index.add(path)
+          ppath_index.add(path.gsub(/\/[^\/]+$/, '').presence || '/') if path != '/'
+        end
+      end
+    end
+    self.changes = nil
+    self.changes_index = {'id' => id_index, 'path' => path_index, 'ppath' => ppath_index}
+  end
+
+  # Returns a hash representation of a content state for serialization purpose.
+  def to_hash
+    {
+      content_state_id: content_state_id,
+      changes_index: changes_index,
+      from_content_state_id: from_content_state_id
+    }
+  end
+
+  private
+
+  def id_index
+    @id_index ||= changes_index['id']
+  end
+
+  def path_index
+    @path_index ||= changes_index['path']
+  end
+
+  def ppath_index
+    @ppath_index ||= changes_index['ppath']
+  end
+end
+
+end

data/lib/scrivito/content_state_caching.rb

@@ -0,0 +1,47 @@
+module Scrivito
+
+# This module provides advances auto-invalidating caching mechanism for storing obj data.
+#
+# To keep it up-to-date its caches and changes should be updated periodically
+# It's changes should be updated every time a new workspace data has been fetched.
+# It's caches should be updated every time a new obj data has been fetched.
+module ContentStateCaching
+  class << self
+    # How deep should a content state chain be inspected. Default depth is 20.
+    attr_accessor :cache_lookup_depth
+
+    # At which lookup depth to copy a hit found in an ancestor content state
+    # to the current content state's cache. Default depth is 5.
+    attr_accessor :cache_replication_depth
+
+    # Updates caches with data from given workspace.
+    # Should be called every time a new OBJ data has been fetched.
+    def store_obj_data(content_state, index, key, data)
+      content_state.save_obj_data(index, key, data) if content_state
+    end
+
+    # Fetches up-to-date obj data for given workspace, index and key.
+    # Returns nil if no up-to-date data found.
+    def find_obj_data(current_content_state , index, key)
+      if index == 'permalink'
+        current_content_state.find_obj_data(index, key)
+      else
+        visitor = ContentStateVisitor.new(current_content_state)
+        cache_lookup_depth.times do |depth|
+          return unless content_state = visitor.visit_next
+          if hit = content_state.find_obj_data(index, key)
+            visitor.visited_except_current.each { |cs| return if cs.has_changes_for?(index, key, hit) }
+            current_content_state.save_obj_data(index, key, hit) if depth >= cache_replication_depth
+            return hit
+          end
+        end
+        nil
+      end
+    end
+  end
+
+  self.cache_replication_depth = 5
+  self.cache_lookup_depth = 20
+end
+
+end

data/lib/scrivito/content_state_visitor.rb

@@ -0,0 +1,19 @@
+module Scrivito
+  class ContentStateVisitor
+    def initialize(start_content_state)
+      @next_content_state, @visited = start_content_state, []
+    end
+
+    def visit_next
+      if content_state = @next_content_state
+        @visited << content_state
+        @next_content_state = content_state.from_content_state
+        content_state
+      end
+    end
+
+    def visited_except_current
+      @visited[0..-2]
+    end
+  end
+end

data/lib/scrivito/controller_runtime.rb

@@ -0,0 +1,35 @@
+require 'active_support/core_ext/module/attr_internal'
+
+module Scrivito
+
+module ControllerRuntime
+  extend ActiveSupport::Concern
+
+protected
+
+  attr_internal :rc_runtime
+
+  def cleanup_view_runtime
+    rc_rt_before_render = Scrivito::LogSubscriber.reset_runtime
+    runtime = super
+    rc_rt_after_render = Scrivito::LogSubscriber.reset_runtime
+    self.rc_runtime = rc_rt_before_render + rc_rt_after_render
+    runtime - rc_rt_after_render
+  end
+
+  def append_info_to_payload(payload)
+    super
+    payload[:rc_runtime] = rc_runtime
+  end
+
+  module ClassMethods
+    def log_process_action(payload)
+      messages, rc_runtime = super, payload[:rc_runtime]
+      messages << ("Scrivito: %.1fms" % rc_runtime.to_f)
+      messages
+    end
+  end
+end
+
+end # module Scrivito
+

data/lib/scrivito/date_attribute.rb

@@ -0,0 +1,16 @@
+module Scrivito
+
+  # Adds support for string columns which contain ISO dates
+  module DateAttribute
+    def self.parse(iso_date_time)
+      return nil unless iso_date_time
+
+      if iso_date_time.to_s =~ /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$/
+        Time.utc($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i).in_time_zone
+      else
+        raise "The value is not a valid ISO date time: #{iso_date_time.inspect}"
+      end
+    end
+  end
+
+end

data/lib/scrivito/deprecation.rb

@@ -0,0 +1,21 @@
+module Scrivito
+  class Deprecation
+    class << self
+      def warn(message, source = caller(1))
+        ActiveSupport::Deprecation.warn(message, source)
+      end
+
+      def warn_method(depricated_method_name, new_method_name = nil)
+        warn(warn_method_message(depricated_method_name, new_method_name), caller(1))
+      end
+
+      private
+
+      def warn_method_message(depricated_method_name, new_method_name = nil)
+        message = "The method #{depricated_method_name} will be removed from the Scrivito SDK. "
+        message << "Please use #{new_method_name} instead" if new_method_name
+        message
+      end
+    end
+  end
+end

data/lib/scrivito/diff.rb

@@ -0,0 +1,110 @@
+require "diff-lcs"
+require "hyp_diff"
+
+module Scrivito
+
+class Diff; class << self
+
+  def for(mode, field_type, old, new)
+    case field_type
+    when "widget"
+      ListComparison.for(mode, old || [], new || [])
+    when "html"
+      for_html(mode, old, new)
+    when "text"
+      for_string(mode, old, new)
+    when "string"
+      for_string(mode, old, new)
+    end
+  end
+
+  private
+
+  def for_string(mode, old, new)
+    for_html(mode, ERB::Util.h(old), ERB::Util.h(new))
+  end
+
+  def for_html(mode, old, new)
+    return nil if !old
+    return nil if !new
+
+    hyp_diff_options =
+      case mode
+      when "added"
+        {render_deletion: proc {}, markup_from: "after"}
+      when "deleted"
+        {render_insertion: proc {}, markup_from: "before"}
+      when "diff"
+        {}
+      else
+        return nil
+      end
+
+    diff = HypDiff.compare(old, new, hyp_diff_options)
+    [StringTagging.tag_as_html(diff)]
+  end
+
+  class ListComparison
+    def self.for(mode, old, new)
+      new(mode).compare(old, new).result
+    end
+
+    def initialize(mode)
+      @mode = mode
+      @list = []
+      @modifications = []
+    end
+
+    def compare(old, new)
+      ::Diff::LCS.sdiff(old, new).map do |change|
+        case change.action
+        when "-" then
+          note_deletion(change)
+        when "+" then
+          note_insertion(change)
+        when "=" then
+          note_equal(change)
+        when "!" then
+          note_deletion(change)
+          note_insertion(change)
+        else
+          raise "unexpected change.action #{change.action}"
+        end
+      end
+
+      self
+    end
+
+    def result
+      [@list, @modifications]
+    end
+
+    private
+
+    def note_equal(change)
+      @modifications << nil
+      if @mode == "deleted"
+        @list << change.old_element
+      else
+        @list << change.new_element
+      end
+    end
+
+    def note_deletion(change)
+      unless @mode == "added"
+        @modifications << "deleted"
+        @list << change.old_element
+      end
+    end
+
+    def note_insertion(change)
+      unless @mode == "deleted"
+        @modifications << "new"
+        @list << change.new_element
+      end
+    end
+  end
+
+end; end
+
+end