locomotivecms_steam 1.5.0.rc0 → 1.5.0.rc1

data/lib/locomotive/steam/errors.rb

@@ -5,34 +5,41 @@ module Locomotive::Steam
 
   class RedirectionException < ::Exception
 
-    attr_reader :url
+    attr_reader :url, :permanent
 
-    def initialize(url)
-      @url = url
-      super("Redirect to #{url}")
+    def initialize(url, permanent: false)
+      @url        = url
+      @permanent  = permanent
+      super("Redirect to #{url} (#{permanent ? '301': '302'})")
     end
 
   end
 
-  class ParsingRenderingError < ::StandardError
+  class PageNotFoundException < ::Exception
+  end
+
+  class TemplateError < ::Liquid::Error
 
     LINES_RANGE = 10
 
-    attr_accessor :file, :line, :source, :original_backtrace
+    attr_accessor :source, :original_backtrace
 
-    def initialize(message, file, source, line, original_backtrace)
-      @file, @source, @line, @original_backtrace = file, source, line, original_backtrace
+    def initialize(message, template_name, source, line_number, original_backtrace)
       super(message)
+      self.template_name      = template_name
+      self.line_number        = line_number
+      self.source             = source
+      self.original_backtrace = original_backtrace
     end
 
     def code_lines
-      return [] if source.blank? || line.nil?
+      return [] if source.blank? || line_number.nil?
 
       lines = source.split("\n")
 
-      start   = line - (LINES_RANGE / 2)
+      start   = line_number - (LINES_RANGE / 2)
       start   = 1 if start <= 0
-      finish  = line + (LINES_RANGE / 2)
+      finish  = line_number + (LINES_RANGE / 2)
 
       (start..finish).map { |i| [i, lines[i - 1]] }
     end
@@ -41,21 +48,38 @@ module Locomotive::Steam
       original_backtrace
     end
 
+    private
+
+    def message_prefix
+      ""
+      # "Liquid parsing error - "
+    end
+
   end
 
-  class RenderError < ParsingRenderingError
+  class LiquidError < TemplateError
 
     def initialize(error, file, source)
-      message   = error.message
-      line      = error.respond_to?(:line_number) ? error.line_number : error.line
-      backtrace = error.backtrace
+      message     = error.message
+      line_number = error.respond_to?(:line_number) ? error.line_number : error.line
+      backtrace   = error.backtrace
 
-      super(message, file, source, line, backtrace)
+      super(message, file, source, line_number, backtrace)
     end
 
   end
 
-  class JsonParsingError < ParsingRenderingError
+  class RenderError < LiquidError
+
+    private
+
+    def message_prefix
+      "Render - "
+    end
+
+  end
+
+  class JsonParsingError < TemplateError
 
     def initialize(error, file, source)
       line = if error.message =~ /at line ([0-9]+)/
@@ -67,9 +91,15 @@ module Locomotive::Steam
       super(error.message, file, source, line, error.backtrace)
     end
 
+    private
+
+    def message_prefix
+      "JSON parsing error - "
+    end
+
   end
 
-  class ActionError < ParsingRenderingError
+  class ActionError < TemplateError
 
     attr_accessor :action
 
@@ -77,6 +107,12 @@ module Locomotive::Steam
       super(error.message, nil, script, 0, error.backtrace)
     end
 
+    private
+
+    def message_prefix
+      "Action error - "
+    end
+
   end
 
 end

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

@@ -50,7 +50,7 @@ module Locomotive
             end
           end
 
-          def before_method(meth)
+          def liquid_method_missing(meth)
             return '' if @_source.nil?
 
             if not @@forbidden_attributes.include?(meth.to_s)

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

@@ -38,7 +38,7 @@ module Locomotive
             { 'create' => public_submission_url }
           end
 
-          def before_method(meth)
+          def liquid_method_missing(meth)
             if (meth.to_s =~ /^group_by_(.+)$/) == 0
               repository.group_by_select_option($1)
             elsif (meth.to_s =~ /^(.+)_options$/) == 0

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

@@ -4,7 +4,7 @@ module Locomotive
       module Drops
         class ContentTypes < ::Liquid::Drop
 
-          def before_method(meth)
+          def liquid_method_missing(meth)
             if content_type = fetch_content_type(meth.to_s)
               ContentEntryCollection.new(content_type)
             else

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

