scrivito_sdk 0.12.0

data/lib/scrivito/basic_widget.rb

@@ -0,0 +1,238 @@
+module Scrivito
+
+# The CMS widget class
+# @api public
+class BasicWidget
+  include AttributeContent
+
+  def self.type_computer
+    @_type_computer ||= TypeComputer.new(Scrivito::BasicWidget, ::Widget)
+  end
+
+  def self.reset_type_computer!
+    @_type_computer = nil
+  end
+
+  attr_accessor :container, :container_field_name
+
+  attr_writer :obj, :id
+
+  attr_reader :attributes_to_be_saved
+
+  delegate :widget_from_pool, to: :obj
+
+  # Create a new Widget.
+  # The new Widget must be stored inside a container (i.e. an Obj or another Widget)
+  # before it can be used.
+  #
+  # See {BasicObj.create Obj.create} for a detailed overview of how to set attributes.
+  # @api public
+  # @param [Hash] attributes
+  #
+  # @example Create a widget using a subclass
+  #   # you can create widgets by explicitly providing the attribute `_obj_class`
+  #   new_widget = Widget.new(_obj_class: "MyWidget")
+  #   # but it is better to simply use the constructor of a subclass
+  #   new_widget = MyWidget.new
+  #
+  # @example Create a widget and store it inside an Obj
+  #   # create the widget
+  #   new_widget = Widget.new(_obj_class: "MyWidget")
+  #   # store it inside an obj
+  #   my_obj(my_widget_field: [new_widget])
+  #
+  def initialize(attributes = {})
+    @attributes_to_be_saved = self.class.with_default_obj_class(attributes)
+  end
+
+  def revision
+    obj.revision
+  end
+
+  # Update the attributes of this Widget
+  #
+  # See {BasicObj.create Obj.create} for a detailed overview of how to set attributes
+  # @api public
+  # @param [Hash] attributes
+  def update(attributes)
+    widget_hash = CmsRestApi::WidgetExtractor.call(attributes, obj)
+    widget_pool = CmsRestApi::AttributeSerializer.generate_widget_pool_changes(widget_hash)
+        .merge(id => CmsRestApi::AttributeSerializer.convert(attributes))
+
+    obj_attributes = {'_widget_pool' => widget_pool}
+
+    widget_gc = WidgetGarbageCollection.new(obj, {self => attributes}.merge(widget_hash))
+    widget_gc.widgets_to_delete.each { |widget| widget_pool[widget.id] = nil }
+
+    CmsRestApi.put("workspaces/#{Workspace.current.id}/objs/#{obj.id}", obj: obj_attributes)
+
+    CmsRestApi::WidgetExtractor.notify_persisted_widgets(self.obj, widget_hash)
+
+    Workspace.reload
+
+    reload
+  end
+
+  # Destroys the {BasicWidget Widget} in the current {Workspace}
+  # @api public
+  def destroy
+    new_widget_list = container[container_field_name] - [self]
+    container.update(container_field_name => new_widget_list)
+  end
+
+  def id
+    if @id
+      @id
+    else
+      raise_not_persisted_errror
+    end
+  end
+
+  def persisted?
+    @attributes_to_be_saved.nil?
+  end
+
+  def obj_class_name
+    data_from_cms.value_of('_obj_class')
+  end
+
+  def obj_class
+    raise ScrivitoError, "BasicWidget#obj_class is no longer available"+
+      ", please use BasicWidget#obj_class_name instead."
+  end
+
+  def ==(other)
+    other.respond_to?(:obj) && obj == other.obj && other.respond_to?(:id) && id == other.id
+  end
+
+  def eql?(other)
+    self == other
+  end
+
+  # Reverts content changes of this widget. Widget attributes of this widget are not effected.
+  # After calling this method it's as if this widget has been never modified in the current working copy.
+  # This method does not work with +new+ or +deleted+ widgets.
+  # This method also does also not work for the +published+ workspace or the +rtc+ working copy.
+  def revert
+    Workspace.current.assert_revertable
+
+    case modification
+    when Modification::UNMODIFIED
+      # do nothing
+    when Modification::EDITED
+      previous_obj_content =
+          CmsRestApi.get("revisions/#{Workspace.current.base_revision_id}/objs/#{obj.id}")
+      previous_widget_content = previous_obj_content["_widget_pool"]["#{id}"]
+      previous_widget_content.delete_if do |attribute_name, _|
+        type_of_attribute(attribute_name) == "widget"
+      end
+      CmsRestApi.put("workspaces/#{Workspace.current.id}/objs/#{obj.id}",
+          { obj: {_widget_pool: {id => previous_widget_content}} })
+    else
+      raise ScrivitoError, "cannot revert changes, since widget is #{modification}."
+    end
+  end
+
+  def in_revision(revision)
+    obj_in_revision = obj.in_revision(revision)
+    obj_in_revision && obj_in_revision.widget_from_pool(id)
+  end
+
+  def new?(revision=Workspace.current.base_revision)
+    obj.new?(revision) || cms_data_for_revision(revision).nil?
+  end
+
+  def deleted?(revision=Workspace.current.base_revision)
+    obj.deleted?(revision)
+  end
+
+  def modification(revision=Workspace.current.base_revision)
+    if deleted?(revision)
+      Modification::DELETED
+    elsif new?(revision)
+      Modification::NEW
+    else
+      if data_from_cms == cms_data_for_revision(revision)
+        Modification::UNMODIFIED
+      else
+        Modification::EDITED
+      end
+    end
+  end
+
+  def hash
+    if @obj && @id
+      (id + obj.id).hash
+    else
+      super
+    end
+  end
+
+  # returns the entity ({BasicObj} or {BasicWidget}) that references this widget
+  # @api public
+  def container
+    @container || cache_container_and_field_name_for_widget.first
+  end
+
+  # returns the name of the widget field that references this widget
+  # @api public
+  def container_field_name
+    @container_field_name || cache_container_and_field_name_for_widget.second
+  end
+
+  def inspect
+    if @id
+      if @obj
+        "<#{self.class} id=\"#{id}\" obj.id=\"#{obj.id}\">"
+      else
+        "<#{self.class} id=\"#{id}\">"
+      end
+    else
+      "<#{self.class}>"
+    end
+  end
+
+  def obj
+    if @obj
+      @obj
+    else
+      raise_not_persisted_errror
+    end
+  end
+
+  def forget_unsaved_attribtues
+    @attributes_to_be_saved = nil
+    reload
+  end
+
+  def reload
+    obj.reload
+
+    update_proc = -> { obj.widget_data_from_pool(id) }
+    update_data(update_proc)
+  end
+
+  private
+
+  def data_from_cms
+    if persisted?
+      super
+    else
+      raise_not_persisted_errror
+    end
+  end
+
+  def raise_not_persisted_errror
+    raise ScrivitoError.new('Can not access a new widget before it has been saved')
+  end
+
+  def cms_data_for_revision(revision)
+    obj.widget_data_for_revision(id, revision)
+  end
+
+  def cache_container_and_field_name_for_widget
+    @cache_container_and_field_name_for_widget ||= obj.container_and_field_name_for_widget(id)
+  end
+end
+
+end

