locomotivecms_steam 1.5.0.rc0 → 1.5.0.rc1

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

@@ -5,45 +5,37 @@ module Locomotive
 
         class Snippet < ::Liquid::Include
 
-          def parse(tokens)
-            name = evaluate_snippet_name
+          attr_reader :name
+
+          def initialize(tag_name, markup, options)
+            super
 
-            ActiveSupport::Notifications.instrument('steam.parse.include', page: options[:page], name: name)
+            # we use a convention to differentiate sections from snippets
+            @name               = evaluate_snippet_name
+            @template_name_expr = "snippets--#{@name}"
+          end
+
+          def parse(tokens)
+            ActiveSupport::Notifications.instrument('steam.parse.include', page: parse_context[:page], name: name)
 
-            # look for editable elements
-            if options[:snippet_finder] && snippet = options[:snippet_finder].find(name)
-              options[:parser]._parse(snippet, options.merge(snippet: name))
+            # look for editable elements (only used by the Engine)
+            # In the next version of Locomotive (v5), we won't support the editable elements
+            if parse_context[:snippet_finder] && snippet = parse_context[:snippet_finder].find(name)
+              parse_context[:parser]._parse(snippet, parse_context.merge(snippet: name))
             end
           end
 
           def render(context)
-            @template_name = evaluate_snippet_name(context)
-            # @options doesn't include the page key if cache is on
-            @options[:page] = context.registers[:page]
-
-            begin
-              super
-            rescue Locomotive::Steam::ParsingRenderingError => e
-              e.file = @template_name + ' [Snippet]'
-              raise e
-            end
+            # parse_context (previously @options) doesn't include the page key if cache is on
+            parse_context[:page] = context.registers[:page]
+            super
           end
 
           private
 
-          def read_template_from_file_system(context)
-            service = context.registers[:services]
-            snippet = service.snippet_finder.find(@template_name)
-
-            raise SnippetNotFound.new("Snippet with slug '#{@template_name}' was not found") if snippet.nil?
-
-            snippet.liquid_source
-          end
-
-          def evaluate_snippet_name(context = nil)
-            context.try(:evaluate, @template_name) ||
-            (!@template_name.is_a?(String) && @template_name.send(:state).first) ||
-            @template_name
+          def evaluate_snippet_name
+            (!template_name_expr.is_a?(String) && template_name_expr.send(:state).first) ||
+            template_name_expr
           end
 
         end

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

@@ -14,65 +14,99 @@ module Locomotive
         # {% endwith_scope %}
         #
 
-        class WithScope < Solid::Block
+        class WithScope < ::Liquid::Block
 
-          OPERATORS = %w(all exists gt gte in lt lte ne nin size near within)
+          include Concerns::Attributes
 
