scrivito_sdk 1.9.1 → 1.10.0.rc1

data/lib/scrivito/connection_manager.rb

@@ -6,54 +6,60 @@ module Scrivito
 
     attr_reader :uri
 
-    class << self
-      def request(request, timeout: nil, uri: nil)
-        connection_pool_for(uri || Configuration.endpoint_uri).with do |connection|
-          connection.request(request, timeout)
-        end
+    def self.request(request, timeout: nil, uri: nil)
+      connection_pool_for(uri || Configuration.endpoint_uri).with do |connection|
+        connection.request(request, timeout)
       end
+    end
 
-      # For test purpose only.
-      def clear_cache!
-        @connection_pools = nil
-        @cert_store = nil
-      end
+    # For test purpose only.
+    def self.clear_cache!
+      @connection_pools = nil
+      @cert_store = nil
+    end
 
-      def cert_store
-        @cert_store ||= OpenSSL::X509::Store.new.tap do |store|
-          store.set_default_paths
-          store.add_file(Configuration.ca_file)
-        end
+    def self.cert_store
+      @cert_store ||= OpenSSL::X509::Store.new.tap do |store|
+        store.set_default_paths
+        store.add_file(Configuration.ca_file)
       end
+    end
 
-      attr_writer :minimum_open_timeout
-      attr_writer :minimum_ssl_timeout
-      attr_writer :minimum_read_timeout
+    def self.minimum_open_timeout
+      @minimum_open_timeout || 0.5
+    end
 
-      def minimum_open_timeout
-        @minimum_open_timeout || 0.5
-      end
+    def self.minimum_open_timeout=(value)
+      @minimum_open_timeout = value
+    end
 
-      def minimum_ssl_timeout
-        @minimum_ssl_timeout || 1.0
-      end
+    def self.minimum_ssl_timeout
+      @minimum_ssl_timeout || 1.0
+    end
 
-      def minimum_read_timeout
-        @minimum_read_timeout || 0.5
-      end
+    def self.minimum_ssl_timeout=(value)
+      @minimum_ssl_timeout = value
+    end
+
+    def self.minimum_read_timeout
+      @minimum_read_timeout || 0.5
+    end
+
+    def self.minimum_read_timeout=(value)
+      @minimum_read_timeout = value
+    end
 
-      def connection_pool_for(uri)
-        endpoint_url = "#{uri.scheme}://#{uri.host}:#{uri.port}"
-        connection_pools.fetch(endpoint_url) do
-          connection_pools[endpoint_url] = ConnectionPool.new(size: 100, timeout: 0) do
-            new(URI.parse(endpoint_url))
-          end
+    def self.connection_pool_for(uri)
+      endpoint_url = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+      connection_pools.fetch(endpoint_url) do
+        connection_pools[endpoint_url] = ConnectionPool.new(size: 100, timeout: 0) do
+          new(URI.parse(endpoint_url))
         end
       end
+    end
 
-      def connection_pools
-        @connection_pools ||= {}
-      end
+    def self.connection_pools
+      @connection_pools ||= {}
     end
 
     def initialize(uri)

data/lib/scrivito/deprecation.rb

@@ -1,22 +1,18 @@
 module Scrivito
   class Deprecation
-    class << self
-      def warn(message, source = caller(1))
-        ActiveSupport::Deprecation.warn(message, source)
-      end
-
-      def warn_method(deprecated_method_name, new_method_name = nil)
-        warn(warn_method_message(deprecated_method_name, new_method_name), caller(1))
-      end
+    def self.warn(message, source = caller(1))
+      ActiveSupport::Deprecation.warn(message, source)
+    end
 
-      private
+    def self.warn_method(deprecated_method_name, new_method_name = nil)
+      warn(warn_method_message(deprecated_method_name, new_method_name), caller(1))
+    end
 