data/lib/scrivito/blob.rb

@@ -0,0 +1,48 @@
+module Scrivito
+
+# TODO Caching:
+# unlimited urls: ewig
+# limited urls: zeitlimit - x (x fuer mindestverwendbarkeitszeit)
+class Blob
+
+  class << self
+
+    def configure(config)
+    end
+
+    def find(id)
+      new(id)
+    end
+
+  end
+
+  attr_reader :id
+
+  def initialize(id)
+    @id = id
+  end
+
+  def url
+    raw_data["url"]
+  end
+
+  def content_type
+    meta_data[:content_type]
+  end
+
+  def length
+    meta_data[:content_length].to_i
+  end
+
+  private
+
+  def raw_data
+    @raw_data ||= CmsBackend.instance.find_blob_data_by_id(id)
+  end
+
+  def meta_data
+    @meta_data ||= RestClient.head(raw_data["meta_url"]).headers
+  end
+end
+
+end

data/lib/scrivito/cache.rb

@@ -0,0 +1,41 @@
+module Scrivito
+
+class Cache
+  attr_reader :cache_prefix, :fallback_backend
+
+  def initialize(options = {})
+    @fallback_backend, @cache_prefix = options[:fallback_backend], options[:cache_prefix]
+    @cache = {}
+  end
+
+  def read(key)
+    value = @cache[key]
+    if !value && @fallback_backend
+      value = @fallback_backend.read(cache_key_for_fallback_backend(key))
+      @cache[key] = value
+    end
+    value
+  end
+
+  def write(key, value, options={})
+    @fallback_backend.write(cache_key_for_fallback_backend(key), value, options) if @fallback_backend
+    @cache[key] = value
+  end
+
+  def fetch(key, &block)
+    read(key) || block.call.tap { |value| write(key, value) }
+  end
+
+  def clear
+    @cache = {}
+  end
+
+  private
+
+  def cache_key_for_fallback_backend(key)
+    @cache_prefix ? "#{@cache_prefix}/#{key}" : key
+  end
+end
+
+end # module Scrivito
+