-          SYMBOL_OPERATORS_REGEXP = /(\w+\.(#{OPERATORS.join('|')})){1}\s*\:/o
+          # Regexps and Arrays are allowed
+          ArrayFragment   = /\[(\s*(#{::Liquid::QuotedFragment},\s*)*#{::Liquid::QuotedFragment}\s*)\]/o.freeze
+          RegexpFragment  = /\/([^\/]+)\/([imx]+)?/o.freeze
+
+          # a slight different from the Shopify implementation because we allow stuff like `started_at.le`
+          TagAttributes   = /([a-zA-Z_0-9\.]+)\s*\:\s*(#{ArrayFragment}|#{RegexpFragment}|#{::Liquid::QuotedFragment})/o.freeze
 
           REGEX_OPTIONS = {
             'i' => Regexp::IGNORECASE,
             'm' => Regexp::MULTILINE,
             'x' => Regexp::EXTENDED
-          }
+          }.freeze
+
+          attr_reader :attributes
 
-          # register the tag
-          tag_name :with_scope
+          def initialize(tag_name, markup, options)
+            super
 
-          def initialize(name, markup, options)
-            # convert symbol operators into valid ruby code
-            markup.gsub!(SYMBOL_OPERATORS_REGEXP, ':"\1" =>')
+            parse_attributes(markup) { |value| parse_attribute(value) }
 
-            super(name, markup, options)
+            if attributes.empty?
+              raise ::Liquid::SyntaxError.new("Syntax Error in 'with_scope' - Valid syntax: with_scope <name_1>: <value_1>, ..., <name_n>: <value_n>")
+            end
           end
 
-          def display(options = {}, &block)
-            current_context.stack do
-              current_context['with_scope'] = self.decode(options)
-              current_context['with_scope_content_type'] = false # for now, no content type is assigned to this with_scope
-              yield
+          def render(context)
+            context.stack do
+              context['with_scope'] = self.evaluate_attributes(context)
+
+              # for now, no content type is assigned to this with_scope
+              context['with_scope_content_type'] = false
+
+              super
             end
           end
 
           protected
 
-          def decode(options)
+          def parse_attribute(value)
+            case value
+            when RegexpFragment
+              # let the cast_value attribute create the Regexp (done during the rendering phase)
+              value
+            when ArrayFragment
+              $1.split(',').map { |_value| parse_attribute(_value) }
+            else
+              ::Liquid::Expression.parse(value)
+            end
+          end
+
+          def evaluate_attributes(context)
             HashWithIndifferentAccess.new.tap do |hash|
-              options.each do |key, value|
+              attributes.each do |key, value|
                 # _slug instead of _permalink
                 _key = key.to_s == '_permalink' ? '_slug' : key.to_s
 
-                hash[_key] = cast_value(value)
+                # evaluate the value if possible before casting it
+                _value = value.is_a?(::Liquid::VariableLookup) ? context.evaluate(value) : value
+
+                hash[_key] = cast_value(context, _value)
               end
             end
           end
 
-          def cast_value(value)
+          def cast_value(context, value)
             case value
-            when Array then value.map { |_value| cast_value(_value) }
-            when /^\/([^\/]*)\/([imx]+)?$/
-              _value, options_str = $1, $2
-              options = options_str.blank? ? nil : options_str.split('').uniq.inject(0) do |_options, letter|
-                _options |= REGEX_OPTIONS[letter]
-              end
-              Regexp.new(_value, options)
+            when Array          then value.map { |_value| cast_value(context, _value) }
+            when RegexpFragment then create_regexp($1, $2)
             else
-              value.respond_to?(:_id) ? value.send(:_source) : value
+              _value = context.evaluate(value)
+              _value.respond_to?(:_id) ? _value.send(:_source) : _value
             end
           end
 
+          def create_regexp(value, unparsed_options)
+            options = unparsed_options.blank? ? nil : unparsed_options.split('').uniq.inject(0) do |_options, letter|
+              _options |= REGEX_OPTIONS[letter]
+            end
+            Regexp.new(value, options)
+          end
+
+          def tag_attributes_regexp
+            TagAttributes
+          end
+
         end
 
+        ::Liquid::Template.register_tag('with_scope'.freeze, WithScope)
+
       end
     end
   end

data/lib/locomotive/steam/liquid.rb

@@ -1,10 +1,12 @@
-require 'solid'
+require 'liquid'
 
 require_relative 'liquid/errors'
 require_relative 'liquid/patches'
+require_relative 'liquid/file_system'
 require_relative 'liquid/drops/base'
 require_relative 'liquid/drops/i18n_base'
 require_relative 'liquid/tags/hybrid'
 require_relative 'liquid/tags/concerns/section'
+require_relative 'liquid/tags/concerns/attributes'
 require_relative 'liquid/tags/section'
 require_relative_all %w(. drops filters tags/concerns tags), 'liquid'

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

@@ -0,0 +1,117 @@
+module Locomotive::Steam
+  module Middlewares
+
+    class Cache < ThreadSafe
+
+      include Concerns::Helpers
+
+      CACHEABLE_RESPONSE_CODES  = [200, 301, 404, 410].freeze
+
+      CACHEABLE_REQUEST_METHODS = %w(GET HEAD).freeze
+
+      DEFAULT_CACHE_CONTROL     = 'max-age=0, s-maxage=3600, public, must-revalidate'.freeze
+
+      DEFAULT_CACHE_VARY        = 'Accept-Language'.freeze
+
+      NO_CACHE_CONTROL          = 'max-age=0, private, must-revalidate'.freeze
+
+      def _call
+        if cacheable?
+          key = cache_key
+
+          # TODO: only for debugging
+          # log("HTTP keys: #{env.select { |key, _| key.starts_with?('HTTP_') }}".light_blue)
+
+          # Test if the ETag or Last Modified has been modified. If not, return a 304 response
+          if stale?(key)
+            render_response(nil, 304, nil)
+            return
+          end
+
+          # we have to tell the CDN (or any proxy) what the expiration & validation strategy are
+          env['steam.cache_control']        = cache_control
+          env['steam.cache_vary']           = cache_vary
+          env['steam.cache_etag']           = key
+          env['steam.cache_last_modified']  = site.last_modified_at.httpdate
+
+          # retrieve the response from the cache.
+          # This is useful if no CDN is being used.
+          code, headers, _ = response = fetch_cached_response(key)
+
+          unless CACHEABLE_RESPONSE_CODES.include?(code.to_i)
+            env['steam.cache_control'] = headers['Cache-Control'] = NO_CACHE_CONTROL
+            env['steam.cache_vary'] = headers['Vary'] = nil
+          end
+
+          # we don't want to render twice the page
+          @next_response = response
+        else
+          env['steam.cache_control']  = NO_CACHE_CONTROL
+        end
+      end
+
+      private
+
+      def fetch_cached_response(key)
+        log("Cache key = #{key.inspect}")
+        if marshaled = cache.read(key)
+          log('Cache HIT')
+          Marshal.load(marshaled)
+        else
+          log('Cache MISS')
+          self.next.tap do |response|
+            # cache the HTML for further validations (+ optimization)
+            cache.write(key, marshal(response))
+          end
+        end
+      end
+
+      def cacheable?
+        CACHEABLE_REQUEST_METHODS.include?(env['REQUEST_METHOD']) &&
+        !live_editing? &&
+        site.try(:cache_enabled) &&
+        page.try(:cache_enabled) &&
+        is_redirect_url?
+      end
+
+      def cache_key
+        site, path, query = env['steam.site'], env['PATH_INFO'], env['QUERY_STRING']
+        key = "#{Locomotive::Steam::VERSION}/site/#{site._id}/#{site.last_modified_at.to_i}/page/#{path}/#{query}"
+        Digest::MD5.hexdigest(key)
+      end
+
+      def cache_control
+        page.try(:cache_control).presence || site.try(:cache_control).presence || DEFAULT_CACHE_CONTROL
+      end
+
+      def cache_vary
+        page.try(:cache_vary).presence || site.try(:cache_vary).presence || DEFAULT_CACHE_VARY
+      end
+
+      def is_redirect_url?
+        return false if page.nil?
+        page.try(:redirect_url).blank?
+      end
+
+      def marshal(response)
+        code, headers, body = response
+
+        # only keep string value headers
+        _headers = headers.reject { |key, val| !val.respond_to?(:to_str) }
+
+        Marshal.dump([code, _headers, body])
+      end
+
+      def stale?(key)
+        env['HTTP_IF_NONE_MATCH'] == key ||
+        env['HTTP_IF_MODIFIED_SINCE'] == site.last_modified_at.httpdate
+      end
+
+      def cache
+        services.cache
+      end
+
+    end
+
+  end
+end

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

@@ -3,8 +3,19 @@ module Locomotive::Steam
     module Concerns
       module Helpers
 
+        HTML_CONTENT_TYPE = 'text/html'.freeze
+
+        HTML_MIME_TYPES   = [nil, 'text/html', 'application/x-www-form-urlencoded', 'multipart/form-data'].freeze
+
+        CACHE_HEADERS     = {
+          'steam.cache_control'       => 'Cache-Control',
+          'steam.cache_vary'          => 'Vary',
+          'steam.cache_etag'          => 'ETag',
+          'steam.cache_last_modified' => 'Last-Modified'
+        }.freeze
+
         def html?
-          [nil, 'text/html', 'application/x-www-form-urlencoded', 'multipart/form-data'].include?(self.request.media_type) &&
+          HTML_MIME_TYPES.include?(self.request.media_type) &&
           !self.request.xhr? &&
           !self.json?
         end
@@ -14,13 +25,16 @@ module Locomotive::Steam
         end
 
         def render_response(content, code = 200, type = nil)
+          base_headers = { 'Content-Type' => type || HTML_CONTENT_TYPE }
+
+          CACHE_HEADERS.each do |key, http_name|
+            base_headers[http_name] = env[key] if env[key]
+          end
+
           _headers = env['steam.headers'] || {}
           inject_cookies(_headers)
-          @next_response = [
-            code,
-            { 'Content-Type' => type || 'text/html' }.merge(_headers),
-            [content]
-          ]
+
+          @next_response = [code, base_headers.merge(_headers), [content]]
         end
 
         def redirect_to(location, type = 301)
@@ -28,7 +42,7 @@ module Locomotive::Steam
 
           self.log "Redirected to #{_location}".blue
 
-          headers = { 'Content-Type' => 'text/html', 'Location' => _location }
+          headers = { 'Content-Type' => HTML_CONTENT_TYPE, 'Location' => _location }
           inject_cookies(headers)
 
           @next_response = [type, headers, []]
@@ -45,7 +59,7 @@ module Locomotive::Steam
           path ||= env['steam.path']
 
           segments = path.split('/')
-          yield(segments)
+          yield(segments) if block_given?
           path = segments.join('/')
 
           path = '/' if path.blank?

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

@@ -21,7 +21,11 @@ module Locomotive::Steam
             live_editing:   live_editing?,
             params:         params,
             session:        request.session,
-            cookies:        request.cookies
+            cookies:        request.cookies,
+            file_system:    Locomotive::Steam::Liquid::FileSystem.new(
+              section_finder: services.section_finder,
+              snippet_finder: services.snippet_finder
+            )
           }.merge(env['steam.liquid_registers'])
         end
 

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

@@ -0,0 +1,53 @@
+module Locomotive::Steam
+  module Middlewares
+    module Concerns
+      module Rendering
+
+        extend ActiveSupport::Concern
+
+        included do
+          include Concerns::LiquidContext
+        end
+
+        private
+
+        def render_page
+          content = parse_and_render_liquid
+
+          # for a better SEO score, it's better to use a CDN host including
+          # the main domain name.
+          content = replace_asset_host(content) if site.asset_host.present?
+
+          render_response(content, page.not_found? ? 404 : 200, page.response_type)
+        end
+
+        def render_missing_404
+          message = (if locale != default_locale
+            "Your 404 page is missing in the #{locale} locale."
+          else
+            "Your 404 page is missing."
+          end) + " Please create it."
+
+          log "[Warning] #{message}".red
+
+          render_response(message, 404)
+        end
+
+        def parse_and_render_liquid
+          document = services.liquid_parser.parse(page)
+          begin
+            document.render(liquid_context)
+          rescue Locomotive::Steam::TemplateError => e
+            e.template_name = page.template_path if e.template_name.blank?
+            raise e
+          end
+        end
+
+        def replace_asset_host(content)
+          content.gsub(ASSET_URL_REGEXP, "\\1#{site.asset_host}/\\3\/\\4\\5")
+        end
+
+      end
+    end
+  end
+end

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

@@ -14,6 +14,10 @@ module Locomotive::Steam
 
       def _call
         if params[:impersonating] == 'stop'
+
+          # notify sign out
+          services.auth.notify(:signed_out, request.env['steam.authenticated_entry'], request)
+
           # sign out the current user
           store_authenticated(nil)
 

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

@@ -35,7 +35,7 @@ module Locomotive::Steam
       def extract_locale
         # 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 = if is_index_page? && !site.bypass_browser_locale
           locale_from_params || locale_from_cookie || locale_from_header
         else
           locale_from_path || locale_from_params
@@ -87,7 +87,7 @@ module Locomotive::Steam
       end
 
       def set_locale_cookie
-        services.cookie.set(cookie_key_name, {'value': locale, 'path': '/', 'max_age': 1.year})
+        services.cookie.set(cookie_key_name, { 'value': locale, 'path': '/', 'max_age': 1.year })
       end
 
       # The preview urls for all the sites share the same domain, so cookie[:locale]

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

@@ -25,7 +25,7 @@ module Locomotive::Steam
           if site.prefix_default_locale
             path_with_locale if locale_not_mentioned_in_path?
           else
-            env['steam.path'] if default_locale? && locale_mentioned_in_path?
+            modify_path(env['steam.path']) if default_locale? && locale_mentioned_in_path?
           end
         end
       end

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

@@ -28,6 +28,7 @@ module Locomotive::Steam
         when 200 then '200 OK'
         when 301 then '301 Found'
         when 302 then '302 Found'
+        when 304 then '304 Not Modified'
         when 404 then '404 Not Found'
         when 422 then '422 Unprocessable Entity'
         end

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

@@ -0,0 +1,37 @@
+module Locomotive::Steam
+  module Middlewares
+
+    # When rendering the page, the developer can stop it at anytime by
+    # raising an PageNotFoundException exception.
+    # Instead of the page, the 404 not found page will be rendered.
+    #
+    # This is particularly helpful with the dynamic routing feature
+    # to avoid duplicated page content (different urls, same HTTP 200 code but same blank page).
+    #
+    class PageNotFound < ThreadSafe
+
+      include Concerns::Helpers
+      include Concerns::Rendering
+
+      def _call
+        begin
+          self.next
+        rescue Locomotive::Steam::PageNotFoundException => e
+          # fetch the 404 error page...
+          env['steam.page'] = page_finder.find('404')
+
+          # ... and render it instead
+          render_page
+        end
+      end
+
+      private
+
+      def page_finder
+        services.page_finder
+      end
+
+    end
+  end
+
+end

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

@@ -14,7 +14,7 @@ module Locomotive::Steam
         begin
           self.next
         rescue Locomotive::Steam::RedirectionException => e
-          redirect_to e.url, 302
+          redirect_to e.url, e.permanent ? 301 : 302
         end
       end
 

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

@@ -4,11 +4,11 @@ module Locomotive::Steam
     class Renderer < ThreadSafe
 
       include Concerns::Helpers
-      include Concerns::LiquidContext
+      include Concerns::Rendering
 
       def _call
         if page
-          render_page
+          render_page_or_redirect
         else
           render_missing_404
         end
@@ -16,33 +16,11 @@ module Locomotive::Steam
 
       private
 
-      def render_page
+      def render_page_or_redirect
         if page.redirect?
           redirect_to(page.redirect_url, page.redirect_type)
         else
-          content = parse_and_render_liquid
-          render_response(content, page.not_found? ? 404 : 200, page.response_type)
-        end
-      end
-
-      def render_missing_404
-        message = (if locale != default_locale
-          "Your 404 page is missing in the #{locale} locale."
-        else
-          "Your 404 page is missing."
-        end) + " Please create it."
-
-        log "[Warning] #{message}".red
-        render_response(message, 404)
-      end
-
-      def parse_and_render_liquid
-        document = services.liquid_parser.parse(page)
-        begin
-          document.render(liquid_context)
-        rescue Locomotive::Steam::ParsingRenderingError => e
-          e.file = page.template_path if e.file.blank?
-          raise e
+          render_page
         end
       end
 

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

@@ -9,11 +9,7 @@ module Locomotive::Steam::Middlewares
       threadsafed = dup
       threadsafed.env = env
 
-      # time = Benchmark.realtime do
       threadsafed._call # thread-safe purpose
-      # end
-
-      # puts "[Benchmark][#{self.class.name}] Time elapsed #{time*1000} milliseconds"
 
       threadsafed.next
     end

data/lib/locomotive/steam/models/pager.rb

@@ -10,6 +10,7 @@ module Locomotive::Steam
       def initialize(source, page, per_page)
         @current_page, @per_page = page || 1, per_page || DEFAULT_PER_PAGE
 
+        @current_page   = 1 if @current_page < 1
         @total_entries  = source.count
         @total_pages    = (@total_entries.to_f / @per_page).ceil
 

data/lib/locomotive/steam/server.rb

@@ -63,11 +63,13 @@ module Locomotive::Steam
           Middlewares::Locale,
           Middlewares::LocaleRedirection,
           Middlewares::Redirection,
-          Middlewares::ImpersonatedEntry,
+          Middlewares::PageNotFound,
           Middlewares::Auth,
+          Middlewares::ImpersonatedEntry,
           Middlewares::PrivateAccess,
           Middlewares::Path,
           Middlewares::Page,
+          Middlewares::Cache,
           Middlewares::Section,
           Middlewares::Sitemap,
           Middlewares::TemplatizedPage

data/lib/locomotive/steam/services/action_service.rb

@@ -14,6 +14,7 @@ module Locomotive
       SERVICES = %w(content_entry api redirection cookie)
 
       BUILT_IN_FUNCTIONS = %w(
+        log
         getProp
         setProp
         getSessionProp
@@ -63,6 +64,10 @@ module Locomotive
         end
       end
 
+      def log_lambda(liquid_context)
+        -> (message) { Locomotive::Common::Logger.info(message) }
+      end
+
       def send_email_lambda(liquid_context)
         -> (options) { !!email.send_email(options, liquid_context) }
       end