-      def warn_method_message(deprecated_method_name, new_method_name = nil)
-        message = "The method #{deprecated_method_name} is deprecated and will be removed "\
-          "from the Scrivito SDK in the next major version. "
-        message << "Please use #{new_method_name} instead" if new_method_name
-        message
-      end
+    private_class_method def self.warn_method_message(deprecated_method_name, new_method_name = nil)
+      message = "The method #{deprecated_method_name} is deprecated and will be removed "\
+        "from the Scrivito SDK in the next major version. "
+      message << "Please use #{new_method_name} instead" if new_method_name
+      message
     end
   end
 end

data/lib/scrivito/diff.rb

@@ -3,9 +3,9 @@ require "hyp_diff"
 
 module Scrivito
 
-class Diff; class << self
+class Diff
 
-  def for(mode, field_type, old, new)
+  def self.for(mode, field_type, old, new)
     case field_type
     when "widgetlist"
       ListComparison.for(mode, old || [], new || [])
@@ -16,13 +16,11 @@ class Diff; class << self
     end
   end
 
-  private
-
-  def for_string(mode, old, new)
+  private_class_method def self.for_string(mode, old, new)
     for_html(mode, ERB::Util.h(old), ERB::Util.h(new))
   end
 
-  def for_html(mode, old, new)
+  private_class_method def self.for_html(mode, old, new)
     return if !old
     return if !new
     return unless %w[added deleted diff].include?(mode)
@@ -31,7 +29,7 @@ class Diff; class << self
     [StringTagging.tag_as_html(diff)]
   end
 
-  def hyp_diff_options(mode)
+  private_class_method def self.hyp_diff_options(mode)
     render_insertion_proc = proc { |html| "<span class='scrivito_insertion'>#{html}</span>" }
     render_deletion_proc  = proc { |html| "<span class='scrivito_deletion'>#{html}</span>" }
     render_nothing_proc   = proc {}
@@ -118,6 +116,6 @@ class Diff; class << self
     end
   end
 
-end; end
+end
 
 end

data/lib/scrivito/gem_info.rb

@@ -1,13 +1,16 @@
 module Scrivito
   module GemInfo
-    class << self
-      delegate :name, :version, to: :spec
 
-      private
+    def self.name
+      spec.name
+    end
+
+    def self.version
+      spec.version
+    end
 
-      def spec
-        @spec ||= Gem.loaded_specs['scrivito_sdk']
-      end
+    private_class_method def self.spec
+      @spec ||= Gem.loaded_specs['scrivito_sdk']
     end
   end
 end

data/lib/scrivito/generator_helper.rb

@@ -1,12 +1,10 @@
 module Scrivito
 module GeneratorHelper
-  class << self
-    def attribute_definition(arg)
-      if %w(enum multienum).include?(arg.type.to_s)
-        "attribute :#{arg.name}, :#{arg.type}, values: []"
-      else
-        "attribute :#{arg.name}, :#{arg.type}"
-      end
+  def self.attribute_definition(arg)
+    if %w(enum multienum).include?(arg.type.to_s)
+      "attribute :#{arg.name}, :#{arg.type}, values: []"
+    else
+      "attribute :#{arg.name}, :#{arg.type}"
     end
   end
 end

data/lib/scrivito/migrations/cms_backend.rb

@@ -10,8 +10,8 @@ module Scrivito
       end
 
       def save(value)
-        CmsRestApi.put(endpoint("objs/#{migration_store_obj.id}"),
-          obj: {versions: ['string', value]})
+        Workspace.current.update_obj(migration_store_obj.id,
+          { obj: { versions: ['string', value] } })
 
         Workspace.current.reload
       end
@@ -19,8 +19,15 @@ module Scrivito
       private
 
       def create
