locomotivecms_steam 1.4.1 → 1.5.0.beta1

data/lib/locomotive/steam/liquid/drops/section_editor_setting_data.rb

@@ -0,0 +1,65 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Drops
+
+        # Required to allow the sync between the Locomotive editor
+        # and the string/text inputs of a section and section block
+        class SectionEditorSettingData < ::Liquid::Drop
+
+          def initialize(section)
+            @section = section
+          end
+
+          def before_method(meth)
+            block   = nil
+            prefix  = "section-#{@context['section'].id}"
+            matches = (@context['forloop.name'] || '').match(SECTIONS_BLOCK_FORLOOP_REGEXP)
+
+            # are we inside a block?
+            if matches && variable_name = matches[:name]
+              block = @context[variable_name]
+              prefix += "-block.#{block.id}"
+            end
+
+            # only string and text inputs can synced
+            if is_text?(meth.to_s, block)
+              %( data-locomotive-editor-setting="#{prefix}.#{meth}")
+            else
+              ''
+            end
+          end
+
+          private
+
+          def is_text?(id, block)
+            settings = block ? block_settings(block['type']) : section_settings
+
+            # can happen if the developer forgets to assign a type to
+            # the default blocks
+            return false if settings.blank?
+
+            text_inputs(settings).include?(id)
+          end
+
+          def text_inputs(settings)
+            settings.map do |input|
+              %w(text textarea).include?(input['type']) ? input['id'] : nil
+            end.compact
+          end
+
+          def block_settings(type)
+            @section.definition['blocks'].find do |block|
+              block['type'] == type
+            end&.fetch('settings', nil)
+          end
+
+          def section_settings
+            @section.definition['settings']
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/steam/liquid/drops/site.rb

@@ -4,7 +4,8 @@ module Locomotive
       module Drops
         class Site < I18nBase
 
-          delegate :name, :handle, :domains, :seo_title, :meta_keywords, :meta_description, :asset_host, to: :@_source
+          delegate :name, :handle, :domains, :seo_title, :meta_keywords,
+            :meta_description, :asset_host, :sections_content, to: :@_source
 
           def index
             @index ||= repository.root.to_liquid

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

@@ -5,6 +5,8 @@ module Locomotive
 
       class SnippetNotFound < ::Liquid::Error; end
 
+      class SectionNotFound < ::Liquid::Error; end
+
       class PageNotTranslated < ::Liquid::Error; end
     end
   end

data/lib/locomotive/steam/liquid/filters/base.rb

@@ -35,14 +35,14 @@ module Locomotive
             input.respond_to?(:url) ? input.url : input
           end
 
-          def css_js_asset_url(input, extension, folder)
+          def any_asset_url(input, extension = nil, folder = nil)
             return '' if input.nil?
 
             if input =~ /^https?:/
               input
             else
-              uri = input.starts_with?('/') ? URI(input) : URI(asset_url("#{folder}/#{input}"))
-              uri.path = "#{uri.path}#{extension}" unless uri.path.ends_with?(extension)
+              uri = input.starts_with?('/') ? URI(input) : URI(asset_url(folder.blank? ? input : "#{folder}/#{input}"))
+              uri.path = "#{uri.path}#{extension}" unless extension.blank? || uri.path.ends_with?(extension)
               uri.to_s
             end
           end

data/lib/locomotive/steam/liquid/filters/date.rb

@@ -17,7 +17,7 @@ module Locomotive
             end
           end
 
-          def parse_date(input, format)
+          def parse_date(input, format = nil)
             return '' if input.blank?
 
             format  ||= I18n.t('date.formats.default')

data/lib/locomotive/steam/liquid/filters/html.rb

@@ -18,10 +18,15 @@ module Locomotive
             %{<link rel="#{rel}" type="#{type}" title="#{title}" href="#{input}" />}
           end
 
+          # Write the url of any theme file
+          def theme_asset_url(input)
+            any_asset_url(input)
+          end
+
           # Write the url of a theme stylesheet
           # input: name of the css file
           def stylesheet_url(input)
