locomotivecms_steam 1.4.1 → 1.5.0.beta1

data/lib/locomotive/steam/liquid/tags/sections_dropzone.rb

@@ -0,0 +1,56 @@
+module Locomotive
+  module Steam
+    module Liquid
+
+      module Tags
+
+        class SectionsDropzone < ::Liquid::Tag
+
+          include Concerns::Section
+
+          def parse(tokens)
+            notify_on_parsing('_sections_dropzone_', is_dropzone: true)
+          end
+
+          def render(context)
+            sections_dropzone_content = context['page']&.sections_dropzone_content || []
+
+            html = sections_dropzone_content.each_with_index.map do |content, index|
+              # find the liquid source of the section
+              section = find_section(context, content['type'])
+
+              next if section.nil? # the section doesn't exist anymore?
+
+              # assign a new dom_id to the section
+              content['id'] = "dropzone-#{index}"
+
+              # parse the template of the section
+              template = build_template(section)
+
+              render_section(context, template, section, content)
+            end.join
+
+            %(<div class="locomotive-sections">#{html}</div>)
+          end
+
+          private
+
+          def find_section(context, type)
+            # TODO: add some cache (useful if there are sections with the same type)
+            context.registers[:services].section_finder.find(type)
+          end
+
+          def build_template(section)
+            # TODO: add some cache here (useful if there are sections with the same type)
+            ::Liquid::Template.parse(section.liquid_source, @options)
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('sections_dropzone'.freeze, SectionsDropzone)
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/liquid/tags/snippet.rb

@@ -6,10 +6,11 @@ module Locomotive
         class Snippet < ::Liquid::Include
 
           def parse(tokens)
-            ActiveSupport::Notifications.instrument('steam.parse.include', page: options[:page], name: @template_name)
+            name = evaluate_snippet_name
+
+            ActiveSupport::Notifications.instrument('steam.parse.include', page: options[:page], name: name)
 
             # look for editable elements
-            name = evaluate_snippet_name
             if options[:snippet_finder] && snippet = options[:snippet_finder].find(name)
               options[:parser]._parse(snippet, options.merge(snippet: name))
             end

data/lib/locomotive/steam/liquid/template.rb

@@ -1,7 +1,6 @@
 module Locomotive
   module Steam
     module Liquid
-
       class Template < ::Liquid::Template
 
         # When we render a Locomotive template, we need to know what are
@@ -18,18 +17,14 @@ module Locomotive
         end
 
         class << self
-
           def parse(source, options = {})
             template = new
             template.parse(source, options.merge({
               line_numbers: true
             }))
           end
-
         end
-
       end
-
     end
   end
 end

data/lib/locomotive/steam/middlewares.rb

@@ -1,6 +1,6 @@
 require_relative 'middlewares/thread_safe'
-require_relative 'middlewares/helpers'
 
+require_relative_all 'middlewares/concerns'
 require_relative_all 'middlewares'
 
 module Locomotive::Steam

data/lib/locomotive/steam/middlewares/auth.rb

@@ -13,7 +13,7 @@ module Locomotive::Steam
     #
     class Auth < ThreadSafe
 
-      include Helpers
+      include Concerns::Helpers
 
       def _call
         load_authenticated_entry
@@ -169,7 +169,7 @@ module Locomotive::Steam
         end
 
         def from
-          params[:auth_email_from] || 'support@locomotivecms.com'
+          smtp_config['sender'] || 'support@locomotivecms.com'
         end
 
         def subject
@@ -188,23 +188,39 @@ module Locomotive::Steam
           params[:auth_entry]
         end
 
+        def smtp_config
+          @config ||= _read_smtp_config
+        end
+
         def smtp
-          name = params[:auth_email_smtp_namespace] || 'smtp'
-          namespace = site.metafields.try(:[], name)
+          if smtp_config.blank?
+            {}
+          else
+            {
+              address:              smtp_config['address'],
+              port:                 smtp_config['port'],
+              user_name:            smtp_config['user_name'],
+              password:             smtp_config['password'],
+              authentication:       smtp_config['authentication'] || 'plain',
+              enable_starttls_auto: (smtp_config['enable_starttls_auto'] || "0").to_bool,
+            }
+          end
+        end
 
-          if namespace.blank?
+      private
+
+        def _read_smtp_config
+          name = params[:auth_email_smtp_namespace] || 'smtp'
+          config = site.metafields.try(:[], name)
+          if config.blank?
             Locomotive::Common::Logger.error "[Auth] Missing SMTP settings in the Site metafields. Namespace: #{name}".light_red
-            return {}
+            {}
+          else
+            config
           end
-
-          {
-            address:    namespace[params[:auth_email_smtp_address_alias] || 'address'],
-            port:       namespace[params[:auth_email_smtp_port_alias] || 'port'],
-            user_name:  namespace[params[:auth_email_smtp_user_name_alias] || 'user_name'],
-            password:   namespace[params[:auth_email_smtp_password_alias] || 'password']
-          }
         end
 
+
       end
 
     end

data/lib/locomotive/steam/middlewares/concerns/helpers.rb

@@ -0,0 +1,59 @@
+module Locomotive::Steam
+  module Middlewares
+    module Concerns
+      module Helpers
+
+        def html?
+          ['text/html', 'application/x-www-form-urlencoded', 'multipart/form-data'].include?(self.request.media_type) &&
+          !self.request.xhr? &&
+          !self.json?
+        end
+
+        def json?
+          self.request.content_type == 'application/json' || File.extname(self.request.path) == '.json'
+        end
+
+        def render_response(content, code = 200, type = nil)
+          @next_response = [code, { 'Content-Type' => type || 'text/html' }, [content]]
+        end
+
+        def redirect_to(location, type = 301)
+          _location = mounted_on && !location.starts_with?(mounted_on) && (location =~ Locomotive::Steam::IsHTTP).nil? ? "#{mounted_on}#{location}" : location
+
+          self.log "Redirected to #{_location}".blue
+
+          @next_response = [type, { 'Content-Type' => 'text/html', 'Location' => _location }, []]
+        end
+
+        def modify_path(path = nil, &block)
+          path ||= env['steam.path']
+
+          segments = path.split('/')
+          yield(segments)
+          path = segments.join('/')
+
+          path = '/' if path.blank?
+          path += "?#{request.query_string}" unless request.query_string.empty?
+          path
+        end
+
+        # make sure the location passed in parameter doesn't
+        # include the "mounted_on" parameter.
+        # If so, returns the location without the "mounted_on" string.
+        def make_local_path(location)
+          return location if mounted_on.blank?
+          location.gsub(Regexp.new('^' + mounted_on), '')
+        end
+
+        def mounted_on
+          request.env['steam.mounted_on']
+        end
+
+        def log(msg, offset = 2)
+          Locomotive::Common::Logger.info (' ' * offset) + msg
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/steam/middlewares/concerns/liquid_context.rb

@@ -0,0 +1,94 @@
+module Locomotive::Steam
+  module Middlewares
+    module Concerns
+      module LiquidContext
+
+        private
+
+        def liquid_context
+          ::Liquid::Context.new(liquid_assigns, {}, liquid_registers, true)
+        end
+
+        def liquid_registers
+          {
+            request:        request,
+            locale:         locale,
+            site:           site,
+            page:           page,
+            services:       services,
+            repositories:   services.repositories,
+            logger:         Locomotive::Common::Logger,
+            live_editing:   live_editing?,
+            params:         params,
+            session:        request.session,
+            cookies:        request.cookies
+          }
+        end
+
+        def liquid_assigns
+          _default_liquid_assigns.merge(
+            _locale_liquid_assigns.merge(
+              _request_liquid_assigns.merge(
+                _http_actions_liquid_assigns.merge(
+                  _steam_liquid_assigns))))
+        end
+
+        def _default_liquid_assigns
+          {
+            'current_page'      => params[:page],
+            'params'            => Locomotive::Steam::Liquid::Drops::Params.new(params),
+            'now'               => Time.zone.now,
+            'today'             => Date.today,
+            'mode'              => Locomotive::Steam.configuration.mode,
+            'wagon'             => Locomotive::Steam.configuration.mode == :test,
+            'live_editing'      => live_editing?
+          }
+        end
+
+        def _steam_liquid_assigns
+          {
+            'site'          => site.to_liquid,
+            'page'          => page.to_liquid,
+            'models'        => Locomotive::Steam::Liquid::Drops::ContentTypes.new,
+            'contents'      => Locomotive::Steam::Liquid::Drops::ContentTypes.new,
+            'session'       => Locomotive::Steam::Liquid::Drops::SessionProxy.new,
+          }.merge(env['steam.liquid_assigns'])
+        end
+
+        def _locale_liquid_assigns
+          {
+            'locale'         => locale.to_s,
+            'default_locale' => site.default_locale.to_s,
+            'locales'        => site.locales.map(&:to_s)
+          }
+        end
+
+        def _request_liquid_assigns
+          {
+            'base_url'    => request.base_url,
+            'fullpath'    => request.fullpath,
+            'http_method' => request.request_method,
+            'ip_address'  => request.ip,
+            'mounted_on'  => mounted_on,
+            'path'        => request.path,
+            'referer'     => request.referer,
+            'url'         => request.url,
+            'user_agent'  => request.user_agent,
+            'host'        => request.host_with_port
+          }
+        end
+
+        def _http_actions_liquid_assigns
+          {
+            'head?'    => request.head?,
+            'get?'    => request.get?,
+            'post?'   => request.post?,
+            'put?'    => request.put?,
+            'delete?' => request.delete?
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/steam/middlewares/encoded_link_redirection.rb

@@ -0,0 +1,45 @@
+module Locomotive::Steam
+  module Middlewares
+
+    # Redirect to the resource (page, templatized page with a content entry)
+    # based on the encoded link in the url.
+    # The link is encoded by the UrlPicker component (engine).
+    #
+    # For SEO purpose, the encoded link shouldn't be shared. It's just for internal purposes.
+    #
+    # Example:
+    #
+    # /_locomotive-link/eyJ0eXBlIjoiX2V4dGVybmFsIiwidmFsdWUiOiJodHRwczovL3d3dy5ub2NvZmZlZS5mciIsImxhYmVsIjpbImV4dGVybmFsIiwiaHR0cHM6Ly93d3cubm9jb2ZmZWUuZnIiXX0
+    #
+    # will redirect (302) to https://www.nocoffee.fr
+    #
+    class EncodedLinkRedirection < ThreadSafe
+
+      include Concerns::Helpers
+
+      PATH_REGEXP = /\/_locomotive-link\/(?<link>[^\"]+)/mo.freeze
+
+      def _call
+        if env['PATH_INFO'] =~ PATH_REGEXP
+          resource = url_finder.decode_link($~[:link])
+
+          # set the locale
+          if resource && resource['locale']
+            services.locale = 'fr'
+          end
+
+          link, _ = url_finder.url_for(resource)
+
+          redirect_to link, 302
+        end
+      end
+
+      private
+
+      def url_finder
+        services.url_finder
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/middlewares/entry_submission.rb

@@ -5,7 +5,7 @@ module Locomotive::Steam
     #
     class EntrySubmission < ThreadSafe
 
-      include Helpers
+      include Concerns::Helpers
 
       HTTP_REGEXP             = /^https?:\/\//o
       ENTRY_SUBMISSION_REGEXP = /^\/entry_submissions\/(\w+)/o

data/lib/locomotive/steam/middlewares/favicon.rb

@@ -5,7 +5,7 @@ module Locomotive::Steam
 
       attr_accessor_initialize :app
 
-      include Helpers
+      include Concerns::Helpers
 
       def call(env)
         if env['PATH_INFO'] == '/favicon.ico'

data/lib/locomotive/steam/middlewares/locale.rb

@@ -9,16 +9,19 @@ module Locomotive::Steam
     #   /fr/        => locale = :fr
     #   /index      => locale = :en (default one)
     #
-    # The
+    #   /en/index?locale=fr => locale = :fr
+    #   /index      => redirection to /en if the locale in session is :en
     #
     class Locale < ThreadSafe
 
-      include Helpers
+      include Concerns::Helpers
 
       def _call
-        locale = extract_locale
+        env['steam.path']   = request.path_info
 
-        log "Detecting locale #{locale.upcase}"
+        env['steam.locale'] = session[session_key_name] = services.locale = extract_locale
+
+        log "Locale used: #{locale.upcase}"
 
         I18n.with_locale(locale) do
           self.next
@@ -28,24 +31,69 @@ module Locomotive::Steam
       protected
 
       def extract_locale
-        _locale = locale_from_params || default_locale
-        _path   = request.path_info
+        # Regarding the index page (basically, "/"), we've to see if we could
+        # guess the locale from the headers the browser sends to us.
+        locale = if is_index_page?
+          locale_from_params || locale_from_session || locale_from_header
+        else
+          locale_from_path || locale_from_params
+        end
 
-        if _path =~ /^\/(#{site.locales.join('|')})+(\/|$)/
-          _locale  = $1
-          _path    = _path.gsub($1 + $2, '')
+        # make sure, the locale is among the ones defined in the site,
+        # otherwise take the default one.
+        locale && locales.include?(locale) ? locale : default_locale
+      end
 
-          # let the other middlewares that the locale was
-          # extracted from the path.
+      def locale_from_params
+        params[:locale]&.to_sym.tap do |locale|
+          log 'Locale extracted from the params' unless locale.blank?
+        end
+      end
+
+      def locale_from_path
+        path = request.path_info
+
+        if path =~ /^\/(#{site.locales.join('|')})+(\/|$)/
+          locale = $1
+
+          # no need to keep the locale in the path used to fetch the page
+          env['steam.path'] = path.gsub($1 + $2, '')
           env['steam.locale_in_path'] = true
+
+          log 'Locale extracted from the path'
+
+          locale.to_sym
         end
+      end
 
-        env['steam.path']   = _path
-        env['steam.locale'] = services.locale = _locale
+      def locale_from_header
+        request.accept_language.lazy
+        .sort { |a, b| b[1] <=> a[1] }
+        .map  { |lang, _| lang[0..1].to_sym }
+        .find { |lang| locales.include?(lang) }.tap do |locale|
+          log 'Locale extracted from the header' unless locale.blank?
+        end
       end
 
-      def locale_from_params
-        locales.include?(params[:locale]) ? params[:locale] : nil
+      def locale_from_session
+        if locale = session[session_key_name]
+          env['steam.locale_in_session'] = true
+
+          log 'Locale extracted from the session'
+
+          locale.to_sym
+        end
+      end
+
+      # The preview urls for all the sites share the same domain, so session[:locale]
+      # would be the same for all the preview urls and this is not good.
+      # This is why we need to use a different key.
+      def session_key_name
+        live_editing? ? "steam-locale-#{site.handle}" : 'steam-locale'
+      end
+
+      def is_index_page?
+        ['/', ''].include?(request.path_info)
       end
 
     end