-        CmsRestApi.post(endpoint('objs'),
-          obj: {_path: path, _obj_class: 'MigrationStore', versions: ['string', '']})
+        obj_id = SecureRandom.hex(8)
+        Workspace.current.update_obj(obj_id, {
+          obj: {
+            _id: obj_id,
+            _obj_class: 'MigrationStore',
+            _path: path,
+            versions: ['string', ''],
+          }
+        })
 
         Workspace.current.reload
       end
@@ -37,10 +44,6 @@ module Scrivito
       def path
         '/_internal/migration-store'
       end
-
-      def endpoint(path)
-        "workspaces/#{Workspace.current.id}/#{path}"
-      end
     end
   end
 end

data/lib/scrivito/migrations/migrator.rb

@@ -1,33 +1,31 @@
 module Scrivito
   module Migrations
     class Migrator
-      class << self
-        def migrations_path
-          Rails.root + Scrivito::Configuration.migration_path
-        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
+      def self.migrations_path
+        Rails.root + Scrivito::Configuration.migration_path
+      end
 
-            unless version
-              raise ScrivitoError.new("Illegal name for migration file: #{filename}\n\t
-                (only lower case letters, numbers, and '_' allowed)")
-            end
+      def self.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/
 
-            version = version
-            name = name.camelize
+        migrations = files.map do |filename|
+          version, name, scope = filename.scan(splitter).first
 
-            require(File.expand_path(filename))
-            name.constantize.new(name, version, filename, scope)
+          unless version
+            raise ScrivitoError.new("Illegal name for migration file: #{filename}\n\t
+              (only lower case letters, numbers, and '_' allowed)")
           end
 
-          migrations.sort_by(&:version)
+          version = version
+          name = name.camelize
+
+          require(File.expand_path(filename))
+          name.constantize.new(name, version, filename, scope)
         end
+
+        migrations.sort_by(&:version)
       end
 
       attr_reader :migrations

data/lib/scrivito/obj_search_enumerator.rb

@@ -248,6 +248,17 @@ module Scrivito
   # @api public
   class ObjSearchEnumerator
     INVALID_NEGATED_OPERATORS = [:contains, :contains_prefix].freeze
+    OPERATOR_WHITELIST = [
+      :contains,
+      :contains_prefix,
+      :equals,
+      :starts_with,
+      :is_greater_than,
+      :is_less_than,
+      :links_to,
+      :refers_to,
+    ].freeze
+
     include Enumerable
 
     attr_reader :workspace
@@ -279,11 +290,12 @@ module Scrivito
     # @return [Scrivito::ObjSearchEnumerator]
     # @api public
     def and(field, operator, value, boost = nil)
-      real_operator = operator_mapping(operator)
-      subquery = { field: field, operator: real_operator, value: convert_value(value) }
+      symbolized_operator = ensure_symbol_and_validate_operator(operator)
+
+      subquery = { field: field, operator: symbolized_operator, value: convert_value(value) }
       if boost.present?
         valid_boost_operators = [:contains, :contains_prefix]
-        if valid_boost_operators.include?(operator.to_sym)
+        if valid_boost_operators.include?(symbolized_operator)
           subquery[:boost] = boost
         else
           raise "Boost is not allowed with operator '#{operator}'. " +
@@ -315,8 +327,9 @@ module Scrivito
       if INVALID_NEGATED_OPERATORS.include?(operator.to_sym)
         raise "Negating operator '#{operator}' is not valid."
       end
-      real_operator = operator_mapping(operator)
-      subquery = { field: field, operator: real_operator, value: convert_value(value),
+      symbolized_operator = ensure_symbol_and_validate_operator(operator)
+
+      subquery = { field: field, operator: symbolized_operator, value: convert_value(value),
           negate: true }
       reset_for_changed_query
       @query = (query || []) + [subquery]
@@ -657,27 +670,14 @@ module Scrivito
       end
     end
 
-    def operator_mapping(operator)
-      case operator.to_sym
-      when :contains
-        :search
-      when :contains_prefix
-        :prefix_search
-      when :equals
-        :equal
-      when :starts_with
-        :prefix
-      when :is_greater_than
-        :greater_than
-      when :is_less_than
-        :less_than
-      when :links_to
-        :links_to
-      when :refers_to
-        :refers_to
-      else
+    def ensure_symbol_and_validate_operator(operator)
+      symbolized_operator = operator.to_sym
+
+      unless OPERATOR_WHITELIST.include?(symbolized_operator)
         raise "Operator '#{operator}' is not valid!"
       end
+
+      symbolized_operator
     end
 
     def search_dsl_params

data/lib/scrivito/request_homepage.rb

@@ -2,21 +2,17 @@ module Scrivito
   module RequestHomepage
     HOMEPAGE_ENV_KEY = "SCRIVITO_HOMEPAGE"
 
-    class << self
-      def call(env)
-        env[HOMEPAGE_ENV_KEY] ||= fetch_homepage(env)
-      end
-
-      private
+    def self.call(env)
+      env[HOMEPAGE_ENV_KEY] ||= fetch_homepage(env)
+    end
 
-      def fetch_homepage(env)
-        callback_result = Scrivito::Configuration.choose_homepage_callback.call(env)
-        if callback_result.is_a?(Obj)
-          callback_result
-        else
-          raise "choose_homepage callback did not return an Obj. "\
-            "Instead saw #{callback_result.class}."
-        end
+    private_class_method def self.fetch_homepage(env)
+      callback_result = Scrivito::Configuration.choose_homepage_callback.call(env)
+      if callback_result.is_a?(Scrivito::BasicObj)
+        callback_result
+      else
+        raise "choose_homepage callback did not return an Obj. "\
+          "Instead saw #{callback_result.class}."
       end
     end
   end

data/lib/scrivito/route.rb

@@ -2,47 +2,43 @@ module Scrivito
 
 class Route
 
-  class << self
-    VALID_ROUTE_NAMES = %i(homepage slug_id permalink).freeze
+  VALID_ROUTE_NAMES = %i(homepage slug_id permalink).freeze
 
-    def register(route_set, name)
-      assert_valid_route_name(name)
-      registry(route_set)[name] = new(name)
-    end
+  def self.register(route_set, name)
+    assert_valid_route_name(name)
+    registry(route_set)[name] = new(name)
+  end
 
-    def find(given_context, name)
-      available_contexts(given_context).each do |context|
-        route = registry(context._routes)[name]
+  def self.find(given_context, name)
+    available_contexts(given_context).each do |context|
+      route = registry(context._routes)[name]
 
-        if route && route.defined_in?(context)
-          return route.apply_to(context)
-        end
+      if route && route.defined_in?(context)
+        return route.apply_to(context)
       end
-
-      nil
     end
 
-    private
+    nil
+  end
 
-    def registry(route_set)
-      @registry ||= {}
-      @registry[route_set] ||= {}
-    end
+  private_class_method def self.registry(route_set)
+    @registry ||= {}
+    @registry[route_set] ||= {}
+  end
 
-    def assert_valid_route_name(name)
-      unless VALID_ROUTE_NAMES.include?(name)
-        valid_values = VALID_ROUTE_NAMES.join(', ')
-        raise ScrivitoError,
-            %("#{name}" is not a valid scrivito route name. Valid values are: #{valid_values}.)
-      end
+  private_class_method def self.assert_valid_route_name(name)
+    unless VALID_ROUTE_NAMES.include?(name)
+      valid_values = VALID_ROUTE_NAMES.join(', ')
+      raise ScrivitoError,
+          %("#{name}" is not a valid scrivito route name. Valid values are: #{valid_values}.)
     end
+  end
 
-    def available_contexts(context)
-      [
-        context,
-        context.try(:main_app)
-      ].compact
-    end
+  private_class_method def self.available_contexts(context)
+    [
+      context,
+      context.try(:main_app)
+    ].compact
   end
 
   def initialize(name)