@@ -0,0 +1,28 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Drops
+
+        # Used to render the content of the parent block.
+        #
+        #   {% extends home %}
+        #   {% block content }{{ block.super }}{% endblock %}
+        #
+        class InheritedBlock < ::Liquid::Drop
+          def initialize(block)
+            @block = block
+          end
+
+          def name
+            @block.name
+          end
+
+          def super
+            @block.call_super(@context)
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module Locomotive
           alias :count    :size
           alias :length   :size
 
-          def before_method(meth)
+          def liquid_method_missing(meth)
             find_value(meth.to_s)
           end
 
@@ -79,7 +79,7 @@ module Locomotive
 
         class Metafields < Base
 
-          def before_method(meth)
+          def liquid_method_missing(meth)
             find_namespace(meth.to_s)
           end
 

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

@@ -9,7 +9,7 @@ module Locomotive
             @_params = params.stringify_keys
           end
 
-          def before_method(meth)
+          def liquid_method_missing(meth)
             Param.new(@_params[meth.to_s])
           end
 

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

@@ -38,8 +38,16 @@ module Locomotive
             @section.definition['class']
           end
 
-          def anchor
-            @content['anchor'] || id
+          def anchor_id
+            "#{@content['anchor'] || id}-section"
+          end
+
+          def locomotive_attributes
+            %(data-locomotive-section-id="#{id}" data-locomotive-section-type="#{type}").tap do
+              # let Steam know that we won't need to wrap the section HTML
+              # into an extra DIV layer.
+              @context['is_section_locomotive_attributes_displayed'] = true
+            end
           end
 
           def blocks

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

@@ -12,12 +12,15 @@ module Locomotive
             @content, @settings = content, settings
           end
 
-          def before_method(name)
+          def liquid_method_missing(name)
             value = @content[name.to_s]
 
+            return nil if value.blank?
+
             case type_of(name)
             when 'url'          then SectionUrlField.new(*url_finder.url_for(value))
             when 'image_picker' then SectionImagePickerField.new(value)
+            when 'integer'      then value.to_i
             when 'text'         then url_finder.decode_urls_for(value)
             else value
             end
@@ -68,6 +71,10 @@ module Locomotive
             @attributes[:cropped]
           end
 
+          def present?
+            self.source.present?
+          end
+
           def to_s
             self.cropped || self.source || ''
           end
@@ -78,7 +85,7 @@ module Locomotive
         class SectionUrlField < ::Liquid::Drop
 
           def initialize(url, new_window = false)
-            @url, @new_window = url || '#', new_window
+            @url, @new_window = url, new_window
           end
 
           def new_window
@@ -89,6 +96,10 @@ module Locomotive
             !!@new_window ? 'target="_blank"' : ''
           end
 
+          def present?
+            @url.present?
+          end
+
           def to_s
             @url
           end

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

@@ -11,7 +11,7 @@ module Locomotive
             @section = section
           end
 
-          def before_method(meth)
+          def liquid_method_missing(meth)
             block   = nil
             prefix  = "section-#{@context['section'].id}"
             matches = (@context['forloop.name'] || '').match(SECTIONS_BLOCK_FORLOOP_REGEXP)

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

@@ -5,7 +5,7 @@ module Locomotive
 
         class SessionProxy < ::Liquid::Drop
 
-          def before_method(meth)
+          def liquid_method_missing(meth)
             request = @context.registers[:request]
             request.session[meth.to_sym]
           end

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

