tribeca_cms 0.1.1

data/lib/locomotive/liquid/tags/inherited_block.rb

@@ -0,0 +1,31 @@
+module Locomotive
+  module Liquid
+    module Tags
+      class InheritedBlock < ::Liquid::InheritedBlock
+
+        def end_tag
+          super
+          
+          if !self.contains_super?(@nodelist) # then disable all editable_elements coming from the parent block too and not used
+            @context[:page].disable_parent_editable_elements(@name) unless @context[:page].nil?
+          end
+        end
+
+        protected
+
+        def contains_super?(nodelist)
+          nodelist.any? do |node|
+            if node.is_a?(::Liquid::Variable) && node.name == 'block.super'
+              true
+            elsif node.respond_to?(:nodelist) && !node.nodelist.nil? && !node.is_a?(Locomotive::Liquid::Tags::InheritedBlock) 
+              contains_super?(node.nodelist)
+            end
+          end
+        end
+
+      end
+
+      ::Liquid::Template.register_tag('block', InheritedBlock)
+    end
+  end
+end

data/lib/locomotive/liquid/tags/inline_editor.rb

@@ -0,0 +1,40 @@
+module Liquid
+  module Locomotive
+    module Tags
+      class InlineEditor < ::Liquid::Tag
+
+        def render(context)
+          if context.registers[:current_locomotive_account] && context.registers[:inline_editor]
+
+            plugins = 'common/format,common/table,common/list,common/link,common/highlighteditables,common/block,common/undo,common/contenthandler,common/paste,common/commands,common/abbr,common/align,common/horizontalruler,custom/locomotive_media'
+
+            controller = context.registers[:controller]
+            controller.instance_variable_set(:@plugins, plugins)
+
+            page = context.registers[:page].to_presenter.as_json_for_html_view
+            page['lang'] = context['locale']
+
+            html = <<-HTML
+              %meta{ :content => true, :name => 'inline-editor' }
+
+              = stylesheet_link_tag 'aloha/css/aloha.css'
+              = javascript_include_tag 'locomotive/aloha', :'data-aloha-plugins' => @plugins
+
+              %script{ :type => 'text/javascript' }
+                :plain
+                  Aloha.ready(function() \{
+                    window.parent.application_view.set_page(#{controller.view_context.j page.to_json.html_safe});
+                  \});
+            HTML
+
+            Haml::Engine.new(html.gsub(/\n+/, "\n").gsub(/^\s{14}/, ''), :escape_html => true).render(controller.view_context)
+          else
+            ''
+          end
+        end
+      end
+
+      ::Liquid::Template.register_tag('inline_editor', InlineEditor)
+    end
+  end
+end

data/lib/locomotive/liquid/tags/locale_switcher.rb

@@ -0,0 +1,83 @@
+module Locomotive
+  module Liquid
+    module Tags
+      # Display the links to change the locale of the current page
+      #
+      # Usage:
+      #
+      # {% locale_switcher %} => <div id="locale-switcher"><a href="/features" class="current en">Features</a><a href="/fr/fonctionnalites" class="fr">Fonctionnalités</a></div>
+      #
+      # {% locale_switcher label: locale, sep: ' - ' }
+      #
+      # options:
+      #   - label: iso (de, fr, en, ...etc), locale (Deutsch, Français, English, ...etc), title (page title)
+      #   - sep: piece of html code separating 2 locales
+      #
+      # notes:
+      #   - "iso" is the default choice for label
+      #   - " | " is the default separating code
+      #
+      class LocaleSwitcher < ::Liquid::Tag
+
+        Syntax = /(#{::Liquid::Expression}+)?/
+
+        def initialize(tag_name, markup, tokens, context)
+          @options = { :label => 'iso', :sep => ' | ' }
+
+          if markup =~ Syntax
+            markup.scan(::Liquid::TagAttributes) { |key, value| @options[key.to_sym] = value.gsub(/"|'/, '') }
+
+            @options[:exclude] = Regexp.new(@options[:exclude]) if @options[:exclude]
+          else
+            raise ::Liquid::SyntaxError.new("Syntax Error in 'locale_switcher' - Valid syntax: locale_switcher <options>")
+          end
+
+          super
+        end
+
+        def render(context)
+          @site, @page = context.registers[:site], context.registers[:page]
+
+          output = %(<div id="locale-switcher">)
+
+          output += @site.locales.collect do |locale|
+            ::Mongoid::Fields::I18n.with_locale(locale) do
+              fullpath = @site.localized_page_fullpath(@page, locale)
+
+              if @page.templatized?
+                fullpath.gsub!('content_type_template', context['entry']._permalink)
+              end
+
+              css = link_class(locale, context['locale'])
+
+              %(<a href="/#{fullpath}" class="#{css}">#{link_label(locale)}</a>)
+            end
+          end.join(@options[:sep])
+
+          output += %(</div>)
+        end
+
+        private
+
+        def link_class(locale, current_locale)
+          css = [locale]
+          css << 'current' if locale == current_locale
+          css.join(' ')
+        end
+
+        def link_label(locale)
+          case @options[:label]
+          when 'iso'     then locale
+          when 'locale'  then I18n.t("locomotive.locales.#{locale}", :locale => locale)
+          when 'title'   then @page.title # FIXME: this returns nil if the page has not been translated in the locale
+          else
+            locale
+          end
+        end
+
+      end
+
+      ::Liquid::Template.register_tag('locale_switcher', LocaleSwitcher)
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+module Locomotive
+  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.
+      #
+      # Passing through depth will control how many nested children are output
+      #
+      # 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}+)?/
+
+        def initialize(tag_name, markup, tokens, context)
+          if markup =~ Syntax
+            @source = ($1 || 'page').gsub(/"|'/, '')
+            @options = { :id => 'nav', :depth => 1, :class => '', :active_class => 'on', :bootstrap => false }
+            markup.scan(::Liquid::TagAttributes) { |key, value| @options[key.to_sym] = value.gsub(/"|'/, '') }
+
+            @options[:exclude] = Regexp.new(@options[:exclude]) if @options[:exclude]
+
+            @options[:add_attributes] = []
+            if @options[:snippet]
+              template = @options[:snippet].include?('{') ? @options[:snippet] : context[:site].snippets.where(:slug => @options[:snippet] ).try(:first).try(:template)
+              unless template.blank?
+                @options[:liquid_render] = ::Liquid::Template.parse(template)
+                @options[:add_attributes] = ['editable_elements']
+              end
+            end
+
+          else
+            raise ::Liquid::SyntaxError.new("Syntax Error in 'nav' - Valid syntax: nav <page|site> <options>")
+          end
+
+          super
+        end
+
+        def render(context)
+          children_output = []
+
+          entries = fetch_entries(context)
+
+          entries.each_with_index do |p, index|
+            css = []
+            css << 'first' if index == 0
+            css << 'last' if index == entries.size - 1
+
+            children_output << render_entry_link(p, css.join(' '), 1)
+          end
+
+          output = children_output.join("\n")
+
+          if @options[:no_wrapper] != 'true'
+            list_class  = !@options[:class].blank? ? %( class="#{@options[:class]}") : ''
+            output      = %{<nav id="#{@options[:id]}"#{list_class}><ul>\n#{output}</ul></nav>}
+          end
+
+          output
+        end
+
+        private
+
+        # Determines root node for the list
+        def fetch_entries(context)
+          @site, @page = context.registers[:site], context.registers[:page]
+
+          children = (case @source
+          when 'site'     then @site.pages.root.minimal_attributes(@options[:add_attributes]).first # start from home page
+          when 'parent'   then @page.parent || @page
+          when 'page'     then @page
+          else
+            @site.pages.fullpath(@source).minimal_attributes(@options[:add_attributes]).first
+          end).children_with_minimal_attributes(@options[:add_attributes]).to_a
+
+          children.delete_if { |p| !include_page?(p) }
+        end
+
+        # Returns a list element, a link to the page and its children
+        def render_entry_link(page, css, depth)
+          selected = @page.fullpath =~ /^#{page.fullpath}/ ? " #{@options[:active_class]}" : ''
+
+          icon = @options[:icon] ? '<span></span>' : ''
+
+          title = @options[:liquid_render] ? @options[:liquid_render].render('page' => page) : page.title
+
+          label = %{#{icon if @options[:icon] != 'after' }#{title}#{icon if @options[:icon] == 'after' }}
+
+          link_options = caret = ''
+          href = File.join('/', @site.localized_page_fullpath(page))
+
+          if render_children_for_page?(page, depth) && bootstrap?
+            css           += ' dropdown'
+            link_options  = %{ class="dropdown-toggle" data-toggle="dropdown"}
+            href          = '#'
+            caret         = %{ <b class="caret"></b>}
+          end
+
+          output  = %{<li id="#{page.slug.to_s.dasherize}-link" class="link#{selected} #{css}">}
+          output << %{<a href="#{href}"#{link_options}>#{label}#{caret}</a>}
+          output << render_entry_children(page, depth.succ) if (depth.succ <= @options[:depth].to_i)
+          output << %{</li>}
+
+          output.strip
+        end
+
+        def render_children_for_page?(page, depth)
+          depth.succ <= @options[:depth].to_i && page.children.reject { |c| !include_page?(c) }.any?
+        end
+
+        # Recursively creates a nested unordered list for the depth specified
+        def render_entry_children(page, depth)
+          output = %{}
+
+          children = page.children_with_minimal_attributes(@options[:add_attributes]).reject { |c| !include_page?(c) }
+          if children.present?
+            output = %{<ul id="#{@options[:id]}-#{page.slug.to_s.dasherize}" class="#{bootstrap? ? 'dropdown-menu' : ''}">}
+            children.each do |c, page|
+              css = []
+              css << 'first' if children.first == c
+              css << 'last'  if children.last  == c
+
+              output << render_entry_link(c, css.join(' '), depth)
+            end
+            output << %{</ul>}
+          end
+
+          output
+        end
+
+        # Determines whether or not a page should be a part of the menu
+        def include_page?(page)
+          if !page.listed? || page.templatized? || !page.published?
+            false
+          elsif @options[:exclude]
+            (page.fullpath =~ @options[:exclude]).nil?
+          else
+            true
+          end
+        end
+
+        def bootstrap?
+          @options[:bootstrap] == 'true'
+        end
+
+      end
+
+      ::Liquid::Template.register_tag('nav', Nav)
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+module Locomotive
+
+  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, context)
+          if markup =~ Syntax
+            @collection_name = $1
+            @per_page = $2.to_i
+          else
+            raise ::Liquid::SyntaxError.new("Syntax Error in 'paginate' - Valid syntax: paginate <collection> by <number>")
+          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?
+
+            if collection.is_a? Array
+              pagination = Kaminari.paginate_array(collection).page(context['current_page']).per(@per_page).to_liquid.stringify_keys
+            else
+              pagination = collection.send(:paginate, {
+                :page       => context['current_page'],
+                :per_page   => @per_page
+              }).to_liquid.stringify_keys
+            end
+            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

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

@@ -0,0 +1,72 @@
+module Locomotive
+  module Liquid
+    module Tags
+      module SEO
+
+        class Base < ::Liquid::Tag
+
+          def render(context)
+            %{
+              #{self.render_title(context)}
+              #{self.render_metadata(context)}
+            }
+          end
+
+          protected
+
+          def render_title(context)
+            title = self.value_for(:seo_title, context)
+            title = context.registers[:site].name if title.blank?
+
+            %{
+              <title>#{title}</title>
+            }
+          end
+
+          def render_metadata(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 charactets from the input
+          def sanitized_string(string)
+            string ? string.strip.gsub(/"/, '') : ''
+          end
+
+          def value_for(attribute, context)
+            object = self.metadata_object(context)
+            value = object.try(attribute.to_sym).blank? ? context.registers[:site].send(attribute.to_sym) : object.send(attribute.to_sym)
+            self.sanitized_string(value)
+          end
+
+          def metadata_object(context)
+            context['content_entry'] || context['page']
+          end
+        end
+
+        class Title < Base
+
+          def render(context)
+            self.render_title(context)
+          end
+
+        end
+
+        class Metadata < Base
+
+          def render(context)
+            self.render_metadata(context)
+          end
+
+        end
+
+      end
+
+      ::Liquid::Template.register_tag('seo', SEO::Base)
+      ::Liquid::Template.register_tag('seo_title', SEO::Title)
+      ::Liquid::Template.register_tag('seo_metadata', SEO::Metadata)
+    end
+  end
+end