scrivito_sdk 0.12.0

data/lib/scrivito/migrations/migration_store.rb

@@ -0,0 +1,23 @@
+require 'singleton'
+
+module Scrivito
+  module Migrations
+    class MigrationStore
+      include Singleton
+
+      def backend
+        @backend ||= CmsBackend.new
+      end
+
+      def versions
+        @versions ||= MultiJson.load(backend.read.presence || '[]')
+      end
+
+      def add_version(version)
+        versions << version
+
+        backend.save(MultiJson.dump(versions))
+      end
+    end
+  end
+end

data/lib/scrivito/migrations/migrator.rb

@@ -0,0 +1,135 @@
+module Scrivito
+  module Migrations
+    class Migrator
+      class << self
+        def migrations_path
+          Rails.root + 'cms/migrate'
+        end
+
+        def determine_migrations(paths)
+          paths = Array(paths)
+          files = Dir[*paths.map { |path| "#{path}/**/[0-9]*_*.rb" }]
+          splitter = /([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/
+
+          migrations = files.map do |filename|
+            version, name, scope = filename.scan(splitter).first
+
+            unless version
+              raise ScrivitoError.new("Illegal name for migration file: #{filename}\n\t
+                (only lower case letters, numbers, and '_' allowed)")
+            end
+
+            version = version
+            name = name.camelize
+
+            require(File.expand_path(filename))
+            name.constantize.new(name, version, filename, scope)
+          end
+
+          migrations.sort_by(&:version)
+        end
+      end
+
+      attr_reader :migrations
+      attr_reader :workspace_lock
+
+      def initialize(migration_store=nil, workspace_lock=nil)
+        @migrations = determine_migrations
+        @migration_store = migration_store || MigrationStore.instance
+        @workspace_lock = workspace_lock || WorkspaceLock.instance
+
+        validate
+      end
+
+      def migrate
+        workspace.as_current do
+          runnable.each do |migration|
+            migration.migrate
+            @migration_store.add_version(migration.version)
+          end
+        end
+      end
+
+      def needs_migration?
+        runnable.present?
+      end
+
+      def publish
+        remove_workspace_with do
+          CmsRestApi.put("workspaces/#{workspace.id}/publish", {})
+        end
+      end
+
+      def abort
+        remove_workspace_with do
+          CmsRestApi.delete("workspaces/#{workspace.id}")
+        end
+      end
+
+      private
+
+      def workspace
+        workspace = migration_workspace
+
+        if workspace
+          if workspace_lock.exists?
+            workspace_lock.validate(workspace)
+          end
+        else
+          CmsRestApi.post('workspaces', :workspace => { :title => 'rtc', :id => 'rtc' })
+          workspace = migration_workspace
+          workspace_lock.write(workspace)
+        end
+
+        workspace
+      end
+
+      def migration_workspace
+        Workspace.find('rtc')
+      rescue ResourceNotFound
+      end
+
+      def remove_workspace_with(&block)
+        workspace = migration_workspace
+
+        if workspace
+          workspace_lock.validate(workspace)
+
+          yield
+
+          workspace_lock.remove
+        else
+          raise ScrivitoError.new('Migration workspace does not exist')
+        end
+      end
+
+      def determine_migrations
+        self.class.determine_migrations(self.class.migrations_path)
+      end
+
+      def runnable
+        migrations.reject do |migration|
+          migrated_versions.include?(migration.version)
+        end
+      end
+
+      def migrated_versions
+        @migration_store.versions
+      end
+
+      def validate
+        name, _ = migrations.group_by(&:name).find { |_, value| value.length > 1 }
+
+        if name
+          raise ScrivitoError.new("Multiple migrations have the name #{name}")
+        end
+
+        version, _ = migrations.group_by(&:version).find { |_, value| value.length > 1 }
+
+        if version
+          raise ScrivitoError.new("Multiple migrations have the version number #{version}")
+        end
+      end
+    end
+  end
+end

data/lib/scrivito/migrations/workspace_lock.rb

@@ -0,0 +1,39 @@
+require 'singleton'
+
+module Scrivito
+  module Migrations
+    class WorkspaceLock
+      include Singleton
+
+      def validate(workspace)
+        unless exists? && workspace.revision_id == File.read(filename)
+          raise ScrivitoError.new("There is a migration in progress right now. \
+            Please try again after the migration working copy '#{workspace.id}' has \
+            been published or removed.")
+        end
+      end
+
+      def write(workspace)
+        File.open(filename, 'w') do |file|
+          file.write(workspace.revision_id)
+        end
+      end
+
+      def remove
+        if exists?
+          File.delete(filename)
+        end
+      end
+
+      def exists?
+        File.exists?(filename)
+      end
+
+      private
+
+      def filename
+        File.join(Rails.root, 'tmp/migration_store.lock')
+      end
+    end
+  end
+end

data/lib/scrivito/model_identity.rb

@@ -0,0 +1,13 @@
+module Scrivito
+
+module ModelIdentity
+  def ==(other)
+    other.equal?(self) || other.instance_of?(self.class) && other.id == id
+  end
+
+  alias_method :eql?, :==
+
+  delegate :hash, to: :id
+end
+
+end

data/lib/scrivito/modification.rb

@@ -0,0 +1,8 @@
+module Scrivito
+  module Modification
+    EDITED = 'edited'.freeze
+    NEW = 'new'.freeze
+    DELETED = 'deleted'.freeze
+    UNMODIFIED = nil
+  end
+end

data/lib/scrivito/named_link.rb

@@ -0,0 +1,75 @@
+module Scrivito
+
+  # This class provides methods used to retrieve objects from CMS based an entry
+  # in CMS of the obj_class <tt>NamedLink</tt>.
+  # @api public
+  class NamedLink
+
+    # @api public
+    class NotFound < StandardError
+    end
+
+    @@named_links_cache = nil
+
+    # Generates a cache of named links based on the CMS objects related link list.
+    # Raises exceptions if zero or more than one objects have this obj_class
+    def self.generate_named_links_cache
+      return if @@named_links_cache
+
+      found_object = find_named_link_obj
+      if found_object.nil?
+        raise NotFound, "Couldn't find NamedLink CMS Object!"
+      else
+        @@named_links_cache = found_object.
+          related_links.
+          flatten(1).
+          each_with_object({}) do |link_obj, temp|
+            temp[link_obj.title] = link_obj.obj
+          end
+      end
+
+      return nil
+    end
+
+    # This method will be called to retrieve the NamedLink {BasicObj Obj}.
+    # By default it will look for the Obj at the path "_named_links".
+    # Overwrite this method only if you know what you are doing.
+    # @api public
+    def self.find_named_link_obj
+      BasicObj.find_by_path("/_named_links")
+    end
+
+    def self.cache_expiry_time=(value)
+      raise "NamedLink.cache_expiry_time is deprecated. NamedLink no longer has a separate cache."
+    end
+
+    def self.cache_expired?
+      true
+    end
+
+    # Returns the CMS object mapped to the given title or nil.
+    # The title can be a string of symbol.
+    # @api public
+    def self.get_object(title, options = {})
+      object = named_links[title.to_s]
+      raise NotFound, "The NamedLink '#{title.to_s}' does not exist" if object.nil?
+      object
+    end
+
+    def self.reset_cache
+      @@named_links_cache = nil
+    end
+
+    def self.named_links
+      reset_cache if cache_expired?
+      generate_named_links_cache unless named_links_cache
+      named_links_cache
+    end
+
+    def self.named_links_cache
+      @@named_links_cache
+    end
+
+  end
+
+end

data/lib/scrivito/network_error.rb

@@ -0,0 +1,11 @@
+module Scrivito
+
+  class NetworkError < Scrivito::CommunicationError
+    attr_reader :http_code
+
+    def self.from_socket_error(socket_error)
+      new(socket_error.message, 503)
+    end
+  end
+
+end

data/lib/scrivito/obj_data.rb

@@ -0,0 +1,140 @@
+module Scrivito
+
+  class ObjData
+    MissingAttribute = Class.new
+
+    internal_key_list = %w[
+      last_changed
+      modification
+      permalink
+      text_links
+      conflicts
+    ]
+
+    INTERNAL_KEYS = Set.new(internal_key_list.map { |name| "_#{name}" } )
+
+    internal_comparison_key_list = %w[
+      path
+      permalink
+      widget_pool
+    ]
+
+    INTERNAL_COMPARISON_KEYS = Set.new(internal_comparison_key_list.map { |name| "_#{name}" })
+
+    SPECIAL_KEYS = Set.new(%w[ body title blob ])
+
+
+    def value_of(attribute_name)
+      value_and_type_of(attribute_name).first
+    end
+
+    def type_of(attribute_name)
+      value_and_type_of(attribute_name).second
+    end
+
+    def unchecked_value_of(attribute_name)
+      unchecked_value_and_type_of(attribute_name).first
+    end
+
+    def value_and_type_of(attribute_name)
+      value_and_type = internal_value_and_type_of(attribute_name)
+
+      if value_and_type.first.is_a?(MissingAttribute)
+        raise ScrivitoError.new("Illegal attribute name #{attribute_name}")
+      else
+        value_and_type
+      end
+    end
+
+    def unchecked_value_and_type_of(attribute_name)
+      value_and_type = internal_value_and_type_of(attribute_name)
+
+      if value_and_type.first.is_a?(MissingAttribute)
+        [nil, nil]
+      else
+        value_and_type
+      end
+    end
+
+    def all_custom_attributes
+      @all_custom_attributes ||= all_attributes.select do |attribute|
+        has_custom_attribute?(attribute)
+      end
+    end
+
+    def raw_value_and_type_of(attribute_name)
+      raise NotImplementedError, "implement in subclass"
+    end
+
+    def has_custom_attribute?(name)
+      raise NotImplementedError, "implement in subclass"
+    end
+
+    def all_attributes
+      raise NotImplementedError, "implement in subclass"
+    end
+
+    def ==(other)
+      if other.kind_of?(ObjData)
+        (all_attributes | other.all_attributes).each do |attr|
+          attr = attr.to_s
+
+          next if attr.start_with?('_') && !INTERNAL_COMPARISON_KEYS.include?(attr)
+
+          if unchecked_value_of(attr) != other.unchecked_value_of(attr)
+            return false
+          end
+        end
+
+        return true
+      end
+
+      false
+    end
+
+    private
+
+    def internal_value_and_type_of(attribute_name)
+      value_and_type = raw_value_and_type_of(attribute_name)
+
+      if value_and_type.blank?
+        if INTERNAL_KEYS.include?(attribute_name) || SPECIAL_KEYS.include?(attribute_name)
+          type = type_of_internal(attribute_name)
+          [default_attribute_value(attribute_name), type]
+        else
+          [ObjData::MissingAttribute.new, nil]
+        end
+      else
+        value_and_type
+      end
+    end
+
+    def type_of_internal(key)
+      case key
+      when "_permalink"
+        "string"
+      when "_text_links"
+        "linklist"
+      when "_last_changed"
+        "date"
+      when "title", "body"
+        "html"
+      when "blob"
+        "binary"
+      else
+        nil
+      end
+    end
+
+    def default_attribute_value(attribute_name)
+      case attribute_name
+      when "_text_links"
+        []
+      else
+        nil
+      end
+    end
+
+  end
+
+end