@@ -0,0 +1,46 @@
+module Locomotive
+  module Steam
+    module Liquid
+
+      # A Liquid file system is a way to let your templates retrieve other templates for use with the include and sections tags.
+      #
+      # Example:
+      #
+      #   Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
+      #   liquid = Liquid::Template.parse(template)
+      #
+      # This will parse the template from both the DB or the Filesystem.
+      #
+      class FileSystem
+
+        attr_reader :section_finder, :snippet_finder
+
+        def initialize(section_finder: nil, snippet_finder: nil)
+          @section_finder, @snippet_finder = section_finder, snippet_finder
+        end
+
+        # Called by Liquid to retrieve a template file
+        def read_template_file(template_path)
+          type, name = template_path.split('--')
+
+          entity = (
+            case type
+            when 'sections'
+              section_finder.find(name)
+            when 'snippets'
+              snippet_finder.find(name)
+            else
+              raise ::Liquid::FileSystemError, "This liquid context does not allow #{type}."
+            end
+          )
+
+          raise ::Liquid::FileSystemError, "Unable to find #{name} in the #{type} folder" if entity.nil?
+
+          entity.liquid_source
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Filters
+
+        module Array
+
+          def pop(array, input = 1)
+            return array unless array.is_a?(::Array)
+            new_ary = array.dup
+            new_ary.pop(input.to_i || 1)
+            new_ary
+          end
+
+          def push(array, input)
+            return array unless array.is_a?(::Array)
+            new_ary = array.dup
+            new_ary.push(input)
+            new_ary
+          end
+
+          def shift(array, input = 1)
+            return array unless array.is_a?(::Array)
+            new_ary = array.dup
+            new_ary.shift(input.to_i || 1)
+            new_ary
+          end
+
+          def unshift(array, input)
+            return array unless array.is_a?(::Array)
+            new_ary = array.dup
+            new_ary.unshift(*input)
+            new_ary
+          end
+
+          def in_groups_of(array, number, fill_with = nil)
+            return array unless array.respond_to?(:all) || array.respond_to?(:each_slice)
+
+            number        = number.to_i
+            grouped_array = array.respond_to?(:all) ? array.all : array
+
+            if fill_with != false
+              # size % number gives how many extra we have;
+              # subtracting from number gives how many to add;
+              # modulo number ensures we don't add group of just fill.
+              padding = (number - grouped_array.size % number) % number
+              grouped_array = grouped_array + ::Array.new(padding, fill_with)
+            end
+
+            grouped_array.each_slice(number).to_a
+          end
+
+        end
+
+        ::Liquid::Template.register_filter(Array)
+
+      end
+
+    end
+  end
+end

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

@@ -4,6 +4,14 @@ module Locomotive
       module Filters
         module Misc
 
+          def blank?(input)
+            input.blank?
+          end
+
+          def present?(input)
+            input.present?
+          end
+
           # was called modulo at first
           def str_modulo(word, index, modulo)
             (index.to_i + 1) % modulo == 0 ? word : ''
@@ -38,10 +46,12 @@ module Locomotive
               elsif property == 'to_i'.freeze
                 e.to_i
               elsif e.respond_to?(:[])
-                e[property]
+                r = e[property]
+                r.is_a?(Proc) ? r.call : r
               end
             end
-
+          rescue TypeError
+            raise_property_error(property)
           end
 
           def hexdigest(input, key, digest = nil)

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

@@ -4,15 +4,15 @@ module Locomotive
       module Filters
         module Number
 
-          def money(input, *options)
+          def money(input, options = nil)
             NumberProxyHelper.new(:currency, @context).invoke(input, options)
           end
 
-          def percentage(input, *options)
+          def percentage(input, options = nil)
             NumberProxyHelper.new(:percentage, @context).invoke(input, options)
           end
 
-          def human_size(input, *options)
+          def human_size(input, options = nil)
             NumberProxyHelper.new(:human_size, @context).invoke(input, options)
           end
 
@@ -30,17 +30,18 @@ module Locomotive
             end
 
             def invoke(input, options)
-              _options = parse_and_interpolate_options(options)
-              send :"number_to_#{@name}", input, _options
+              send :"number_to_#{@name}", input, interpolate_options(options)
             end
 
-            def parse_and_interpolate_options(string_or_array)
-              return {} if string_or_array.empty?
-
-              string = [*string_or_array].flatten.join(', ')
-              arguments = Solid::Arguments.parse(string)
-
-              (arguments.interpolate(@context).first || {})
+            def interpolate_options(options)
+              (options || {}).transform_values do |option|
+                if option.is_a?(String)
+                  _option = ::Liquid::Expression.parse(option)
+                  @context.evaluate(_option) || option
+                else
+                  option
+                end
+              end
             end
 
           end

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

@@ -16,6 +16,10 @@ module Locomotive
             Rack::Utils.escape(input)
           end
 
+          def parameterize(input)
+            input.parameterize
+          end
+
           # alias newline_to_br
           def multi_line(input)
             input.to_s.gsub("\n", '<br/>')

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

@@ -1,9 +1,48 @@
+# Enhance the IF condition to write the following statement:
+#
+# {% if value is present %}Value is not blank{% endif %}
+#
+Liquid::Condition.operators['is'.freeze] = lambda { |cond, left, right|  cond.send(:equal_variables, left, right) }
+
 module Liquid