-            css_js_asset_url(input, '.css', 'stylesheets')
+            any_asset_url(input, '.css', 'stylesheets')
           end
 
           # Write the link tag of a theme stylesheet
@@ -37,7 +42,7 @@ module Locomotive
           # Write the url to javascript resource
           # input: name of the javascript file
           def javascript_url(input)
-            css_js_asset_url(input, '.js', 'javascripts')
+            any_asset_url(input, '.js', 'javascripts')
           end
 
           # Write the link to javascript resource

data/lib/locomotive/steam/liquid/filters/json.rb

@@ -9,7 +9,9 @@ module Locomotive
               fields = fields.split(',').map(&:strip)
             end
 
-            if input.respond_to?(:each)
+            if input.is_a?(Hash)
+              object_to_json(input, fields)
+            elsif input.respond_to?(:each)
               '[' + input.map do |object|
                 fields.size == 1 ? object[fields.first].to_json : object_to_json(object, fields)
               end.join(',') + ']'

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

@@ -54,9 +54,9 @@ module Locomotive
           end
 
           def safe_params(context)
-            return {} if context['params'].blank?
+            return {} if context.registers[:params].blank?
 
-            context['params'].dup.tap do |params|
+            context.registers[:params].dup.tap do |params|
               # Tempfile can't be converted in Duktape for obvious reasons
               replace_tempfile(params)
             end

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