data/lib/scrivito/cache_garbage_collector.rb

@@ -0,0 +1,83 @@
+module Scrivito
+  # The CacheGarbageCollector allows to remove old cache files from the Scrivito cache
+  # storage path. By default, a maximum of +DEFAULT_MAX_FILE_INODES+ file inodes that were accessed
+  # lately are kept in the cache directory. All other files and empty directories are removed. Log
+  # output is written to the Rails environment log file.
+  #
+  # @example Running the garbage collector with default settings
+  #
+  #   bundle exec rake scrivito:cache:gc
+  #
+  # @example Changing the maximum number of file inodes
+  #
+  #   bundle exec rake scrivito:cache:gc MAX_FILE_INODES=5000
+  class CacheGarbageCollector
+    DEFAULT_MAX_FILE_INODES = 100000
+
+    attr_accessor :max_file_inodes
+
+    def initialize(max_file_inodes = nil)
+      @max_file_inodes = (max_file_inodes || DEFAULT_MAX_FILE_INODES).to_i
+    end
+
+    def run_gc
+      announce "Cap number of cache file inodes at #{max_file_inodes} in #{cache_path}."
+
+      directories = []
+      file_inode_count = 0
+      delta_disk_space = 0
+      delta_count = 0
+
+      cache_entries.each do |cache_entry|
+        begin
+          stat = File.stat(cache_entry)
+
+          if stat.file?
+            file_inode_count += 1
+            next if file_inode_count <= max_file_inodes
+
+            File.delete(cache_entry)
+
+            delta_disk_space += stat.size
+            delta_count += 1
+          elsif stat.directory?
+            directories << cache_entry
+          end
+        rescue Errno::ENOENT
+        end
+      end
+
+      directories.sort.reverse_each do |dirname|
+        begin
+          Dir.rmdir(dirname)
+          delta_count += 1
+        rescue Errno::ENOTEMPTY, Errno::ENOENT
+        end
+      end
+
+      announce "Done. Removed #{delta_count} entries. Saved at least #{delta_disk_space} Bytes."
+    end
+
+    def cache_path
+      CmsCacheStorage.backend_cache.cache_path
+    end
+
+    def cache_entries
+      Dir["#{cache_path}/**/*"].sort_by do |file|
+        begin
+          -File.atime(file).to_i
+        rescue Errno::ENOENT
+          # If such file or directory does not exist, sort it as if the last
+          # access time is very long ago.
+          0
+        end
+      end
+    end
+
+    def announce(message)
+      message = "[#{Time.now.iso8601}] #{message}"
+
+      Rails.logger.info(message)
+    end
+  end
+end

data/lib/scrivito/cache_middleware.rb

@@ -0,0 +1,17 @@
+module Scrivito
+
+class CacheMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    CmsBackend.instance.begin_caching
+    @app.call(env)
+  ensure
+    CmsBackend.instance.end_caching
+    Workspace.cache.clear
+  end
+end
+
+end # module Scrivito

data/lib/scrivito/client_config.rb

@@ -0,0 +1,62 @@
+module Scrivito
+
+class ClientConfig < Struct.new(:obj, :editing_context, :lookup_context)
+  def to_json
+    config = {}
+    config[:editing_context] = editing_context_config
+    config[:i18n] = i18n_config
+    config[:obj] = obj_config
+    config.to_json
+  end
+
+  private
+
+  def editing_context_config
+    {
+      display_mode: editing_context.display_mode,
+
+      selected_workspace: {
+        id: editing_context.selected_workspace.id,
+        title: editing_context.selected_workspace.title
+      },
+
+      visible_workspace: {
+        id: editing_context.visible_workspace.id,
+        title: editing_context.visible_workspace.title
+      }
+    }
+  end
+
+  def i18n_config
+    {locale: I18n.locale}
+  end
+
+  def obj_config
+    if obj
+      {current_page: {
+        id: obj.id,
+        obj_class_name: obj.obj_class_name,
+        has_children: obj.children.any?,
+        has_conflict: obj.has_conflict?,
+        has_details_view: obj_has_details_view?,
+        modification: obj_modification,
+      }}
+    end
+  end
+
+  def obj_has_details_view?
+    lookup_context.find(obj.details_view_path).present?
+  rescue ActionView::MissingTemplate
+    false
+  end
+
+  def obj_modification
+    if editing_context.comparison.active?
+      editing_context.comparison.modification(obj)
+    else
+      obj.modification
+    end
+  end
+end
+
+end