scrivito_sdk 1.0.0 → 1.1.0.rc1

data/lib/scrivito/configuration.rb

@@ -210,6 +210,7 @@ module Scrivito
         self.default_image_transformation = {}
         self.choose_homepage_callback = -> (env) { Obj.root }
         self.find_user_proc = nil
+        self.inject_preset_routes = true
         reset_editing_auth_callback!
       end
 
@@ -231,11 +232,48 @@ module Scrivito
 
 
       # @api public
+      # @deprecated The legacy routing is deprecated and will be removed in the next major
+      #   version of Scrivito.
       #
       # Scrivito changed its routing to a slug first url scheme. This configuration option
       # allows you to switch back to the old id first url scheme.
       attr_accessor :legacy_routing
 
+      def legacy_routing=(enabled)
+        if enabled
+          Scrivito::Deprecation.warn(%[
+The legacy routing is deprecated and will be removed in the next major version of Scrivito.
+Please use the new scrivito_route api to replicate the legacy routes:
+  scrivito_route '/', using: 'homepage', via: :all
+  scrivito_route '(/):id/*slug', using: 'slug_id', via: :all
+  scrivito_route '/*permalink', using: 'permalink', via: all
+          ])
+        end
+        @legacy_routing = enabled
+      end
+
+      # @api public
+      #
+      # The +inject_preset_routes+ configuration is enabled by default and adds the default
+      # Scrivito routing to your application routes. It can be disabled by setting it to
+      # +false+ which lets you use {RoutingExtensions#scrivito_route scrivito_route} to
+      # customize the routing used by Scrivito.
+      attr_accessor :inject_preset_routes
+
+      def scrivito_route_enabled?
+        inject_preset_routes == false
+      end
+
+      def with_scrivito_route_enabled
+        begin
+          initial_value = inject_preset_routes
+          self.inject_preset_routes = false
+          yield
+        ensure
+          self.inject_preset_routes = initial_value
+        end
+      end
+
       attr_accessor :choose_homepage_callback, :check_batch_size
 
       #

data/lib/scrivito/connection_manager.rb

@@ -61,11 +61,18 @@ module Scrivito
       end
     end
 
+    # for testing purposes
+    def connect_count
+      @connect_count || 0
+    end
+
     private
 
     attr_accessor :connection
 
     def ensure_started(timeout)
+      cleanup_dead_connection
+
       if @connection && @connection.started?
         configure_timeout(@connection, timeout)
       else
@@ -76,13 +83,75 @@ module Scrivito
           conn.cert_store = self.class.cert_store
         end
         configure_timeout(conn, timeout)
+
+        # keep_alive_timeout is not a timeout as in "wait no longer than X",
+        # but specifies how long a connection will be reused if it was idle.
+        # therefore the 'timeout' parameter is not applied here.
+        # instead we use a large value to maximize connection reuse.
+        # (ELB uses a keep alive timeout of 60 seconds).
+        conn.keep_alive_timeout = 59
+
         retry_twice_on_socket_error do
           conn.start
         end
+
+        increase_connect_count
         @connection = conn
       end
     end
 
+    def increase_connect_count
+      @connect_count ||= 0
+      @connect_count += 1
+    end
+
+    def cleanup_dead_connection
+      ensure_finished if connection_error?
+    end
+
+    # test if the http server closed the connection
+    # (i.e. due to a server-side keep alive timeout)
+    #
+    # if the server closes a connection, the socket of the connection
+    # is at EOF (End-Of-File). Using the connection would cause an error.
+    # Unfortunatly net/http does not detect this.
+    #
+    # Running into an error would be okay-ish for idempotent http requests,
+    # since retry is possible, but for non-idempotent requests (POST) the error
+    # would raise to the user.
+    #
+    # So we have to hack our way around net/http to access the socket directly.
+    # In order to do that, internals of net/http are accessed.
+    # If these internals change in future ruby versions, this method should
+    # simply returns `nil` (i.e. connection error are not detected)
+    # but not raise errors.
+    def connection_error?
+      return unless @connection
+
+      # compare: http://git.io/vltBR
+      socket = @connection.instance_variable_get("@socket")
+      return unless socket
+
+      # compare: http://git.io/vltRu
+      io = socket.try(:io)
+      return unless io && io.respond_to?(:read_nonblock)
+
+      begin
+        io.read_nonblock(1)
+
+        # if read_nonblock returns, there is unexpected data in the socket
+        # this indicates a connection problem, since http servers should never
+        # send data unless the client requests it.
+        true
+      rescue IO::WaitReadable, IO::WaitWritable
+        # these "errors" indicate the connection is still usable
+        false
+      rescue => e
+        # other errors indicate the connection has a problem
+        true
+      end
+    end
+
     def ensure_finished
       @connection.finish if @connection && @connection.started?
       @connection = nil

