locomotivecms_steam 1.5.0.rc0 → 1.5.0.rc1

data/lib/locomotive/steam/liquid/tags/concerns/path.rb

@@ -5,29 +5,33 @@ module Locomotive
         module Concerns
           module Path
 
-            Syntax = /(#{::Liquid::VariableSignature}+)(\s*,.+)?/o
+            Syntax = /(#{::Liquid::QuotedFragment}+)(\s*,.+)?/o
+
+            attr_reader :handle
 
             def initialize(tag_name, markup, options)
-              if markup =~ Syntax
-                @handle, _options = $1, $2
+              super
 
-                # FIXME: the with option needs a string with quotes.
-                # this is a hack for sites which don't follow the new syntax.
-                make_options_compatible_with_previous_version(_options)
+              if markup =~ Syntax
+                @handle, _attributes = $1, $2
 
-                @raw_path_options = parse_options_from_string(_options)
+                parse_attributes(_attributes)
               else
                 self.wrong_syntax!
               end
-
-              super
             end
 
             def render_path(context, &block)
+              evaluate_attributes(context)
+
               set_vars_from_context(context)
 
-              # return a drop or model?
-              if page = self.retrieve_page_drop_from_handle
+              handle = @context[@handle] || @handle
+
+              # is external url?
+              if handle =~ Locomotive::Steam::IsHTTP
+                handle
+              elsif page = self.retrieve_page_drop_from_handle(handle) # return a drop or model?
                 # make sure we've got the page/content entry (if templatized)
                 # in the right locale
                 change_page_locale(locale, page) do
@@ -50,9 +54,7 @@ module Locomotive
               services.repositories.page
             end
 
-            def retrieve_page_drop_from_handle
-              handle = @context[@handle] || @handle
-
+            def retrieve_page_drop_from_handle(handle)
               case handle
               when String
                 _retrieve_page_drop_from(handle)
@@ -84,34 +86,19 @@ module Locomotive
             end
 
             def locale
-              @path_options[:locale] || @raw_locale || @locale
+              attributes[:locale] || raw_attributes[:locale] || @locale
             end
 
             def template_slug
-              @path_options[:with] || @raw_with
+              attributes[:with] || raw_attributes[:with]
             end
 
             def set_vars_from_context(context)
               @context      = context
-              @path_options = evaluate_path_options(context)
               @site         = context.registers[:site]
               @locale       = context.registers[:locale]
             end
 
-            def evaluate_path_options(context)
-              interpolate_options(@raw_path_options, context)
-            end
-
-            def make_options_compatible_with_previous_version(options)
-              if options
-                %w(with locale).each do |name|
-                  if options =~ /#{name}: ([\w-]+)/
-                    instance_variable_set(:"@raw_#{name}", $1);
-                  end
-                end
-              end
-            end
-
           end
         end
       end

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

@@ -17,8 +17,8 @@ module Locomotive::Steam::Liquid::Tags::Concerns
 
         begin
           _render(context, template)
-        rescue Locomotive::Steam::ParsingRenderingError => e
-          e.file = section.name + ' [Section]'
+        rescue Locomotive::Steam::TemplateError => e
+          e.template_name = "sections--#{section.name}"
           raise e
         end
       end
@@ -29,14 +29,25 @@ module Locomotive::Steam::Liquid::Tags::Concerns
         editor_settings_lookup(template.root)
       end
 
-      html        = template.render(context)
+      html = template.render(context)
+
+      # by default, Steam will wrap the section HTML to make sure it has all the
+      # DOM attributes the live editing editor needs.
+      if context['is_section_locomotive_attributes_displayed']
+        html
+      else
+        wrap_html(html, context)
+      end
+    end
+
+    def wrap_html(html, context)
       section     = context['section']
       css_class   = context['section_css_class']
 
       # we need the section_css_class once
-      context.scopes.last.delete('section_css_class')
+      # context.scopes.last.delete('section_css_class')
 
-      anchor_id = %(id="#{section.anchor}-section")
+      anchor_id = %(id="#{section.anchor_id}")
       tag_id    = %(id="locomotive-section-#{section.id}")
       tag_class = %(class="#{['locomotive-section', section.css_class, css_class].compact.join(' ')}")
       tag_data  = %(data-locomotive-section-type="#{section.type}")
@@ -49,13 +60,13 @@ module Locomotive::Steam::Liquid::Tags::Concerns
     # - once found, get the closest tag
     # - add custom data attributes to it
     def editor_settings_lookup(root)
+      return if root.nodelist.blank?
+
       previous_node = nil
       new_nodelist  = []
 
-      return if root.nodelist.blank?
-
       root.nodelist.each_with_index do |node, index|
-        if node.is_a?(::Liquid::Variable) && previous_node.is_a?(::Liquid::Token)
+        if node.is_a?(::Liquid::Variable) && previous_node.is_a?(String)
           matches = node.raw.match(Locomotive::Steam::SECTIONS_SETTINGS_VARIABLE_REGEXP)
 
           # is a section setting variable?
@@ -66,11 +77,11 @@ module Locomotive::Steam::Liquid::Tags::Concerns
             # here we go, add a liquid variable!
             new_nodelist.push(::Liquid::Variable.new(
               "section.editor_setting_data.#{matches[:id]}",
-              node.instance_variable_get(:@options))
+              node.parse_context)
             )
 
             # close the tag
-            new_nodelist.push(::Liquid::Token.new('>', previous_node.line_number))
+            new_nodelist.push('>') #::Liquid::Tokenizer.new('>', previous_node.line_number))
           end
         elsif node.respond_to?(:nodelist)
           editor_settings_lookup(node)
@@ -90,7 +101,7 @@ module Locomotive::Steam::Liquid::Tags::Concerns
       previous_node = nodelist[index - 1]
       next_node     = nodelist[index + 1]
 
-      return false unless next_node.is_a?(::Liquid::Token)
+      return false unless next_node.is_a?(String)
 
       (previous_node =~ /\>\s*\z/).present? && (next_node =~ /\A\s*\</).present?
     end

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

@@ -15,68 +15,61 @@ module Locomotive
         #
         class Consume < ::Liquid::Block
 
-          Syntax = /(#{::Liquid::VariableSignature}+)\s*from\s*(#{::Liquid::QuotedString}|#{::Liquid::VariableSignature}+)(.*)?/o
+          include Concerns::Attributes
+
+          Syntax = /(#{::Liquid::VariableSignature}+)\s*from\s*(#{::Liquid::QuotedFragment}+),?(.+)?/o.freeze
+
+          attr_reader :variable_name, :url, :expires_in
 
           def initialize(tag_name, markup, options)
+            super
+
             if markup =~ Syntax
-              @name = $1.to_s
+              @variable_name, @url, attributes = $1.to_s, ::Liquid::Expression.parse($2), $3
 
-              self.prepare_url($2)
-              @default_api_options = parse_options_from_string($3)
+              parse_attributes(attributes)
             else
               raise ::Liquid::SyntaxError.new("Syntax Error in 'consume' - Valid syntax: consume <var> from \"<url>\" [username: value, password: value]")
             end
-
-            super
           end
 
           def render(context)
-            self.set_api_options(context)
+            evaluate_attributes(context)
 
-            if instance_variable_defined?(:@variable_name)
-              @url = context[@variable_name]
-            end
+            # attributes will become the options which will be passed to the service.
+            # we don't want the expires_in option to be part of it.
+            @expires_in = attributes.delete(:expires_in)&.to_i
 
-            if @url.blank?
+            # the URL can come from a variable
+            @url = context.evaluate(url)
+
+            if url.blank?
               Locomotive::Common::Logger.error "A consume tag can't call an empty URL."
               ''
             else
-              render_all_and_cache_it(context)
+              render_all_and_cache_it(context) { |_context| super(_context) }
             end
           end
 
           protected
 
-          def prepare_url(token)
-            if token.match(::Liquid::QuotedString)
-              @url = token.gsub(/['"]/, '')
-            else
-              @variable_name = token
-            end
-          end
-
-          def set_api_options(context)
-            @api_options  = interpolate_options(@default_api_options, context)
-            @expires_in   = @api_options.delete(:expires_in).try(:to_i)
-          end
-
-          def render_all_and_cache_it(context)
+          def render_all_and_cache_it(context, &block)
             cache_service(context).fetch(page_fragment_cache_key, cache_options) do
-              self.render_all_without_cache(context)
+              self.render_all_without_cache(context, &block)
             end
           end
 
           def render_all_without_cache(context)
             context.stack do
               begin
-                Locomotive::Common::Logger.info "[consume] #{@url.inspect} / #{@api_options.inspect}"
+                Locomotive::Common::Logger.info "[consume] #{url.inspect} / #{attributes.inspect}"
 
-                context.scopes.last[@name] = service(context).consume(@url, @api_options)
+                context.scopes.last[variable_name] = service(context).consume(url, attributes)
               rescue Timeout::Error, Errno::ETIMEDOUT
-                context.scopes.last[@name] = last_response(context)
+                context.scopes.last[variable_name] = last_response(context)
               end
 
-              @body.render(context)
+              yield(context)
             end
           end
 
@@ -89,7 +82,7 @@ module Locomotive
           end
 
           def cache_options
-            @expires_in.blank? || @expires_in == 0 ? { force: true } : { expires_in: @expires_in }
+            expires_in.blank? || expires_in == 0 ? { force: true } : { expires_in: expires_in }
           end
 
           def last_response(context)
@@ -97,7 +90,7 @@ module Locomotive
           end
 
           def page_fragment_cache_key
-            "Steam-consume-#{Digest::SHA1.hexdigest(@name + @url)}"
+            "Steam-consume-#{Digest::SHA1.hexdigest(variable_name + url)}"
           end
 
         end

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

@@ -5,12 +5,12 @@ module Locomotive
         module Csrf
 
           class Base < ::Liquid::Tag
+
             def render(context)
-              service  = context.registers[:services].csrf_protection
+              service = context.registers[:services].csrf_protection
 
               if service.enabled?
                 render_csrf(service)
-
               else
                 ''
               end

data/lib/locomotive/steam/liquid/tags/editable/base.rb

@@ -5,18 +5,20 @@ module Locomotive
         module Editable
           class Base < ::Liquid::Block
 
+            include Concerns::Attributes
+
             Syntax = /(#{::Liquid::QuotedFragment})(\s*,\s*#{::Liquid::Expression}+)?/o
 
-            attr_accessor :slug
+            attr_accessor :label, :slug, :page_fullpath
 
             def initialize(tag_name, markup, options)
               if markup =~ Syntax
                 @page_fullpath    = options[:page].fullpath
                 @label_or_slug    = $1.gsub(/[\"\']/, '')
-                @element_options  = { fixed: false, inline_editing: true }
-                markup.scan(::Liquid::TagAttributes) { |key, value| @element_options[key.to_sym] = value.gsub(/^[\"\']/, '').gsub(/[\"\']$/, '') }
 
-                self.set_label_and_slug
+                parse_attributes(markup, fixed: false, inline_editing: true)
+
+                set_label_and_slug
               else
                 raise ::Liquid::SyntaxError.new("Valid syntax: #{tag_name} <slug>(, <options>)")
               end
@@ -35,14 +37,22 @@ module Locomotive
             alias :default_render :render
 
             def render(context)
+              evaluate_attributes(context)
+
               service   = context.registers[:services].editable_element
               page      = fetch_page(context)
-              block     = @element_options[:block] || context['block'].try(:name)
+              block     = attributes[:block] || context['block'].try(:name)
+
+              # If Steam inside Wagon (test mode), we've to let the developer know
+              # that editable_**** tags don't work if the site has declared at least one section
+              if context['wagon'] && context.registers[:repositories].section.count > 0
+                Locomotive::Common::Logger.error "[#{page.fullpath}] You can't use editable elements whereas you declared section(s)".colorize(:red)
+              end
 
-              if element = service.find(page, block, @slug)
+              if element = service.find(page, block, slug)
                 render_element(context, element)
               else
-                Locomotive::Common::Logger.error "[#{page.fullpath}] missing #{@tag_name} \"#{@slug}\" (#{context['block'].try(:name) || 'default'})"
+                Locomotive::Common::Logger.error "[#{page.fullpath}] missing #{@tag_name} \"#{slug}\" (#{context['block'].try(:name) || 'default'})".colorize(:yellow)
                 super
               end
             end
@@ -74,12 +84,12 @@ module Locomotive
             def fetch_page(context)
               page = context.registers[:page]
 
-              return page if !@element_options[:fixed] || page.fullpath == @page_fullpath
+              return page if !attributes[:fixed] || page.fullpath == page_fullpath
 
               pages   = context.registers[:pages] ||= {}
               service = context.registers[:services].page_finder
 
-              pages[@page_fullpath] ||= service.find(@page_fullpath)
+              pages[page_fullpath] ||= service.find(page_fullpath)
             end
 
             def register_default_content
@@ -93,10 +103,10 @@ module Locomotive
 
             def set_label_and_slug
               @slug   = @label_or_slug
-              @label  = @element_options[:label]
+              @label  = attributes[:label]
 
-              if @element_options[:slug].present?
-                @slug   = @element_options[:slug]
+              if attributes[:slug].present?
+                @slug   = attributes[:slug]
                 @label  ||= @label_or_slug
               end
             end
@@ -104,24 +114,24 @@ module Locomotive
             def default_element_attributes
               {
                 block:          self.current_inherited_block_name,
-                label:          @label,
-                slug:           @slug,
-                hint:           @element_options[:hint],
-                priority:       @element_options[:priority] || 0,
-                fixed:          [true, 'true'].include?(@element_options[:fixed]),
+                label:          label,
+                slug:           slug,
+                hint:           attributes[:hint],
+                priority:       attributes[:priority] || 0,
+                fixed:          [true, 'true'].include?(attributes[:fixed]),
                 disabled:       false,
-                inline_editing: [true, 'true'].include?(@element_options[:inline_editing]),
+                inline_editing: [true, 'true'].include?(attributes[:inline_editing]),
                 from_parent:    false,
                 type:           @tag_name.to_sym
               }
             end
 
             def current_inherited_block_name
-              @element_options[:block] || current_inherited_block.try(:name)
+              attributes[:block] || current_inherited_block.try(:name)
             end
 
             def current_inherited_block
-              options[:inherited_blocks].try(:[], :nested).try(:last)
+              parse_context[:inherited_blocks].try(:[], :nested).try(:last)
             end
 
             #:nocov:

data/lib/locomotive/steam/liquid/tags/editable/control.rb

@@ -10,12 +10,12 @@ module Locomotive
             def default_element_attributes
               super.merge({
                 content_from_default: self.render_default_content,
-                options: @element_options[:options]
+                options: attributes[:options]
               })
             end
 
             def render_element(context, element)
-              element.content
+              element.content.to_s
             end
 
             def render_default_content

data/lib/locomotive/steam/liquid/tags/editable/file.rb

@@ -7,7 +7,7 @@ module Locomotive
 
             def parse(tokens)
               super.tap do
-                @path = [current_inherited_block_name, @slug].compact.join('--').gsub('/', '--')
+                @path = [current_inherited_block_name, slug].compact.join('--').gsub('/', '--')
               end
             end
 
@@ -20,7 +20,7 @@ module Locomotive
             def default_element_attributes
               super.merge({
                 default_source_url: render_default_content.strip,
-                resize_format:      @element_options[:resize]
+                resize_format:      attributes[:resize]
               })
             end
 
@@ -54,23 +54,23 @@ module Locomotive
 
             def apply_transformation(url, context)
               # resize image with the image_resizer service?
-              if (format = @element_options[:resize]).present?
+              if (format = attributes[:resize]).present?
                 options = []
 
-                @element_options.each do |k, v|
-                  options << case k.to_sym
+                attributes.each do |key, value|
+                  options << case key.to_sym
                   when :quality
-                    "-quality #{v}"
+                    "-quality #{value}"
                   when :optimize # Shortcut helper to set quality, progressive and strip
-                    "-quality #{v} -strip -interlace Plane"
+                    "-quality #{value} -strip -interlace Plane"
                   when :auto_orient
-                    "-auto-orient" if v.downcase == "true"
+                    "-auto-orient" if value
                   when :strip
-                    "-strip" if v.downcase == "true"
+                    "-strip" if value
                   when :progressive
-                    "-interlace Plane" if v.downcase == "true"
+                    "-interlace Plane" if value
                   when :filters
-                    v
+                    value
                   else
                     next
                   end

data/lib/locomotive/steam/liquid/tags/editable/text.rb

@@ -42,16 +42,16 @@ module Locomotive
             def default_element_attributes
               super.merge(
                 content_from_default: self.render_default_content,
-                format:               @element_options[:format] || 'html',
-                rows:                 @element_options[:rows] || 10,
-                inline:               @element_options[:inline],
-                line_break:           @element_options[:line_break].blank? ? true : @element_options[:line_break],
+                format:               attributes[:format] || 'html',
+                rows:                 attributes[:rows] || 10,
+                inline:               attributes[:inline],
+                line_break:           attributes[:line_break].blank? ? true : attributes[:line_break],
               )
             end
 
             def dom_id(context)
               block_name = context['block'].try(:name).try(:gsub, '/', '-')
-              ['locomotive-editable-text', block_name, @slug].compact.join('-')
+              ['locomotive-editable-text', block_name, slug].compact.join('-')
             end
 
             def markdown_service(context)

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

@@ -2,7 +2,45 @@ module Locomotive
   module Steam
     module Liquid
       module Tags
-        class Extends < ::Liquid::Extends
+
+        # Extends allows designer to use template inheritance.
+        #
+        #   {% extends home %}
+        #   {% block content }Hello world{% endblock %}
+        #
+        class Extends < ::Liquid::Block
+          SYNTAX = /(#{::Liquid::QuotedFragment}+)/o
+
+          def initialize(tag_name, markup, options)
+            super
+
+            if markup =~ SYNTAX
+              @template_name = Regexp.last_match(1).gsub(/["']/o, '').strip
+            else
+              raise ::Liquid::SyntaxError.new("Syntax Error in 'extends' - Valid syntax: extends <page_handle_or_parent_keyword>")
+            end
+
+            # variables needed by the inheritance mechanism during the parsing
+            options[:inherited_blocks] ||= {
+              nested: [], # used to get the full name of the blocks if nested (stack mechanism)
+              all: {}, # keep track of the blocks by their full name
+            }
+          end
+
+          def parse(tokens)
+            super
+
+            parent_template = parse_parent_template
+
+            # replace the nodes of the current template by those from the parent
+            # which itself may have have done the same operation if it includes
+            # the extends tag.
+            nodelist.replace(parent_template.root.nodelist)
+          end
+
+          def blank?
+            false
+          end
 
           def render(context)
             context.stack do
@@ -11,27 +49,37 @@ module Locomotive
             end
           end
 
-          private
+          protected
+
+          def parse_body(body, tokens)
+            body.parse(tokens, options) do |end_tag_name, _|
+              @blank &&= body.blank?
+
+              # Note: extends does not require the "end tag".
+              return false if end_tag_name.nil?
+            end
+
+            true
+          end
 
           def parse_parent_template
-            parent = options[:parent_finder].find(options[:page], @template_name)
+            parent = parse_context[:parent_finder].find(parse_context[:page], @template_name)
 
             # no need to go further if the parent does not exist
-            raise PageNotFound.new("Extending a missing page. Page/Layout with fullpath '#{@template_name}' was not found") if parent.nil?
+            raise Liquid::PageNotFound.new("Extending a missing page. Page/Layout with fullpath '#{@template_name}' was not found") if parent.nil?
 
-            ActiveSupport::Notifications.instrument('steam.parse.extends', page: options[:page], parent: parent)
+            ActiveSupport::Notifications.instrument('steam.parse.extends', page: parse_context[:page], parent: parent)
 
             # define the layout name which is basically the handle of the parent page
             # if there is no handle, we take the slug which might or might not be localized.
             @layout_name = parent.handle || parent.slug
 
             # the source has already been parsed before
-            options[:parser]._parse(parent, options.merge(page: parent))
+            parse_context[:parser]._parse(parent, parse_context.merge(page: parent))
           end
-
         end
 
-        ::Liquid::Template.register_tag('extends'.freeze, Extends)
+        ::Liquid::Template.register_tag('extends', Extends)
       end
     end
   end

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

@@ -5,22 +5,22 @@ module Locomotive
         class GlobalSection < Locomotive::Steam::Liquid::Tags::Section
 
           def parse(tokens)
-            notify_on_parsing(evaluate_section_name,
+            notify_on_parsing(section_type,
               source:     :site,
-              id:         "site-#{evaluate_section_name}",
-              key:        evaluate_section_name,
-              placement:  @section_options[:placement]&.to_sym
+              id:         "site-#{section_type}",
+              key:        section_type,
+              placement:  attributes[:placement]&.to_sym
             )
           end
 
           private
 
           def find_section_content(context)
-            context['site']&.sections_content&.fetch(@section_type, nil)
+            context['site']&.sections_content&.fetch(section_type, nil)
           end
 
           def set_section_dom_id(context)
-            context['section_id'] = "site-#{@section_type}"
+            context['section_id'] = "site-#{section_type}"
           end
 
         end

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

@@ -2,18 +2,26 @@ module Locomotive
   module Steam
     module Liquid
       module Tags
-        class GoogleAnalytics < ::Solid::Tag
+        class GoogleAnalytics < ::Liquid::Tag
 
-          tag_name :google_analytics
+          Syntax = /(#{::Liquid::QuotedFragment}+)/o.freeze
 
-          def display(account_id = nil)
-            if account_id.blank?
-              raise ::Liquid::SyntaxError.new("Syntax Error in 'google_analytics' - Valid syntax: google_analytics <account_id>")
+          attr_reader :account_id
+
+          def initialize(tag_name, markup, options)
+            super
+
+            if markup =~ Syntax
+              @account_id = ::Liquid::Expression.parse($1)
             else
-              ga_snippet(account_id)
+              raise ::Liquid::SyntaxError.new("Syntax Error in 'google_analytics' - Valid syntax: google_analytics <account_id>")
             end
           end
 
+          def render(context)
+            ga_snippet(context.evaluate(account_id))
+          end
+
           private
 
           def ga_snippet(account_id)
@@ -32,6 +40,8 @@ module Locomotive
 
         end
 
+        ::Liquid::Template.register_tag('google_analytics'.freeze, GoogleAnalytics)
+
       end
     end
   end