scrivito_sdk 1.9.1 → 1.10.0.rc1

data/lib/scrivito/binary_param_verifier.rb

@@ -3,45 +3,41 @@ module Scrivito
 module BinaryParamVerifier
   InvalidSignature = Class.new(StandardError)
 
-  class << self
-    def verify(encrypted_params)
-      params = decrypt(encrypted_params)
-      expires = DateConversion.deserialize_from_backend(params['expires'])
-      raise InvalidSignature if expires && expires < Time.zone.now
-      verify_without_expire(encrypted_params)
-    end
+  def self.verify(encrypted_params)
+    params = decrypt(encrypted_params)
+    expires = DateConversion.deserialize_from_backend(params['expires'])
+    raise InvalidSignature if expires && expires < Time.zone.now
+    verify_without_expire(encrypted_params)
+  end
 
-    def verify_without_expire(encrypted_params)
-      params = decrypt(encrypted_params)
-      Binary.new(params['binary_id'], params['expires'].nil?,
-          transformation_definition: params['transformation_definition'],
-          obj_id: params['obj_id'])
-    end
+  def self.verify_without_expire(encrypted_params)
+    params = decrypt(encrypted_params)
+    Binary.new(params['binary_id'], params['expires'].nil?,
+        transformation_definition: params['transformation_definition'],
+        obj_id: params['obj_id'])
+  end
 
-    def generate(binary)
-      params = {
-        binary_id: binary.id,
-        obj_id: binary.obj_id,
-        transformation_definition: binary.transformation_definition,
-      }
-      if binary.private?
-        params[:expires] = DateConversion.serialize_for_backend(Time.zone.now + 1.hour)
-      end
-      message_verifier.generate(params)
+  def self.generate(binary)
+    params = {
+      binary_id: binary.id,
+      obj_id: binary.obj_id,
+      transformation_definition: binary.transformation_definition,
+    }
+    if binary.private?
+      params[:expires] = DateConversion.serialize_for_backend(Time.zone.now + 1.hour)
     end
+    message_verifier.generate(params)
+  end
 
-    private
-
-    def decrypt(encrypted_params)
-      message_verifier.verify(encrypted_params)
-    rescue ActiveSupport::MessageVerifier::InvalidSignature
-      raise InvalidSignature
-    end
+  private_class_method def self.decrypt(encrypted_params)
+    message_verifier.verify(encrypted_params)
+  rescue ActiveSupport::MessageVerifier::InvalidSignature
+    raise InvalidSignature
+  end
 
-    def message_verifier
-      ActiveSupport::MessageVerifier.new(
-        Rails.application.secrets.secret_key_base, serializer: JSON)
-    end
+  private_class_method def self.message_verifier
+    ActiveSupport::MessageVerifier.new(
+      Rails.application.secrets.secret_key_base, serializer: JSON)
   end
 end
 

data/lib/scrivito/client_error.rb

@@ -10,6 +10,8 @@ module Scrivito
     end
 
     def ==(client_error)
+      return false unless client_error.is_a?(ClientError)
+
       message == client_error.message &&
         http_code == client_error.http_code &&
         backend_code == client_error.backend_code

data/lib/scrivito/cms_data_cache.rb

@@ -4,87 +4,85 @@ module Scrivito
 module CmsDataCache
   VERSION = 'v3'.freeze
 