data/lib/scrivito/controller_actions.rb

@@ -163,8 +163,8 @@ module ControllerActions
   #
   def deliver_file
     if binary = @obj.binary
-      url = BinaryRouting.new(request, scrivito_engine).resolved_binary_obj_url(@obj, binary)
-      redirect_to CmsRouting.match_protocol(url, request)
+      binary_routing = BinaryRouting.new(request, scrivito_engine)
+      redirect_to binary_routing.resolved_binary_obj_url(@obj, binary)
     else
       render text: 'Empty Blob', status: 404
     end

data/lib/scrivito/controller_helper.rb

@@ -20,7 +20,7 @@ module Scrivito
     # @note +scrivito_path+ is also a helper method.
     #
     def scrivito_path(target, options = {})
-      CmsRouting.new(request, main_app, scrivito_engine).path_or_url(target, "path", options)
+      CmsRouting.new(request, self, scrivito_engine).path_or_url(target, "path", options)
     end
 
     #
@@ -38,7 +38,7 @@ module Scrivito
     # @note +scrivito_url+ is also a helper method.
     #
     def scrivito_url(target, options = {})
-      CmsRouting.new(request, main_app, scrivito_engine).path_or_url(target, "url", options)
+      CmsRouting.new(request, self, scrivito_engine).path_or_url(target, "url", options)
     end
 
     #

data/lib/scrivito/date_attribute.rb

@@ -17,7 +17,10 @@ module Scrivito
 
       DateTime.iso8601(iso8601_date_time).in_time_zone
     rescue ArgumentError
-      raise "The value is not a valid ISO 8601 date time: #{iso8601_date_time.inspect}"
+      raise Scrivito::ClientError.new(
+        "The value is not a valid ISO 8601 date time: #{iso8601_date_time.inspect}",
+        400
+      )
     end
 
     def self.serialize_for_backend(attribute_value)

data/lib/scrivito/deprecation.rb

@@ -5,14 +5,15 @@ module Scrivito
         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))