@@ -0,0 +1,63 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+
+        class AltPageLinks < ::Liquid::Tag
+
+          include Concerns::I18nPage
+
+          def render(context)
+            set_vars_from_context(context)
+
+            if @site.locales.size == 1
+              ''
+            else
+              (
+                [%(<link rel="alternate" hreflang="x-default" href="#{url_for(@site.default_locale, true)}" />)] +
+                @site.locales.map do |locale|
+                  %(<link rel="alternate" hreflang="#{locale}" href="#{url_for(locale)}" />)
+                end
+              ).join("\n")
+            end
+          end
+
+          private
+
+          # Examples:
+          # - http://www.example.com/fr (even if the default locale is fr)
+          # - http://www.example.com/ (as the default url (x-default) for the index page)
+          #
+          # Note: the index page has a different behaviour because rendering "/" depends
+          # on the language returned by the browser (so might be different based on the user session).
+          def url_for(locale, default = false)
+            change_page_locale(locale, @page) do
+              fullpath = services.url_builder.url_for(@page.send(:_source), locale, @page.index? && !default ? true : nil)
+
+              if @page.index? && default
+                fullpath.gsub!(/\/#{locale}$/, '/')
+              end
+
+              @base_url + fullpath
+            end
+          end
+
+          def services
+            @context.registers[:services]
+          end
+
+          def set_vars_from_context(context)
+            @context      = context
+            @site         = context.registers[:site]
+            @page         = context['page']
+            @base_url     = context['base_url']
+          end
+
+
+        end
+
+        ::Liquid::Template.register_tag('alt_page_links'.freeze, AltPageLinks)
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module Locomotive
               page = drop.send(:_source)
 
               page.__with_locale__(locale) do
-                if page.templatized?
+                if page.templatized? && page.content_entry
                   page.content_entry.__with_locale__(locale) { yield }
                 else
                   yield

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

@@ -0,0 +1,117 @@
+module Locomotive::Steam::Liquid::Tags::Concerns
+
+  module Section
+
+    private
+
+    def render_section(context, template, section, content)
+      context.stack do
+        # build a drop from the content and add it to the new context
+        context['section'] = Locomotive::Steam::Liquid::Drops::Section.new(
+          section,
+          content
+        )
+
+        # assign an id if specified in the context
+        context['section'].id ||= context['section_id'] if context['section_id'].present?
+
+        begin
+          _render(context, template)
+        rescue Locomotive::Steam::ParsingRenderingError => e
+          e.file = section.name + ' [Section]'
+          raise e
+        end
+      end
+    end
+
+    def _render(context, template)
+      if context.registers[:live_editing]
+        editor_settings_lookup(template.root)
+      end
+
+      context.stack do
+        html    = template.render(context)
+        section = context['section']
+
+        tag_id    = %(id="locomotive-section-#{section.id}")
+        tag_class = %(class="#{['locomotive-section', section.css_class].compact.join(' ')}")
+        tag_data  = %(data-locomotive-section-type="#{section.type}")
+
+        %(<div #{tag_id} #{tag_class} #{tag_data}>#{html}</div>)
+      end
+    end
+
+    # in order to enable string/text synchronization with the editor:
+    # - find variables like {{ section.settings.<id> }} or {{ block.settings.<id> }}
+    # - once found, get the closest tag
+    # - add custom data attributes to it
+    def editor_settings_lookup(root)
+      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)
+          matches = node.raw.match(Locomotive::Steam::SECTIONS_SETTINGS_VARIABLE_REGEXP)
+
+          # is a section setting variable?
+          if matches && matches[:id] && wrapped_around_tag?(index, root.nodelist)
+            # open the closest HTML tag
+            previous_node.gsub!(/>(\s*)\z/, '\1')
+
+            # here we go, add a liquid variable!
+            new_nodelist.push(::Liquid::Variable.new(
+              "section.editor_setting_data.#{matches[:id]}",
+              node.instance_variable_get(:@options))
+            )
+
+            # close the tag
+            new_nodelist.push(::Liquid::Token.new('>', previous_node.line_number))
+          end
+        elsif node.respond_to?(:nodelist)
+          editor_settings_lookup(node)
+        end
+
+        new_nodelist.push(node)
+
+        previous_node = node
+      end
+
+      (root.instance_variable_get(:@body) || root).instance_variable_set(:@nodelist, new_nodelist)
+    end
+
+    def wrapped_around_tag?(index, nodelist)
+      return false if index + 1 >= nodelist.size
+
+      previous_node = nodelist[index - 1]
+      next_node     = nodelist[index + 1]
+
+      return false unless next_node.is_a?(::Liquid::Token)
+
+      (previous_node =~ /\>\s*\z/).present? && (next_node =~ /\A\s*\</).present?
+    end
+
+    def notify_on_parsing(type, source: :page, is_dropzone: false, key: nil, id: nil, label: nil, placement: nil)
+      ActiveSupport::Notifications.instrument('steam.parse.section', {
+        attributes: {
+          type:         type,
+          source:       source,
+          id:           id,
+          key:          key,
+          is_dropzone:  is_dropzone,
+          label:        label,
+          placement:    placement
+        },
+        page:   options[:page],
+        block:  current_inherited_block_name
+      })
+    end
+
+    def current_inherited_block_name
+      options[:inherited_blocks].try(:[], :nested).try(:last).try(:name)
+    end
+
+  end
+
+end

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

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

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

@@ -79,7 +79,7 @@ module Locomotive
             if url.blank?
               if options[:json]
                 url = current_context['path'].blank? ? '/' : current_context['path']
-                url + 'index.json'
+                url + (url.ends_with?('/') ? 'index.json' : '.json')
               else
                 nil
               end

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

@@ -0,0 +1,87 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+        class Section < ::Liquid::Include
+
+          include Concerns::Section
+
+          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)")
+            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
+            )
+          end
+
+          def render(context)
+            # @options doesn't include the page key if cache is on
+            @options[: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}"
+
+            section   = find_section(context)
+            template  = load_cached_partial(context)
+
+            # if the tag is called by the Section middleware, use the content
+            # from the request.
+            content = context.registers[:_section_content]
+
+            # if no content from the middleware, go get it from the page
+            content ||= find_section_content(context)
+
+            context.stack do
+              set_section_dom_id(context)
+              render_section(context, template, section, content)
+            end
+          end
+
+          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
+          end
+
+          def find_section(context)
+            context.registers[:services].section_finder.find(@section_type)
+          end
+
+          def find_section_content(context)
+            section_id = @section_options[: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
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('section'.freeze, Section)
+      end
+    end
+  end
+end