+
+  class Expression
+
+    class << self
+      alias_method :parse_without_extra_literals, :parse
+    end
+
+    EXTRA_LITERALS = {
+      'present' => MethodLiteral.new(:present?, '').freeze
+    }.freeze
+
+    def self.parse(markup)
+      if EXTRA_LITERALS.key?(markup)
+        EXTRA_LITERALS[markup]
+      else
+        parse_without_extra_literals(markup)
+      end
+    end
+
+  end
+
+  class ParseContext
+
+    def []=(option_key, value)
+      @options[option_key] = value
+    end
+
+    def merge(options)
+      @template_options.merge(options)
+    end
+
+  end
+
   module StandardFilters
 
     private
 
-    # Fixme: Handle DateTime, Date and Time objects, convert them
+    # FIXME: Handle DateTime, Date and Time objects, convert them
     # into seconds (integer)
     def to_number(obj)
       case obj
@@ -19,32 +58,32 @@ module Liquid
     end
 
   end
-end
 
-module Liquid
-  module OptionsBuilder
-
-    private
+  class PartialCache
 
-    def parse_options_from_string(string)
-      string.try(:strip!)
+    def self.load(template_name, context:, parse_context:)
+      begin
+        cached_partials = (context.registers[:cached_partials] ||= {})
+        cached = cached_partials[template_name]
+        return cached if cached
 
-      return nil if string.blank?
+        file_system = (context.registers[:file_system] ||= ::Liquid::Template.file_system)
+        source = file_system.read_template_file(template_name)
+        parse_context.partial = true
 
-      string = string.gsub(/^(\s*,)/, '')
+        partial = ::Liquid::Template.parse(source, parse_context)
+        cached_partials[template_name] = partial
 
-      Solid::Arguments.parse(string)
-    end
 
-    def interpolate_options(options, context)
-      if options
-        options.interpolate(context).first
-      else
-        {}
+      rescue ::Liquid::SyntaxError => e
+        # FIXME: we had to reload the template one more time. Not ideal.
+        file_system = (context.registers[:file_system] ||= ::Liquid::Template.file_system)
+        source = file_system.read_template_file(template_name)
+        raise Locomotive::Steam::LiquidError.new(e, template_name, source)
       end
+    ensure
+      parse_context.partial = false
     end
 
   end
 end
-
-Liquid::Tag.send(:include, Liquid::OptionsBuilder)

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

@@ -13,10 +13,12 @@ module Locomotive
             if @site.locales.size == 1
               ''
             else
+              ending_path = context['alt_page_links_ending_path'] || ''
+
               (
-                [%(<link rel="alternate" hreflang="x-default" href="#{url_for(@site.default_locale, true)}" />)] +
+                [%(<link rel="alternate" hreflang="x-default" href="#{url_for(@site.default_locale, ending_path, true)}" />)] +
                 @site.locales.map do |locale|
-                  %(<link rel="alternate" hreflang="#{locale}" href="#{url_for(locale)}" />)
+                  %(<link rel="alternate" hreflang="#{locale}" href="#{url_for(locale, ending_path)}" />)
                 end
               ).join("\n")
             end
@@ -30,15 +32,17 @@ module Locomotive
           #
           # 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)
+          def url_for(locale, ending_path = '', default = false)
             change_page_locale(locale, @page) do
-              fullpath = services.url_builder.url_for(@page.send(:_source), locale, @page.index? && !default ? true : nil)
+              fullpath = services.url_builder.url_for(@page.send(:_source), locale, @site.prefix_default_locale) #@page.index? && !default ? true : nil)
 
               if @page.index? && default
                 fullpath.gsub!(/\/#{locale}$/, '/')
               end
 
-              @base_url + fullpath
+              fullpath.gsub!(/\/$/, '') if ending_path.present?
+
+              @base_url + fullpath + ending_path
             end
           end
 

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

@@ -0,0 +1,47 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+        module Concerns
+
+          # Many of Liquid tags have attributes (like options)
+          # This module makes sure we use the same reliable way to
+          # extract and evaluate them.
+
+          module Attributes
+
+            attr_reader :attributes, :raw_attributes
+
+            private
+
+            def parse_attributes(markup, default = {})
+              @attributes     = default || {}
+              @raw_attributes = {}
+
+              return if markup.blank?
+
+              markup.scan(tag_attributes_regexp) do |key, value|
+                _key = key.to_sym
+
+                @attributes[_key]     = block_given? ? yield(value) : ::Liquid::Expression.parse(value)
+                @raw_attributes[_key] = value
+              end
+            end
+
+            def evaluate_attributes(context)
+              @attributes = @attributes.transform_values do |attribute|
+                context.evaluate(attribute)
+              end
+            end
+
+            def tag_attributes_regexp
+              ::Liquid::TagAttributes
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end