-  class << self
-    def cache
-      Thread.current[:scrivito_cms_data_cache_chain] ||=
-        Cache::RamStore.new(next_store: first_level_cache, cache_prefix: VERSION)
-    end
-
-    def cache_path=(path)
-      clear_cache_chain
-      @cache_path = path
-    end
-
-    def first_level_cache
-      @first_level_cache ||= Cache::FileStore.new(path: @cache_path, next_store: second_level_cache)
-    end
-
-    attr_reader :second_level_cache
-
-    def second_level_cache=(cache_store)
-      clear_cache_chain
-      @second_level_cache = cache_store
-    end
-
-    SCHEMA = {
-      obj_data:           'obj/#{cache_id}/#{index}/#{key}',
-      content_state_node: 'csn/#{content_state_id}',
-      workspace_state:    'wrkstt/#{workspace_id}',
-      tag_data:           'tagd/#{tag}'
-    }
-
-    SCHEMA.each do |name, schema|
-      params = schema.scan(/\#{([^}]+)}/).map(&:first)
-      params_code = params.map(&:to_s).join(",")
-
-      # using eval instead of define_method for performance reasons
-      class_eval(<<-END, __FILE__, __LINE__ + 1)
-        def read_#{name}(#{params_code})
-          cache.read("#{schema}")
-        end
-      END
-
-      class_eval(<<-END, __FILE__, __LINE__ + 1)
-        def write_#{name}(#{params_code}, data, **options)
-          if data == nil
-            raise InternalError, "tried to write nil into #{schema}"
-          end
-          cache.write("#{schema}", data, **options)
-        end
-      END
+  def self.cache
+    Thread.current[:scrivito_cms_data_cache_chain] ||=
+      Cache::RamStore.new(next_store: first_level_cache, cache_prefix: VERSION)
+  end
 
-      # for test purposes
-      class_eval(<<-END, __FILE__, __LINE__ + 1)
-        def evict_#{name}(#{params_code})
-          cache.write("#{schema}", nil)
-        end
-      END
-    end
+  def self.cache_path=(path)
+    clear_cache_chain
+    @cache_path = path
+  end
+
+  def self.first_level_cache
+    @first_level_cache ||= Cache::FileStore.new(path: @cache_path, next_store: second_level_cache)
+  end
+
+  def self.second_level_cache
+    @second_level_cache
+  end
+
+  def self.second_level_cache=(cache_store)
+    clear_cache_chain
+    @second_level_cache = cache_store
+  end
 
-    def write_data_to_tag(data)
-      tag = Digest::SHA1.base64digest(Marshal::dump(data))
-      write_tag_data(tag, data)
+  SCHEMA = {
+    obj_data:           'obj/#{cache_id}/#{index}/#{key}',
+    content_state_node: 'csn/#{content_state_id}',
+    workspace_state:    'wrkstt/#{workspace_id}',
+    tag_data:           'tagd/#{tag}'
+  }
+
+  SCHEMA.each do |name, schema|
+    params = schema.scan(/\#{([^}]+)}/).map(&:first)
+    params_code = params.map(&:to_s).join(",")
+
+    # using eval instead of define_method for performance reasons
+    class_eval(<<-END, __FILE__, __LINE__ + 1)
+      def self.read_#{name}(#{params_code})
+        cache.read("#{schema}")
+      end
+    END
+
+    class_eval(<<-END, __FILE__, __LINE__ + 1)
+      def self.write_#{name}(#{params_code}, data, **options)
+        if data == nil
+          raise InternalError, "tried to write nil into #{schema}"
+        end
+        cache.write("#{schema}", data, **options)
+      end
+    END
+
+    # for test purposes
+    class_eval(<<-END, __FILE__, __LINE__ + 1)
+      def self.evict_#{name}(#{params_code})
+        cache.write("#{schema}", nil)
+      end
+    END
+  end
 
-      tag
-    end
+  def self.write_data_to_tag(data)
+    tag = Digest::SHA1.base64digest(Marshal::dump(data))
+    write_tag_data(tag, data)
 
-    def read_data_from_tag(tag)
-      raise ArgumentError, 'tag can not be nil' if tag.nil?
-      read_tag_data(tag)
-    end
+    tag
+  end
 
-    def clear_request_cache
-      cache.clear
-    end
+  def self.read_data_from_tag(tag)
+    raise ArgumentError, 'tag can not be nil' if tag.nil?
+    read_tag_data(tag)
+  end
 
-    private
+  def self.clear_request_cache
+    cache.clear
+  end
 
-    def clear_cache_chain
-      Thread.current[:scrivito_cms_data_cache_chain] = nil
+  private_class_method def self.clear_cache_chain
+    Thread.current[:scrivito_cms_data_cache_chain] = nil
 
-      @first_level_cache = nil
-      @second_level_cache = nil
-    end
+    @first_level_cache = nil
+    @second_level_cache = nil
   end
 end
 

data/lib/scrivito/cms_rest_api.rb

@@ -84,162 +84,158 @@ module Scrivito
         Addressable::URI::CharacterClasses::UNRESERVED)
     end
 
-    class << self
+    private_class_method def self.request_cms_api(action, resource_path, payload, options)
+      assert_valid_resource_path(resource_path)
 
-      private
+      log_api_request(action, resource_path, payload) do
+        @number_of_requests += 1 if resource_path == @count_requests
 
-      def request_cms_api(action, resource_path, payload, options)
-        assert_valid_resource_path(resource_path)
+        timer = build_timer(options)
+        response = response_for_request_cms_api(action, resource_path, payload, timer)
 
-        log_api_request(action, resource_path, payload) do
-          @number_of_requests += 1 if resource_path == @count_requests
-
-          timer = build_timer(options)
-          response = response_for_request_cms_api(action, resource_path, payload, timer)
-
-          if task_response?(response)
-            task_path = "tasks/#{response['task']['id']}"
-            poll_interval = options[:interval].presence.try(:to_f) || 2
-            wait_for_tasks_final_response(task_path, poll_interval)
-          else
-            response
-          end
+        if task_response?(response)
+          task_path = "tasks/#{response['task']['id']}"
+          poll_interval = options[:interval].presence.try(:to_f) || 2
+          wait_for_tasks_final_response(task_path, poll_interval)
+        else
+          response
         end
       end
+    end
 
-      def log_api_request(action, resource_path, payload, &block)
-        ActiveSupport::Notifications.instrumenter.instrument(
-          "backend_request.scrivito",
-          {
-            :path => resource_path,
-            :verb => action,
-            :params => action == :get ? payload : nil
-          },
-          &block
-        )
-      end
+    private_class_method def self.log_api_request(action, resource_path, payload, &block)
+      ActiveSupport::Notifications.instrumenter.instrument(
+        "backend_request.scrivito",
+        {
+          :path => resource_path,
+          :verb => action,
+          :params => action == :get ? payload : nil
+        },
+        &block
+      )
+    end
 
-      def task_response?(response)
-        response.is_a?(Hash) && response.keys == ['task'] && response['task'].is_a?(Hash)
-      end
+    private_class_method def self.task_response?(response)
+      response.is_a?(Hash) && response.keys == ['task'] && response['task'].is_a?(Hash)
+    end
 
-      def response_for_request_cms_api(method, resource_path, payload, timer)
-        request = method_to_net_http_class(method).new(path(resource_path))
-        set_headers(request)
-        request.body = MultiJson.encode(payload) if payload.present?
+    private_class_method def self.response_for_request_cms_api(method, resource_path, payload,
+      timer)
+      request = method_to_net_http_class(method).new(path(resource_path))
+      set_headers(request)
+      request.body = MultiJson.encode(payload) if payload.present?
 
-        response = retry_once_on_network_error(method, timer) do
-          CmsRestApi::RateLimit.retry_on_rate_limit(timer) do
-            request_timeout = [timer.remaining_time, MAX_REQUEST_TIME].min
-            ConnectionManager.request(request, timeout: request_timeout)
-          end
+      response = retry_once_on_network_error(method, timer) do
+        CmsRestApi::RateLimit.retry_on_rate_limit(timer) do
+          request_timeout = [timer.remaining_time, MAX_REQUEST_TIME].min
+          ConnectionManager.request(request, timeout: request_timeout)
         end
-
-        handle_response(resource_path, response)
       end
 
-      def handle_response(resource_path, response)
-        http_code = response.code.to_i
-        if response.code.start_with?('2')
-          MultiJson.load(response.body)
-        elsif response.code == '403'
-          raise AccessDenied.new(response.body)
-        else
-          begin
-            error_body = MultiJson.decode(response.body)
-            specific_output = error_body['error']
-
-            if response.code.start_with?('4')
-              backend_code = error_body['code']
-              raise ClientError.new(specific_output,
-                  http_code: http_code, backend_code: backend_code)
-            elsif response.code == '500' && specific_output
-              raise BackendError.new(specific_output, http_code)
-            else # 3xx and >500 are treated as NetworkErrors
-              raise NetworkError.new(response.body, http_code)
-            end
-          rescue MultiJson::DecodeError
+      handle_response(resource_path, response)
+    end
+
+    private_class_method def self.handle_response(resource_path, response)
+      http_code = response.code.to_i
+      if response.code.start_with?('2')
+        MultiJson.load(response.body)
+      elsif response.code == '403'
+        raise AccessDenied.new(response.body)
+      else
+        begin
+          error_body = MultiJson.decode(response.body)
+          specific_output = error_body['error']
+
+          if response.code.start_with?('4')
+            backend_code = error_body['code']
+            raise ClientError.new(specific_output,
+                http_code: http_code, backend_code: backend_code)
+          elsif response.code == '500' && specific_output
+            raise BackendError.new(specific_output, http_code)
+          else # 3xx and >500 are treated as NetworkErrors
             raise NetworkError.new(response.body, http_code)
           end
+        rescue MultiJson::DecodeError
+          raise NetworkError.new(response.body, http_code)
         end
       end
+    end
 
-      def wait_for_tasks_final_response(task_path, poll_interval)
-        task_data = fetch_final_response(task_path, poll_interval)
+    private_class_method def self.wait_for_tasks_final_response(task_path, poll_interval)
+      task_data = fetch_final_response(task_path, poll_interval)
 
-        if task_data['status'] == 'success'
-          task_data['result']
-        else
-          message = task_data["message"] ||
-            "Missing error message in task response #{task_data}"
+      if task_data['status'] == 'success'
+        task_data['result']
+      else
+        message = task_data["message"] ||
+          "Missing error message in task response #{task_data}"
 
-          backend_code = task_data['code']
-          raise ClientError.new(message, backend_code: backend_code)
-        end
+        backend_code = task_data['code']
+        raise ClientError.new(message, backend_code: backend_code)
       end
+    end
 
-      def upload_file(file, content_type, upload_permission)
-        uri = URI.parse(upload_permission['url'])
-        uri.normalize!
+    private_class_method def self.upload_file(file, content_type, upload_permission)
+      uri = URI.parse(upload_permission['url'])
+      uri.normalize!
 
-        File.open(file) do |open_file|
-          upload_io = UploadIO.new(open_file, content_type, File.basename(file))
-          params = upload_permission['fields'].merge('file' => upload_io)
-          request = Net::HTTP::Post::Multipart.new(uri.path, params)
-          response = ConnectionManager.request(request, uri: uri)
+      File.open(file) do |open_file|
+        upload_io = UploadIO.new(open_file, content_type, File.basename(file))
+        params = upload_permission['fields'].merge('file' => upload_io)
+        request = Net::HTTP::Post::Multipart.new(uri.path, params)
+        response = ConnectionManager.request(request, uri: uri)
 
-          if response.code.starts_with?('2')
-            upload_permission['blob']
-          else
-            raise ScrivitoError, "File upload failed with code #{response.code}"
-          end
+        if response.code.starts_with?('2')
+          upload_permission['blob']
+        else
+          raise ScrivitoError, "File upload failed with code #{response.code}"
         end
       end
+    end
 
-      def fetch_final_response(task_path, poll_interval)
-        loop do
-          sleep poll_interval
-          task_data = response_for_request_cms_api(:get, task_path, nil, build_timer)
+    private_class_method def self.fetch_final_response(task_path, poll_interval)
+      loop do
+        sleep poll_interval
+        task_data = response_for_request_cms_api(:get, task_path, nil, build_timer)
 
-          return task_data if task_data['status'] != 'open'
-        end
+        return task_data if task_data['status'] != 'open'
       end
+    end
 
-      def retry_once_on_network_error(method, timer)
-        return yield if method == :post
+    private_class_method def self.retry_once_on_network_error(method, timer)
+      return yield if method == :post
 
-        begin
+      begin
+        yield
+      rescue NetworkError => e
+        if timer.finished?
+          raise e
+        else
           yield
-        rescue NetworkError => e
-          if timer.finished?
-            raise e
-          else
-            yield
-          end
         end
       end
+    end
 
-      def set_headers(request)
-        request.basic_auth('api_token', Configuration.api_key)
-        request['Content-type'] = 'application/json'
-        request['Accept'] = 'application/json'
-      end
+    private_class_method def self.set_headers(request)
+      request.basic_auth('api_token', Configuration.api_key)
+      request['Content-type'] = 'application/json'
+      request['Accept'] = 'application/json'
+    end
 
-      def path(path)
-        "/#{Configuration.endpoint_uri.path}/#{path}".squeeze('/')
-      end
+    private_class_method def self.path(path)
+      "/#{Configuration.endpoint_uri.path}/#{path}".squeeze('/')
+    end
 
-      def build_timer(options={})
-        CmsRestApi::RequestTimer.new(options.fetch(:timeout, DEFAULT_TIMEOUT))
-      end
+    private_class_method def self.build_timer(options={})
+      CmsRestApi::RequestTimer.new(options.fetch(:timeout, DEFAULT_TIMEOUT))
+    end
 
-      def method_to_net_http_class(method)
-        METHOD_TO_NET_HTTP_CLASS.fetch(method)
-      end
+    private_class_method def self.method_to_net_http_class(method)
+      METHOD_TO_NET_HTTP_CLASS.fetch(method)
+    end
 
-      def assert_valid_resource_path(resource_path)
-        URI(resource_path)
-      end
+    private_class_method def self.assert_valid_resource_path(resource_path)
+      URI(resource_path)
     end
   end
 end