locomotivecms_steam 0.1.0

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

@@ -0,0 +1,287 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+
+        # Display the children pages of the site, current page or the parent page. If not precised, nav is applied on the current page.
+        # The html output is based on the ul/li tags.
+        #
+        # Usage:
+        #
+        # {% nav site %} => <ul class="nav"><li class="on"><a href="/features">Features</a></li></ul>
+        #
+        # {% nav site, no_wrapper: true, exclude: 'contact|about', id: 'main-nav', class: 'nav', active_class: 'on' }
+        #
+        class Nav < ::Liquid::Tag
+
+          Syntax = /(#{::Liquid::Expression}+)?/
+
+          attr_accessor :current_page, :mounting_point
+
+          def initialize(tag_name, markup, tokens, options)
+            if markup =~ Syntax
+              @source = ($1 || 'page').gsub(/"|'/, '')
+
+              self.set_options(markup, options)
+            else
+              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.nav"), options[:line])
+            end
+
+            super
+          end
+
+          def render(context)
+            self.set_accessors_from_context(context)
+
+            entries = self.fetch_entries
+            output  = self.build_entries_output(entries)
+
+            if self.no_wrapper?
+              output
+            else
+              self.render_tag(:nav, id: @_options[:id], css: @_options[:class]) do
+                self.render_tag(:ul) { output }
+              end
+            end
+          end
+
+          protected
+
+          # Build recursively the links of all the pages.
+          #
+          # @param [ Array ] entries List of pages
+          #
+          # @return [ String ] The final HTML output
+          #
+          def build_entries_output(entries, depth = 1)
+            output  = []
+
+            entries.each_with_index do |page, index|
+              css = []
+              css << 'first'  if index == 0
+              css << 'last'   if index == entries.size - 1
+
+              output << self.render_entry_link(page, css.join(' '), depth)
+            end
+
+            output.join("\n")
+          end
+
+          # Get all the children of a source: site (index page), parent or page.
+          #
+          # @return [ Array ] List of pages
+          #
+          def fetch_entries
+            children = (case @source
+            when 'site'     then self.mounting_point.pages['index']
+            when 'parent'   then self.current_page.parent || self.current_page
+            when 'page'     then self.current_page
+            else
+              self.mounting_point.pages[@source]
+            end).children.try(:clone) || []
+
+            children.delete_if { |p| !include_page?(p) }
+          end
+
+          # Determine whether or not a page should be a part of the menu.
+          #
+          # @param [ Object ] page The page
+          #
+          # @return [ Boolean ] True if the page can be included or not
+          #
+          def include_page?(page)
+            if !page.listed? || page.templatized? || !page.published?
+              false
+            elsif @_options[:exclude]
+              (page.fullpath =~ @_options[:exclude]).nil?
+            else
+              true
+            end
+          end
+
+          # Determine wether or not a page is currently the displayed one.
+          #
+          # @param [ Object ] page The page
+          #
+          # @return [ Boolean ]
+          #
+          def page_selected?(page)
+            self.current_page.fullpath =~ /^#{page.fullpath}(\/.*)?$/
+          end
+
+          # Determine if the children of a page have to be rendered or not.
+          # It depends on the depth passed in the option.
+          #
+          # @param [ Object ] page The page
+          # @param [ Integer ] depth The current depth
+          #
+          # @return [ Boolean ] True if the children have to be rendered.
+          #
+          def render_children_for_page?(page, depth)
+            depth.succ <= @_options[:depth].to_i &&
+            (page.children || []).select { |child| self.include_page?(child) }.any?
+          end
+
+          # Return the label of an entry. It may use or not the template
+          # given by the snippet option.
+          #
+          # @param [ Object ] page The page
+          #
+          # @return [ String ] The label in HTML
+          #
+          def entry_label(page)
+            icon  = @_options[:icon] ? '<span></span>' : ''
+            title = @_options[:liquid_render] ? @_options[:liquid_render].render('page' => page) : page.title
+
+            if icon.blank?
+              title
+            elsif @_options[:icon] == 'after'
+              "#{title} #{icon}"
+            else
+              "#{icon} #{title}"
+            end
+          end
+
+          # Return the localized url of an entry (page).
+          #
+          # @param [ Object ] page The page
+          #
+          # @return [ String ] The localized url
+          #
+          def entry_url(page)
+            if ::I18n.locale.to_s == self.mounting_point.default_locale.to_s
+              "/#{page.fullpath}"
+            else
+              "/#{::I18n.locale}/#{page.fullpath}"
+            end
+          end
+
+          # Return the css of an entry (page).
+          #
+          # @param [ Object ] page The page
+          # @param [ String ] css The extra css
+          #
+          # @return [ String ] The css
+          #
+          def entry_css(page, css = '')
+            _css = 'link'
+            _css += " #{page} #{@_options[:active_class]}" if self.page_selected?(page)
+
+            (_css + " #{css}").strip
+          end
+
+          # Return the HTML output of a page and its children if requested.
+          #
+          # @param [ Object ] page The page
+          # @param [ String ] css The current css to apply to the entry
+          # @param [ Integer] depth Used to know if the children has to be added or not.
+          #
+          # @return [ String ] The HTML output
+          #
+          def render_entry_link(page, css, depth)
+            url       = self.entry_url(page)
+            label     = self.entry_label(page)
+            css       = self.entry_css(page, css)
+            options   = ''
+
+            if self.render_children_for_page?(page, depth) && self.bootstrap?
+              url       = '#'
+              label     += %{ <b class="caret"></b>}
+              css       += ' dropdown'
+              options   = %{ class="dropdown-toggle" data-toggle="dropdown"}
+            end
+
+            self.render_tag(:li, id: "#{page.slug.to_s.dasherize}-link", css: css) do
+              children_output = depth.succ <= @_options[:depth].to_i ? self.render_entry_children(page, depth.succ) : ''
+              %{<a href="#{url}"#{options}>#{label}</a>} + children_output
+            end
+          end
+
+          # Recursively create a nested unordered list for the depth specified.
+          #
+          # @param [ Array ] entries The children of the page
+          # @param [ Integer ] depth The current depth
+          #
+          # @return [ String ] The HTML code
+          #
+          def render_entry_children(page, depth)
+            entries = (page.children || []).select { |child| self.include_page?(child) }
+            css     = self.bootstrap? ? 'dropdown-menu' : ''
+
+            unless entries.empty?
+              self.render_tag(:ul, id: "#{@_options[:id]}-#{page.slug.to_s.dasherize}", css: css) do
+                self.build_entries_output(entries, depth)
+              end
+            else
+              ''
+            end
+          end
+
+          # Set the value (default or assigned by the tag) of the options.
+          #
+          def set_options(markup, options)
+            @_options = { id: 'nav', class: '', active_class: 'on', bootstrap: false, no_wrapper: false }
+
+            markup.scan(::Liquid::TagAttributes) { |key, value| @_options[key.to_sym] = value.gsub(/"|'/, '') }
+
+            @_options[:exclude] = Regexp.new(@_options[:exclude]) if @_options[:exclude]
+
+            if @_options[:snippet]
+              if template = self.parse_snippet_template(options, @_options[:snippet])
+                @_options[:liquid_render] = template
+              end
+            end
+          end
+
+          # Avoid to call context.registers to get the current page
+          # and the mounting point.
+          #
+          def set_accessors_from_context(context)
+            self.current_page   = context.registers[:page]
+            self.mounting_point = context.registers[:mounting_point]
+          end
+
+          # Parse the template of the snippet give in option of the tag.
+          # If the template_name contains a liquid tag or drop, it will
+          # be used an inline template.
+          #
+          def parse_snippet_template(context, template_name)
+            source = if template_name.include?('{')
+              template_name
+            else
+              context[:mounting_point].snippets[template_name].try(:source)
+            end
+
+            source ? ::Liquid::Template.parse(source) : nil
+          end
+
+          # Steam any kind HTML tags. The content of the tag comes from
+          # the block.
+          #
+          # @param [ String ] tag_name Name of the HTML tag (li, ul, div, ...etc).
+          # @param [ String ] html_options Id, class, ..etc
+          #
+          # @return [ String ] The HTML
+          #
+          def render_tag(tag_name, html_options = {}, &block)
+            options = ['']
+            options << %{id="#{html_options[:id]}"} if html_options[:id].present?
+            options << %{class="#{html_options[:css]}"} if html_options[:css].present?
+
+            %{<#{tag_name}#{options.join(' ')}>#{yield}</#{tag_name}>}
+          end
+
+          def bootstrap?
+            @_options[:bootstrap].to_bool
+          end
+
+          def no_wrapper?
+            @_options[:no_wrapper].to_bool
+          end
+
+          ::Liquid::Template.register_tag('nav', Nav)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+module Locomotive
+  module Steam
+    module Liquid
+        module Tags
+
+        # Paginate a collection
+        #
+        # Usage:
+        #
+        # {% paginate contents.projects by 5 %}
+        #   {% for project in paginate.collection %}
+        #     {{ project.name }}
+        #   {% endfor %}
+        #  {% endpaginate %}
+        #
+
+        class Paginate < ::Liquid::Block
+
+          Syntax = /(#{::Liquid::Expression}+)\s+by\s+([0-9]+)/
+
+          def initialize(tag_name, markup, tokens, options)
+            if markup =~ Syntax
+              @collection_name = $1
+              @per_page = $2.to_i
+            else
+              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.paginate"), options[:line])
+            end
+
+            super
+          end
+
+          def render(context)
+            context.stack do
+              collection = context[@collection_name]
+
+              raise ::Liquid::ArgumentError.new("Cannot paginate array '#{@collection_name}'. Not found.") if collection.nil?
+
+              pagination = collection.send(:paginate, {
+                :page       => context['current_page'],
+                :per_page   => @per_page }).stringify_keys!
+
+              page_count, current_page = pagination['total_pages'], pagination['current_page']
+
+              path = sanitize_path(context['fullpath'])
+
+              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
+
+              context['paginate'] = pagination
+
+              render_all(@nodelist, context)
+            end
+          end
+
+          private
+
+          def sanitize_path(path)
+            _path = path.gsub(/page=[0-9]+&?/, '').gsub(/_pjax=true&?/, '')
+            _path = _path.slice(0..-2) if _path.last == '?' || _path.last == '&'
+            _path
+          end
+
+          def window_size
+            3
+          end
+
+          def no_link(title)
+            { 'title' => title, 'is_link' => false, 'hellip_break' => title == '&hellip;' }
+          end
+
+          def link(title, page, path)
+            _path = %(#{path}#{path.include?('?') ? '&' : '?'}page=#{page})
+            { 'title' => title, 'url' => _path, 'is_link' => true }
+          end
+        end
+
+        ::Liquid::Template.register_tag('paginate', Paginate)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+
+        module PathHelper
+
+          def render_path(context, &block)
+            site  = context.registers[:site]
+
+            if page = self.retrieve_page_from_handle(context)
+              path = self.public_page_fullpath(context, page)
+
+              if block_given?
+                block.call page, path
+              else
+                path
+              end
+            else
+              raise Liquid::PageNotTranslated.new(%{[link_to] Unable to find a page for the #{@handle}. Wrong handle or missing template for your content.})
+            end
+          end
+
+          protected
+
+          def retrieve_page_from_handle(context)
+            mounting_point = context.registers[:mounting_point]
+
+            context.scopes.reverse_each do |scope|
+              handle = scope[@handle] || @handle
+
+              page = case handle
+              when Locomotive::Mounter::Models::Page          then handle
+              when Liquid::Drops::Page                        then handle.instance_variable_get(:@_source)
+              when String                                     then fetch_page(mounting_point, handle)
+              when Liquid::Drops::ContentEntry                then fetch_page(mounting_point, handle.instance_variable_get(:@_source), true)
+              when Locomotive::Mounter::Models::ContentEntry  then fetch_page(mounting_point, handle, true)
+              else
+                nil
+              end
+
+              return page unless page.nil?
+            end
+
+            nil
+          end
+
+          def fetch_page(mounting_point, handle, templatized = false)
+            ::Locomotive::Mounter.with_locale(@_options['locale']) do
+              if templatized
+                page = mounting_point.pages.values.find do |_page|
+                  _page.templatized? &&
+                  !_page.templatized_from_parent &&
+                  _page.content_type.slug == handle.content_type.slug &&
+                  (@_options['with'].nil? || _page.handle == @_options['with'])
+                end
+
+                page.content_entry = handle if page
+
+                page
+              else
+                mounting_point.pages.values.find { |_page| _page.handle == handle }
+              end
+            end
+          end
+
+          def public_page_fullpath(context, page)
+            mounting_point  = context.registers[:mounting_point]
+            locale          = @_options['locale'] || ::I18n.locale
+
+            if !page.translated_in?(locale)
+              title = page.title_translations.values.compact.first
+              raise Liquid::PageNotTranslated.new(%{the "#{title}" page is not translated in #{locale.upcase}})
+            end
+
+            fullpath = ::Locomotive::Mounter.with_locale(locale) do
+              page.fullpath.clone
+            end
+
+            fullpath = "#{locale}/#{fullpath}" if locale.to_s != mounting_point.default_locale.to_s
+
+            if page.templatized?
+              if page.content_entry._slug.nil?
+                title = %{#{page.content_entry.content_type.name.singularize} "#{page.content_entry.send(page.content_entry.content_type.label_field_name)}"}
+                raise Liquid::ContentEntryNotTranslated.new(%{the #{title} slug is not translated in #{locale.upcase}})
+              end
+              fullpath.gsub!(/(content[_-]type[_-]template|template)/, page.content_entry._slug)
+            end
+
+            File.join('/', fullpath)
+          end
+
+        end
+      end
+
+    end
+  end
+end