locomotivecms_steam 1.5.0.rc0 → 1.5.0.rc1

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

@@ -18,19 +18,23 @@ module Locomotive
             end
           end
 
-          def find_block_delimiter?(tokens)
-            tokens.each do |token|
+          def find_block_delimiter?(tokenizer)
+            tokenizer.instance_variable_get(:@tokens).each do |token|
               next if token.empty?
               if token.start_with?(::Liquid::BlockBody::TAGSTART)
                 if token =~ ::Liquid::BlockBody::FullToken
-                  return false  if $1 == @tag_name
-                  return true   if $1 == block_delimiter
+                  return false  if Regexp.last_match(1) == @tag_name
+                  return true   if Regexp.last_match(1) == block_delimiter
                 end
               end
             end
             false
           end
 
+          def nodelist
+            @body&.nodelist || []
+          end
+
         end
 
       end

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

@@ -13,33 +13,111 @@ module Locomotive
         #   - short_name (Boolean): use just the name and skip the name of the nested blocks.
         #   - priority (Integer): allow blocks to be displayed before others
         #
-        class InheritedBlock < ::Liquid::InheritedBlock
+        class InheritedBlock < ::Liquid::Block
+
+          include Concerns::Attributes
+
+          SYNTAX = /(#{::Liquid::QuotedFragment}+)/o
+
+          attr_reader :name
+
+          # linked chain of inherited blocks included
+          # in different templates if multiple extends
+          attr_accessor :parent, :descendant
 
           def initialize(tag_name, markup, options)
             super
 
-            @attributes = { short_name: false, priority: 0, anchor: true }
-            markup.scan(::Liquid::TagAttributes) do |key, value|
-              @attributes[key.to_sym] = ::Liquid::Expression.parse(value)
+            if markup =~ SYNTAX
+              @name = Regexp.last_match(1).gsub(/["']/o, '').strip
+            else
+              raise ::Liquid::SyntaxError.new("Syntax Error in 'block' - Valid syntax: block <name>")
+            end
+
+            prepare_for_inheritance
+
+            parse_attributes(markup, short_name: false, priority: 0, anchor: true)
+          end
+
+          def prepare_for_inheritance
+            # give a different name if this is a nested block
+            if (block = inherited_blocks[:nested].last)
+              @name = "#{block.name}/#{@name}"
+            end
+
+            # append this block to the stack in order to
+            # get a name for the other nested inherited blocks
+            inherited_blocks[:nested].push(self)
+
+            # build the linked chain of inherited blocks
+            # make a link with the descendant and the parent (chained list)
+            if (descendant = inherited_blocks[:all][@name])
+              self.descendant   = descendant
+              descendant.parent = self
+
+              # get the value of the blank property from the descendant
+              @blank = descendant.blank?
             end
+
+            # become the descendant of the inherited block from the parent template
+            inherited_blocks[:all][@name] = self
           end
 
           def parse(tokens)
-            super.tap do
+            super
+
+            # when the parsing of the block is done, we can then remove it from the stack
+            inherited_blocks[:nested].pop.tap do
               ActiveSupport::Notifications.instrument('steam.parse.inherited_block', {
-                page: options[:page],
-                name: @name,
+                page: parse_context[:page],
+                name: name,
                 found_super: self.contains_super?(nodelist)
-              }.merge(@attributes))
+              }.merge(attributes))
             end
           end
 
+          alias_method :render_without_inheritance, :render
+
           def render(context)
-            (if live_editing?(context) && (@attributes[:anchor] || @attributes[:anchor].nil?)
-              %{<span class="locomotive-block-anchor" data-element-id="#{@name}" style="visibility: hidden"></span>}
+            context.stack do
+              # look for the very first descendant
+              block = self_or_first_descendant
+
+              # the block drop is in charge of rendering "{{ block.super }}"
+              context['block'] = Drops::InheritedBlock.new(block)
+
+              anchor_html = if live_editing?(context) && (attributes[:anchor] || attributes[:anchor].nil?)
+                %{<span class="locomotive-block-anchor" data-element-id="#{name}" style="visibility: hidden"></span>}
+              else
+                ''
+              end
+
+              anchor_html + block.render_without_inheritance(context)
+            end
+          end
+
+          # when we render an inherited block, we need the version of the
+          # very first descendant.
+          def self_or_first_descendant
+            block = self
+            while block.descendant; block = block.descendant; end
+            block
+          end
+
+          def call_super(context)
+            if parent
+              # remove the block from the linked chain
+              parent.descendant = nil
+
+              parent.render(context)
             else
               ''
-            end) + super
+            end
+          end
+
+          def inherited_blocks
+            # initialize it in the case the template does not include an extend tag
+            options[:inherited_blocks] ||= { all: {}, nested: [] }
           end
 
           protected
@@ -71,10 +149,9 @@ module Locomotive
           def live_editing?(context)
             !!context.registers[:live_editing]
           end
-
         end
 
-        ::Liquid::Template.register_tag('block'.freeze, InheritedBlock)
+        ::Liquid::Template.register_tag('block', InheritedBlock)
       end
     end
   end

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

@@ -8,17 +8,17 @@ module Locomotive
         #
         # @deprecated
         #
-        class InlineEditor < Solid::Tag
+        class InlineEditor < ::Liquid::Tag
 
-          tag_name :inline_editor
-
-          def display
+          def render(context)
             Locomotive::Common::Logger.warn %(The inline_editor liquid tag is no more used.).yellow
             ''
           end
 
         end
 
+        ::Liquid::Template.register_tag('inline_editor'.freeze, InlineEditor)
+
       end
     end
   end

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

@@ -4,6 +4,7 @@ module Locomotive
       module Tags
         class LinkTo < Hybrid
 
+          include Concerns::Attributes
           include Concerns::I18nPage
           include Concerns::Path
 
@@ -40,7 +41,7 @@ module Locomotive
           end
 
           def css
-            @path_options[:class]
+            attributes[:class]
           end
 
         end

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

@@ -20,14 +20,24 @@ module Locomotive
         #   - " | " is the default separating code
         #
 
-        class LocaleSwitcher < Solid::Tag
+        class LocaleSwitcher < ::Liquid::Tag
 
+          include Concerns::Attributes
           include Concerns::I18nPage
 
-          tag_name :locale_switcher
+          attr_reader :attributes, :site, :page, :current_locale, :url_builder
+
+          def initialize(tag_name, markup, options)
+            super
+
+            parse_attributes(markup, label: 'iso', sep: ' | ')
+          end
+
+          def render(context)
+            evaluate_attributes(context)
+
+            set_vars_from_context(context)
 
-          def display(*values)
-            @options = { label: 'iso', sep: ' | ' }.merge(values.first || {})
             %{<div id="locale-switcher">#{build_site_locales}</div>}
           end
 
@@ -41,12 +51,12 @@ module Locomotive
 
                 %(<a href="#{path}" class="#{css}">#{link_label(locale)}</a>)
               end
-            end.join(@options[:sep])
+            end.join(attributes[:sep])
           end
 
           def link_class(locale)
             css = [locale]
-            css << 'current' if locale.to_sym == current_locale.to_sym
+            css << 'current' if locale.to_sym == current_locale
             css.join(' ')
           end
 
@@ -55,7 +65,7 @@ module Locomotive
           end
 
           def link_label(locale)
-            case @options[:label]
+            case attributes[:label]
             when 'locale' then I18n.t("locomotive.locales.#{locale}")
             when 'title' then page_title
             else
@@ -71,24 +81,18 @@ module Locomotive
             end
           end
 
-          def site
-            @site ||= current_context.registers[:site]
-          end
-
-          def page
-            @page ||= current_context['page']
-          end
-
-          def url_builder
-            current_context.registers[:services].url_builder
-          end
-
-          def current_locale
-            @current_locale ||= current_context.registers[:locale]
+          def set_vars_from_context(context)
+            @context        = context
+            @site           = context.registers[:site]
+            @page           = context['page']
+            @current_locale = context.registers[:locale].to_sym
+            @url_builder    = context.registers[:services].url_builder
           end
 
         end
 
+        ::Liquid::Template.register_tag('locale_switcher'.freeze, LocaleSwitcher)
+
       end
     end
   end

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

@@ -16,27 +16,46 @@ module Locomotive
         #
         # {% model_form 'newsletter_addresses', class: 'a-css-class', success: 'http://www.google.fr', error: '/error' %}...{% endform_form %}
         #
-        class ModelForm < Solid::Block
+        class ModelForm < ::Liquid::Block
 
-          tag_name :model_form
+          include Concerns::Attributes
 
-          def display(*options, &block)
-            name    = options.shift
-            options = options.shift || {}
+          Syntax = /(#{::Liquid::QuotedFragment})\s*,*(.*)?/o.freeze
 
-            form_attributes = prepare_form_attributes(options)
+          attr_reader :name
 
-            html_content_tag :form,
-              content_type_html(name) + csrf_html + callbacks_html(options) + recaptcha_html(options) + yield,
+          def initialize(tag_name, markup, options)
+            super
+
+            if markup =~ Syntax
+              @name, _attributes = $1, $2
+
+              parse_attributes(_attributes)
+            else
+              raise ::Liquid::SyntaxError.new("Syntax Error in 'model_form' - Valid syntax: model_form <content_type_slug>(, <attributes>)")
+            end
+          end
+
+          def render(context)
+            @name = context[name]
+
+            evaluate_attributes(context)
+
+            form_attributes = prepare_form_attributes(context, attributes)
+
+            html_content_tag(
+              :form,
+              content_type_html(name) + csrf_html(context) + callbacks_html(attributes) + recaptcha_html(attributes) + super,
               form_attributes
+            )
           end
 
           def content_type_html(name)
             html_tag :input, type: 'hidden', name: 'content_type_slug', value: name
           end
 
-          def csrf_html
-            service = current_context.registers[:services].csrf_protection
+          def csrf_html(context)
+            service = context.registers[:services].csrf_protection
 
             html_tag :input, type: 'hidden', name: service.field, value: service.token
           end
@@ -70,8 +89,8 @@ module Locomotive
             (options.stringify_keys.to_a.collect { |a, b| "#{a}=\"#{b}\"" }).join(' ')
           end
 
-          def prepare_form_attributes(options)
-            url         = action_url(options)
+          def prepare_form_attributes(context, options)
+            url         = action_url(context, options)
             attributes  = options.slice(:id, :class, :name, :novalidate)
 
             { method: 'POST', enctype: 'multipart/form-data' }.merge(attributes).tap do |_attributes|
@@ -79,28 +98,30 @@ module Locomotive
             end
           end
 
-          def action_url(options)
+          def action_url(context, options)
             url = options[:action]
 
             if url.blank?
               if options[:json]
-                url = current_context['path'].blank? ? '/' : current_context['path']
+                url = context['path'].blank? ? '/' : context['path']
                 url + (url.ends_with?('/') ? 'index.json' : '.json')
               else
                 nil
               end
             else
               url = '/' + url unless url.starts_with?('/')
-              url_builder.prefix(url)
+              url_builder(context).prefix(url)
             end
           end
 
-          def url_builder
-            current_context.registers[:services].url_builder
+          def url_builder(context)
+            context.registers[:services].url_builder
           end
 
         end
 
+        ::Liquid::Template.register_tag('model_form'.freeze, ModelForm)
+
       end
     end
   end

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

@@ -34,14 +34,14 @@ module Locomotive
             set_template_if_asked
 
             # get all the children of a source: site (index page), parent or page.
-            pages   = children_of(fetch_starting_page)
-            output  = self.build_entries_output(pages, context)
+            pages     = children_of(fetch_starting_page)
+            _output   = self.build_entries_output(pages, context)
 
             if self.no_wrapper?
-              output
+             _output
             else
               self.render_tag(:nav, id: @_options[:id], css: @_options[:class]) do
-                self.render_tag(:ul) { output }
+                self.render_tag(:ul) { _output }
               end
             end
           end

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

@@ -0,0 +1,19 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+
+        class PageNotFound < ::Liquid::Tag
+
+          def render(context)
+            raise Locomotive::Steam::PageNotFoundException.new
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('render_page_not_found'.freeze, PageNotFound)
+
+      end
+    end
+  end
+end

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

@@ -15,14 +15,18 @@ module Locomotive
         #
         class Paginate < ::Liquid::Block
 
+          include Concerns::Attributes
+
           Syntax = /(#{::Liquid::QuotedFragment}+)\s+by\s+(#{::Liquid::QuotedFragment}+)/o
 
+          attr_reader :collection_name, :per_page
+
           def initialize(tag_name, markup, options)
             if markup =~ Syntax
               @collection_name  = $1
               @per_page         = $2
-              @paginate_options = {}
-              markup.scan(::Liquid::TagAttributes) { |key, value| @paginate_options[key.to_sym] = value.gsub(/^'/, '').gsub(/'$/, '') }
+
+              parse_attributes(markup)
             else
               raise ::Liquid::SyntaxError.new('Valid syntax: paginate <collection> by <number>')
             end
@@ -31,6 +35,8 @@ module Locomotive
           end
 
           def render(context)
+            evaluate_attributes(context)
+
             context.stack do
               pagination = context['paginate'] = paginate_collection(context)
 
@@ -53,11 +59,11 @@ module Locomotive
           # collection.
           #
           def paginate_collection(context)
-            collection    = context[@collection_name]
-            per_page      = context[@per_page].to_i
+            collection    = context[collection_name]
+            per_page      = context[self.per_page].to_i
             current_page  = context['current_page'].try(:to_i)
 
-            raise ::Liquid::ArgumentError.new("Cannot paginate '#{@collection_name}'. Not found.") if collection.nil?
+            raise ::Liquid::ArgumentError.new("Cannot paginate '#{collection_name}'. Not found.") if collection.nil?
 
             pager = Locomotive::Steam::Models::Pager.new(collection, current_page, per_page)
 
@@ -117,7 +123,7 @@ module Locomotive
           end
 
           def window_size
-            @window_size ||= @paginate_options[:window_size] ? @paginate_options[:window_size].to_i : 3
+            @window_size ||= attributes[:window_size] ? attributes[:window_size].to_i : 3
           end
 
           def no_link(title)
@@ -126,7 +132,7 @@ module Locomotive
 
           def link(title, page, path)
             _path = %(#{path}#{path.include?('?') ? '&' : '?'}page=#{page})
-            { 'title' => title, 'url' => _path, 'is_link' => true }
+            { 'title' => title, 'url' => _path, 'is_link' => true, 'page' => page }
           end
         end
 

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

@@ -4,6 +4,7 @@ module Locomotive
       module Tags
         class PathTo < ::Liquid::Tag
 
+          include Concerns::Attributes
           include Concerns::I18nPage
           include Concerns::Path
 

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

@@ -0,0 +1,34 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+
+        class RedirectTo < ::Liquid::Tag
+
+          include Concerns::Attributes
+          include Concerns::I18nPage
+          include Concerns::Path
+
+          def render(context)
+            if (path = render_path(context)).present?
+              # 301 or 302 redirection
+              is_permanent = attributes[:permanent].nil? ? true : attributes[:permanent]
+
+              # break the rendering process
+              raise Locomotive::Steam::RedirectionException.new(path, permanent: is_permanent)
+            end
+            ''
+          end
+
+          def wrong_syntax!
+            raise SyntaxError.new("Valid syntax: redirect_to <page|page_handle|content_entry|external_url>(, locale: [fr|de|...], with: <page_handle>, permanent: [true|false]")
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('redirect_to'.freeze, RedirectTo)
+
+      end
+    end
+  end
+end

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

@@ -5,38 +5,43 @@ module Locomotive
         class Section < ::Liquid::Include
 
           include Concerns::Section
+          include Concerns::Attributes
+
+          Syntax = /(#{::Liquid::QuotedString}|#{::Liquid::VariableSignature}+)\s*,*(.*)?/o.freeze
+
+          attr_reader :section_type
 
           def initialize(tag_name, markup, options)
-            if markup =~ /(#{::Liquid::QuotedString}|#{::Liquid::VariableSignature}+)\s*,*(.*)?/o
-              @section_type, _options = $1, $2
-              raw_options       = parse_options_from_string(_options)
-              @section_options  = interpolate_options(raw_options, {})
-              super
-            else
-              raise ::Liquid::SyntaxError.new("Syntax Error in 'section' - Valid syntax: section section_type, id: '<string>', placement: 'top|bottom' (id and placement are optional)")
+            super
+
+            if markup =~ Syntax
+              @section_type, _attributes = $1, $2
+              @template_name_expr = @section_type.gsub!(/['"]/, '')
+
+              parse_attributes(_attributes)
             end
           end
 
           def parse(tokens)
-            notify_on_parsing(evaluate_section_name,
-              id:         "page-#{@section_options[:id] || evaluate_section_name}",
-              key:        (@section_options[:id] || evaluate_section_name).to_s,
-              label:      @section_options[:label],
-              placement:  @section_options[:placement]&.to_sym
+            notify_on_parsing(section_type,
+              id:         "page-#{attributes[:id] || section_type}",
+              key:        (attributes[:id] || section_type).to_s,
+              label:      attributes[:label],
+              placement:  attributes[:placement]&.to_sym
             )
           end
 
           def render(context)
-            # @options doesn't include the page key if cache is on
-            @options[:page] = context.registers[:page]
+            evaluate_attributes(context)
+
+            # the context (parsing) doesn't include the page key if cache is on
+            parse_context[:page] = context.registers[:page]
 
-            # get the type/slug of the section
-            # @section_options  = interpolate_options(@raw_section_options, context)
-            @section_type     = evaluate_section_name(context)
-            @template_name    = "sections-#{@section_type}"
+            # use the Liquid filesystem to get the template of the section
+            template = parse_template(section_type, context)
 
-            section   = find_section(context)
-            template  = load_cached_partial(context)
+            # fetch the section definition
+            section = find_section(context)
 
             # if the tag is called by the Section middleware, use the content
             # from the request.
@@ -54,28 +59,24 @@ module Locomotive
           private
 
           def set_section_dom_id(context)
-            context['section_id'] = "page-#{@section_options[:id] || @section_type}"
-          end
-
-          def read_template_from_file_system(context)
-            section = find_section(context)
-            raise SectionNotFound.new("Section with slug '#{@section_type}' was not found") if section.nil?
-            section.liquid_source
+            context['section_id'] = "page-#{attributes[:id] || section_type}"
           end
 
           def find_section(context)
-            context.registers[:services].section_finder.find(@section_type)
+            context.registers[:services].section_finder.find(section_type)
           end
 
           def find_section_content(context)
-            section_id = @section_options[:id].presence || @section_type
+            section_id = attributes[:id].presence || section_type
             context['page']&.sections_content&.fetch(section_id, nil)
           end
 
-          def evaluate_section_name(context = nil)
-            context.try(:evaluate, @template_name) ||
-            (!@template_name.is_a?(String) && @template_name.send(:state).first) ||
-            @template_name
+          def parse_template(section_type, context)
+            ::Liquid::PartialCache.load(
+              "sections--#{section_type}",
+              context:        context,
+              parse_context:  parse_context
+            )
           end
 
         end

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

@@ -42,7 +42,7 @@ module Locomotive
 
           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)
+            ::Liquid::Template.parse(section.liquid_source, parse_context)
           end
 
         end

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

@@ -7,10 +7,8 @@ module Locomotive
           class Base < ::Liquid::Tag
 
             def render(context)
-              %{
-                #{self.render_title(context)}
-                #{self.render_metadata(context)}
-              }
+              self.render_title(context) +
+              self.render_metadata(context)
             end
 
             protected

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

@@ -12,6 +12,7 @@ module Locomotive
         #   {{ session.foo }}
         #
         class SessionAssign < ::Liquid::Tag
+
           Syntax = /(#{::Liquid::VariableSignature}+)\s*=\s*(#{::Liquid::QuotedFragment}+)/o
 
           def initialize(tag_name, markup, options)