locomotivecms_steam 0.1.2.pre.beta → 1.0.0.pre.alpha

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

@@ -1,9 +1,9 @@
 module Locomotive
   module Steam
     module Liquid
-        module Tags
+      module Tags
 
-        # Paginate a collection
+        # Paginate a collection (array or from a DB).
         #
         # Usage:
         #
@@ -13,17 +13,18 @@ module Locomotive
         #   {% endfor %}
         #  {% endpaginate %}
         #
-
         class Paginate < ::Liquid::Block
 
-          Syntax = /(#{::Liquid::Expression}+)\s+by\s+([0-9]+)/
+          Syntax = /(#{::Liquid::QuotedFragment}+)\s+by\s+([0-9]+)/o
 
-          def initialize(tag_name, markup, tokens, options)
+          def initialize(tag_name, markup, options)
             if markup =~ Syntax
-              @collection_name = $1
-              @per_page = $2.to_i
+              @collection_name  = $1
+              @per_page         = $2.to_i
+              @paginate_options = {}
+              markup.scan(::Liquid::TagAttributes) { |key, value| @paginate_options[key.to_sym] = value.gsub(/^'/, '').gsub(/'$/, '') }
             else
-              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.paginate"), options[:line])
+              raise ::Liquid::SyntaxError.new('Valid syntax: paginate <collection> by <number>')
             end
 
             super
@@ -31,52 +32,74 @@ module Locomotive
 
           def render(context)
             context.stack do
-              collection = context[@collection_name]
+              pagination = context['paginate'] = paginate_collection(context)
 
-              raise ::Liquid::ArgumentError.new("Cannot paginate array '#{@collection_name}'. Not found.") if collection.nil?
+              path = sanitize_path(context['fullpath'])
 
-              pagination = collection.send(:paginate, {
-                :page       => context['current_page'],
-                :per_page   => @per_page }).stringify_keys!
+              build_next_previous_links(pagination, path)
 
-              page_count, current_page = pagination['total_pages'], pagination['current_page']
+              if pagination['total_pages'] > 1
+                build_parts(pagination, path)
+              end
 
-              path = sanitize_path(context['fullpath'])
+              super
+            end
+          end
 
-              pagination['previous'] = link(I18n.t('pagination.previous'), current_page - 1, path) if pagination['previous_page']
-              pagination['next'] = link(I18n.t('pagination.next'), current_page + 1, path) if pagination['next_page']
-              pagination['parts'] = []
-
-              hellip_break = false
-
-              if page_count > 1
-                1.upto(page_count) do |page|
-                  if current_page == page
-                    pagination['parts'] << no_link(page)
-                  elsif page == 1
-                    pagination['parts'] << link(page, page, path)
-                  elsif page == page_count - 1
-                    pagination['parts'] << link(page, page, path)
-                  elsif page <= current_page - window_size or page >= current_page + window_size
-                    next if hellip_break
-                    pagination['parts'] << no_link('&hellip;')
-                    hellip_break = true
-                    next
-                  else
-                    pagination['parts'] << link(page, page, path)
-                  end
-
-                  hellip_break = false
-                end
-              end
+          private
 
-              context['paginate'] = pagination
+          # Paginate the collection and returns a pagination
+          # object storing all the information about the paginated
+          # collection.
+          #
+          def paginate_collection(context)
+            collection    = context[@collection_name]
+            current_page  = context['current_page']
 
-              render_all(@nodelist, context)
+            raise ::Liquid::ArgumentError.new("Cannot paginate '#{@collection_name}'. Not found.") if collection.nil?
+
+            pager = Locomotive::Steam::Models::Pager.new(collection, current_page, @per_page)
+
+            # make sure the pagination object is a hash with strings as keys (and not symbol)
+            HashConverter.to_string(pager.to_liquid).tap do |_pagination|
+              _pagination['parts'] = []
             end
           end
 
-          private
+          def build_next_previous_links(pagination, path)
+            current_page = pagination['current_page']
+
+            if pagination['previous_page']
+              pagination['previous']= link(I18n.t('pagination.previous'), current_page - 1, path)
+            end
+
+            if pagination['next_page']
+              pagination['next'] = link(I18n.t('pagination.next'), current_page + 1, path)
+            end
+          end
+
+          def build_parts(pagination, path)
+            hellip_break  = false
+
+            1.upto(pagination['total_pages']) do |page|
+              hellip_break = _build_parts(pagination, path, page, hellip_break)
+            end
+          end
+
+          def _build_parts(pagination, path, page, hellip_break)
+            if pagination['current_page'] == page
+              pagination['parts'] << no_link(page)
+            elsif is_page_a_bound?(pagination, page)
+              pagination['parts'] << link(page, page, path)
+            elsif is_page_inside_window?(pagination, page)
+              pagination['parts'] << no_link('&hellip;') unless hellip_break
+              return true
+            else
+              pagination['parts'] << link(page, page, path)
+            end
+
+            false
+          end
 
           def sanitize_path(path)
             _path = path.gsub(/page=[0-9]+&?/, '').gsub(/_pjax=true&?/, '')
@@ -84,8 +107,16 @@ module Locomotive
             _path
           end
 
+          def is_page_inside_window?(pagination, page)
+            page <= pagination['current_page'] - window_size or page >= pagination['current_page'] + window_size
+          end
+
+          def is_page_a_bound?(pagination, page)
+            page == 1 || page == pagination['total_pages']
+          end
+
           def window_size
-            3
+            @window_size ||= @paginate_options[:window_size] ? @paginate_options[:window_size].to_i : 3
           end
 
           def no_link(title)
@@ -98,8 +129,9 @@ module Locomotive
           end
         end
 
-        ::Liquid::Template.register_tag('paginate', Paginate)
+        ::Liquid::Template.register_tag('paginate'.freeze, Paginate)
       end
+
     end
   end
-end
+end

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

@@ -2,35 +2,23 @@ module Locomotive
   module Steam
     module Liquid
       module Tags
-
         class PathTo < ::Liquid::Tag
 
-          include PathHelper
-
-          Syntax = /(#{::Liquid::Expression}+)(#{::Liquid::TagAttributes}?)/
-
-          def initialize(tag_name, markup, tokens, context)
-            if markup =~ Syntax
-              @handle = $1
-              @_options = {}
-              markup.scan(::Liquid::TagAttributes) do |key, value|
-                @_options[key] = value
-              end
-            else
-              raise SyntaxError.new("Syntax Error in 'path_to' - Valid syntax: path_to <page|page_handle|content_entry>(, locale: [fr|de|...], with: <page_handle>")
-            end
-
-            super
-          end
+          include Concerns::I18nPage
+          include Concerns::Path
 
           def render(context)
             render_path(context)
           end
 
+          def wrong_syntax!
+            raise SyntaxError.new("Valid syntax: path_to <page|page_handle|content_entry>(, locale: [fr|de|...], with: <page_handle>")
+          end
+
         end
 
-        ::Liquid::Template.register_tag('path_to', PathTo)
+        ::Liquid::Template.register_tag('path_to'.freeze, PathTo)
       end
     end
   end
-end
+end

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

@@ -26,12 +26,12 @@ module Locomotive
 
             def render_metadata(context)
               %{
-                <meta name="description" content="#{self.value_for(:meta_description, context)}" />
-                <meta name="keywords" content="#{self.value_for(:meta_keywords, context)}" />
+                <meta name="description" content="#{self.value_for(:meta_description, context)}">
+                <meta name="keywords" content="#{self.value_for(:meta_keywords, context)}">
               }
             end
 
-            # Removes whitespace and quote characters from the input
+            # Removes whitespace and quote charactets from the input
             def sanitized_string(string)
               string ? string.strip.gsub(/"/, '') : ''
             end
@@ -43,7 +43,7 @@ module Locomotive
             end
 
             def metadata_object(context)
-              context['content_instance'] || context['page']
+              context['content_entry'] || context['page']
             end
           end
 
@@ -65,10 +65,10 @@ module Locomotive
 
         end
 
-        ::Liquid::Template.register_tag('seo', SEO::Base)
-        ::Liquid::Template.register_tag('seo_title', SEO::Title)
-        ::Liquid::Template.register_tag('seo_metadata', SEO::Metadata)
+        ::Liquid::Template.register_tag('seo'.freeze, SEO::Base)
+        ::Liquid::Template.register_tag('seo_title'.freeze, SEO::Title)
+        ::Liquid::Template.register_tag('seo_metadata'.freeze, SEO::Metadata)
       end
     end
   end
-end
+end

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

@@ -12,14 +12,13 @@ module Locomotive
         #   {{ session.foo }}
         #
         class SessionAssign < ::Liquid::Tag
-          Syntax = /(#{::Liquid::VariableSignature}+)\s*=\s*(#{::Liquid::QuotedFragment}+)/
+          Syntax = /(#{::Liquid::VariableSignature}+)\s*=\s*(#{::Liquid::QuotedFragment}+)/o
 
-          def initialize(tag_name, markup, tokens, options)
+          def initialize(tag_name, markup, options)
             if markup =~ Syntax
-              @to = $1
-              @from = $2
+              @to, @from = $1, $2
             else
-              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.session_assign"), options[:line])
+              raise ::Liquid::SyntaxError.new("Valid syntax: session_assign [var] = [source]")
             end
 
             super
@@ -27,15 +26,14 @@ module Locomotive
 
           def render(context)
             request = context.registers[:request]
-
             request.session[@to.to_sym] = context[@from]
             ''
           end
 
         end
 
-        ::Liquid::Template.register_tag('session_assign', SessionAssign)
+        ::Liquid::Template.register_tag('session_assign'.freeze, SessionAssign)
       end
     end
   end
-end
+end

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

@@ -5,59 +5,43 @@ module Locomotive
 
         class Snippet < ::Liquid::Include
 
-          def render(context)
-            name    = @template_name.gsub(/[\"\']/, '')
-            snippet = context.registers[:mounting_point].snippets[name]
-
-            raise ::Liquid::StandardError.new("Unknown snippet \"#{name}\"") if snippet.nil?
-
-            partial   = self.parse_template(snippet)
+          def parse(tokens)
+            if listener = options[:events_listener]
+              listener.emit(:include, page: options[:page], name: @template_name)
+
+              # look for editable elements
+              name = evaluate_snippet_name
+              if snippet = options[:snippet_finder].find(name)
+                options[:parser]._parse(snippet, options.merge(snippet: name))
+              end
+            end
+          end
 
-            variable  = context[@variable_name || @template_name[1..-2]]
+          def render(context)
+            @template_name = evaluate_snippet_name(context)
+            super
+          end
 
-            context.stack do
-              @attributes.each do |key, value|
-                context[key] = context[value]
-              end
+          private
 
-              output = (if variable.is_a?(Array)
-                variable.collect do |variable|
-                  context[@template_name[1..-2]] = variable
-                  partial.render(context)
-                end
-              else
-                context[@template_name[1..-2]] = variable
-                partial.render(context)
-              end)
+          def read_template_from_file_system(context)
+            service = context.registers[:services]
+            snippet = service.snippet_finder.find(@template_name)
 
-              Locomotive::Common::Logger.info "  Steamed snippet #{name}"
+            raise SnippetNotFound.new("Snippet with slug '#{@template_name}' was not found") if snippet.nil?
 
-              output
-            end
+            snippet.liquid_source
           end
 
-          protected
-
-          def parse_template(snippet)
-            begin
-              ::Liquid::Template.parse(snippet.source)
-            rescue ::Liquid::Error => e
-              # do it again on the raw source instead so that the error line matches
-              # the source file.
-              begin
-                ::Liquid::Template.parse(snippet.template.raw_source)
-              rescue ::Liquid::Error => e
-                e.backtrace.unshift "#{snippet.template.filepath}:#{e.line + 1}:in `#{snippet.name}'"
-                e.line = self.line - 1
-                raise e
-              end
-            end
+          def evaluate_snippet_name(context = nil)
+            context.try(:evaluate, @template_name) ||
+            @template_name.send(:state).first
           end
 
         end
 
-        ::Liquid::Template.register_tag('include', Snippet)
+        ::Liquid::Template.register_tag('include'.freeze, Snippet)
       end
     end
   end
-end
+end

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

@@ -2,43 +2,61 @@ module Locomotive
   module Steam
     module Liquid
       module Tags
-        class WithScope < ::Liquid::Block
 
-          SlashedString = /\/[^\/]*\//
-          TagAttributes = /(\w+|\w+\.\w+)\s*\:\s*(#{SlashedString}|#{::Liquid::QuotedFragment})/
+        # Filter a collection
+        #
+        # Usage:
+        #
+        # {% with_scope main_developer: 'John Doe', providers.in: ['acme'], started_at.le: today, active: true %}
+        #   {% for project in contents.projects %}
+        #     {{ project.name }}
+        #   {% endfor %}
+        # {% endwith_scope %}
+        #
 
-          def initialize(tag_name, markup, tokens, options)
-            @tag_options = HashWithIndifferentAccess.new
-            markup.scan(TagAttributes) do |key, value|
-              @tag_options[key] = value
-            end
-            super
+        class WithScope < Solid::Block
+
+          OPERATORS = %w(all exists gt gte in lt lte ne nin size near within)
+
+          SYMBOL_OPERATORS_REGEXP = /(\w+\.(#{OPERATORS.join('|')})){1}\s*\:/o
+
+          # register the tag
+          tag_name :with_scope
+
+          def initialize(name, markup, options)
+            # convert symbol operators into valid ruby code
+            markup.gsub!(SYMBOL_OPERATORS_REGEXP, ':"\1" =>')
+
+            super(name, markup, options)
           end
 
-          def render(context)
-            context.stack do
-              context['with_scope'] = decode(@tag_options, context)
-              render_all(@nodelist, context)
+          def display(options = {}, &block)
+            current_context.stack do
+              current_context['with_scope'] = self.decode(options)
+              yield
             end
           end
 
-          private
-
-          def decode(attributes, context)
-            attributes.each_pair do |key, value|
-              attributes[key] = (case value
-              when /^true|false$/i    then value == 'true'
-              when /^\/[^\/]*\/$/     then Regexp.new(value[1..-2])
-              when /^["|'](.+)["|']$/ then $1.gsub(/^["|']/, '').gsub(/["|']$/, '')
-              else
-                context[value] || value
-              end)
+          protected
+
+          def decode(options)
+            HashWithIndifferentAccess.new.tap do |hash|
+              options.each do |key, value|
+                # _slug instead of _permalink
+                _key = key.to_s == '_permalink' ? '_slug' : key.to_s
+
+                hash[_key] = (case value
+                  # regexp inside a string
+                when /^\/[^\/]*\/$/ then Regexp.new(value[1..-2])
+                else
+                  value
+                end)
+              end
             end
           end
         end
 
-        ::Liquid::Template.register_tag('with_scope', WithScope)
       end
     end
   end
-end
+end