+      def warn_method(deprecated_method_name, new_method_name = nil)
+        warn(warn_method_message(deprecated_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. "
+      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

data/lib/scrivito/editing_context.rb

@@ -77,8 +77,8 @@ class EditingContext
 
   def to_params
     {
-      '_scrivito_display_mode' => display_mode,
-      '_scrivito_workspace_id' => selected_workspace.id,
+      _scrivito_display_mode: display_mode,
+      _scrivito_workspace_id: selected_workspace.id,
     }
   end
 

data/lib/scrivito/errors.rb

@@ -4,8 +4,25 @@ module Scrivito
 class ScrivitoError < StandardError
 end
 
+class ApplicationError < ScrivitoError
+  def http_code
+    412
+  end
+
+  def as_json
+    {message: message, message_for_editor: message}
+  end
+end
+
 # @api public
 class ResourceNotFound < ScrivitoError
+  def http_code
+    404
+  end
+
+  def as_json
+    {message: message}
+  end
 end
 
 # @api public

data/lib/scrivito/image_tag.rb

@@ -37,13 +37,13 @@ class ImageTag < Struct.new(:view_context)
       BinaryRouting.new(request, scrivito_engine)
         .binary_obj_url(obj_or_widget, attribute_value, image_options)
     else
-      path = CmsRouting.new(request, main_app, scrivito_engine, image_options)
+      path = CmsRouting.new(request, view_context, scrivito_engine, image_options)
         .path_or_url(attribute_value, :path)
       path unless path == CmsRouting::LINK_TO_EMPTY_BLOB
     end
   end
 
-  delegate :request, :main_app, :scrivito_engine, to: :view_context
+  delegate :request, :scrivito_engine, to: :view_context
 end
 
 end

data/lib/scrivito/link_parser.rb

@@ -63,9 +63,9 @@ module Scrivito
     end
 
     def find_obj(uri)
-      return nil unless application_uri?(uri) && application_route?(uri)
+      return nil unless application_uri?(uri)
 
-      route_params = route(uri)
+      route_params = obj_route_params(uri)
 
       if id = route_params[:id]
         Obj.find(id)
@@ -75,9 +75,14 @@ module Scrivito
     rescue Scrivito::ResourceNotFound
     end
 
-    def application_route?(uri)
-      route_params = route(uri)
-      route_params && route_params[:controller] == 'scrivito/cms_dispatch'
+    def obj_route_params(uri)
+      dispatch_route_for(sdk_route(uri)) || dispatch_route_for(route(uri)) || {}
+    end
+
+    def dispatch_route_for(route_params)
+      if route_params && route_params[:controller] == 'scrivito/cms_dispatch'
+        route_params
+      end
     end
 
     def sdk_route(uri)

data/lib/scrivito/meta_data_collection.rb

@@ -38,6 +38,17 @@ module Scrivito
 # [+iptc_state+]                      The state in which the image was produced.
 # [+iptc_country_name+]               The country in which the image was produced.
 # [+iptc_country_code+]               The code of the country in which the image was produced.
+#
+# == Searching for meta data
+#
+# Meta data is taken into account when searching. See the
+# {Scrivito::ObjSearchEnumerator ObjSearchEnumerator} for details.
+#
+# @example Search for all JPEGs
+#   Image.where('blob:content_type', :equals, 'image/jpeg')
+#
+# @example Search for wide images
+#   Image.where('blob:width', :is_greater_than, 1024)
 class MetaDataCollection
   def initialize(attributes)
     @attributes = ActiveSupport::HashWithIndifferentAccess.new(attributes)

data/lib/scrivito/obj_collection.rb

@@ -85,7 +85,7 @@ module Scrivito
     # @return [ObjSearchEnumerator]
     # @api public
     def all
-      ObjSearchEnumerator.new(workspace).batch_size(1000)
+      ObjSearchEnumerator.new(workspace, 1000)
     end
 
     # Returns an {ObjSearchEnumerator} of all {BasicObj Obj}s with the given +obj_class+.

data/lib/scrivito/obj_facet_value.rb

@@ -1,6 +1,9 @@
 module Scrivito
+  #
   # Instances of this class represent the result of a faceted search.
-  # @api beta
+  #
+  # @api public
+  #
   class ObjFacetValue
 
     def initialize(value, total, included_objs = [])
@@ -9,32 +12,41 @@ module Scrivito
       @included_objs = included_objs
     end
 
-    # @api beta
+    #
     # The value of the attribute name of this ObjFacetValue.
     #
+    # @api public
     # @return [String]
+    #
     def name
       @name
     end
 
-    # @api beta
+    #
     # Total number of Objs available that have this value.
     #
-    # Note that this refers to all Objs,
-    # not just the Objs included in this search.
+    # @api public
+    #
+    # Note that this refers to all Objs, not just the Objs included in this search.
     # Also note that the count is approximate.
+    #
     # @return [Integer]
+    #
     def count
       @count
     end
 
-    # @api beta
+    #
     # The Objs that were included in this search.
     #
-    # if you did not specify +include_objs+ in your facet options,
+    # @api public
+    #
+    # If you did not specify +include_objs+ in your facet options,
     # an empty array is returned.
     # The Objs are ordered by relevance.
+    #
     # @return [Array<BasicObj>]
+    #
     def included_objs
       @included_objs
     end

data/lib/scrivito/obj_params_parser.rb

@@ -28,26 +28,55 @@ module Scrivito
     def parse_widgetlist_params(params)
       params.map do |widget_id_or_params|
         if widget_id_or_params.is_a?(Hash)
-          action, widget_params = widget_id_or_params.flatten
-          case action
-          when 'create' then Widget.new(widget_params, context.slice(:scrivito_user))
-          when 'copy'
-            widget_id = widget_params['widget_id']
-            widget = Workspace.find(widget_params['workspace_id'])
-              .objs.find(widget_params['obj_id'])
-              .widgets[widget_id]
-            raise ResourceNotFound, "Could not find Widget with id #{widget_id}" unless widget
-            widget.copy
-          else raise UnknownWidgetAction
-          end
+          parse_widgetlist_params_with_action(widget_id_or_params)
         else
-          obj.widgets[widget_id_or_params]
+          widget = obj.widgets[widget_id_or_params]
+          raise_widget_not_found_error(widget_id_or_params) unless widget
+          widget
         end
       end
     end
 
+    def parse_widgetlist_params_with_action(params)
+      action, widget_params = params.flatten
+      case action
+      when 'create' then Widget.new(widget_params, context.slice(:scrivito_user))
+      when 'copy'
+        widget_id = widget_params['widget_id']
+        widget = Workspace.find(widget_params['workspace_id'])
+          .objs.find(widget_params['obj_id'])
+          .widgets[widget_id]
+        raise_widget_not_found_error(widget_id) unless widget
+        widget.copy
+      else raise UnknownWidgetAction
+      end
+    end
+
     def parse_binary_params(params)
-      UploadedBinary.new(params) if params
+      return unless params
+
+      if params[:copy]
+        parse_copy_binary_params(params[:copy])
+      else
+        UploadedBinary.new(params)
+      end
+    end
+
+    def parse_copy_binary_params(params)
+      obj = Obj.find(params[:obj_id])
+
+      if widget_id = params[:widget_id]
+        widget = obj.widgets[widget_id]
+        raise_widget_not_found_error(widget_id) unless widget
+      end
+
+      if binary = (widget || obj)[params[:attribute_name]]
+        binary.copy(filename: params[:filename], content_type: params[:content_type])
+      end
+    end
+
+    def raise_widget_not_found_error(widget_id)
+      raise ResourceNotFound, "Could not find Widget with id #{widget_id}"
     end
   end
 end

data/lib/scrivito/obj_search_builder.rb

@@ -40,8 +40,7 @@ class ObjSearchBuilder < Struct.new(:query)
   end
 
   def set_order
-    enumerator.order(query[:order]) if query[:order]
-    enumerator.reverse_order if query[:reverse_order]
+    enumerator.order(Hash[*query[:order]]) if query[:order]
   end
 
   def set_batch_size

data/lib/scrivito/obj_search_enumerator/batch.rb

@@ -0,0 +1,22 @@
+module Scrivito
+class ObjSearchEnumerator
+  class Batch
+    def initialize(objs, total, continuation, facets, previously_fetched_ids)
+      @objs = filter_duplicates(objs, previously_fetched_ids)
+      @total = total
+      @continuation = continuation
+      @facets = facets
+    end
+
+    attr_reader :objs, :total, :continuation, :facets
+
+    private
+
+    def filter_duplicates(objs, previously_fetched_ids)
+      objs.reject do |obj|
+        previously_fetched_ids.include?(obj.id)
+      end
+    end
+  end
+end
+end

data/lib/scrivito/obj_search_enumerator/batch_iterator.rb

@@ -0,0 +1,36 @@
+module Scrivito
+class ObjSearchEnumerator
+  class BatchIterator
+    def initialize(workspace, query, initial_batch)
+      @query = query
+      @executor = ObjSearchEnumerator::QueryExecutor.new(workspace)
+      @all_fetched_ids = Set.new
+      @initial_batch = initial_batch
+    end
+
+    attr_reader :total
+
+    def each
+      current_batch = initial_batch || fetch_batch
+
+      loop do
+        yield current_batch
+        break unless current_batch.continuation
+        current_batch = fetch_batch(current_batch.continuation)
+      end
+
+      @total = @all_fetched_ids.size
+    end
+
+    private
+
+    attr_reader :query, :executor, :initial_batch
+
+    def fetch_batch(continuation=nil)
+      batch = executor.call(query, continuation, @all_fetched_ids)
+      @all_fetched_ids += batch.objs.map(&:id)
+      batch
+    end
+  end
+end
+end

data/lib/scrivito/obj_search_enumerator/query_executor.rb

@@ -0,0 +1,35 @@
+module Scrivito
+class ObjSearchEnumerator
+  class QueryExecutor
+    def initialize(workspace)
+      @workspace = workspace
+    end
+
+    def call(query, continuation=nil, fetched_ids=[])
+      query['continuation'] = continuation if continuation
+      response = CmsBackend.instance.search_objs(workspace, query)
+
+      ObjSearchEnumerator::Batch.new(
+        build_objs(response),
+        response['total'].to_i,
+        response['continuation'],
+        response['facets'],
+        fetched_ids
+      )
+    end
+
+    private
+
+    attr_reader :workspace
+
+    def build_objs(response)
+      obj_ids = response['results'].map { |result| result['id'] }
+      if obj_ids.present?
+        workspace.objs.find_including_deleted(obj_ids)
+      else
+        []
+      end
+    end
+  end
+end
+end