locomotivecms_wagon 1.0.0

data/lib/locomotive/wagon/liquid/filters/translate.rb

@@ -0,0 +1,24 @@
+module Locomotive
+  module Wagon
+    module Liquid
+      module Filters
+        module Translate
+
+          def translate(key, locale = nil)
+            translation = @context.registers[:mounting_point].translations[key.to_s]
+
+            if translation
+              translation.get(locale) || translation.get(Locomotive::Mounter.locale)
+            else
+              "[unknown translation key: #{key}]"
+            end
+          end
+
+        end
+
+        ::Liquid::Template.register_filter(Translate)
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Liquid
+
+  class Drop
+
+    def mounting_point
+      @context.registers[:mounting_point]
+    end
+
+    def site
+      @context.registers[:site]
+    end
+
+  end
+
+  class Template
+
+    # creates a new <tt>Template</tt> object from liquid source code
+    def parse_with_utf8(source, context = {})
+      if RUBY_VERSION =~ /1\.9/
+        source = source.force_encoding('UTF-8') if source.present?
+      end
+      self.parse_without_utf8(source, context)
+    end
+
+    alias_method_chain :parse, :utf8
+
+  end
+
+  module StandardFilters
+
+    private
+
+    def to_number(obj)
+      case obj
+      when Numeric
+        obj
+      when String
+        (obj.strip =~ /^\d+\.\d+$/) ? obj.to_f : obj.to_i
+      when DateTime, Date, Time
+        obj.to_time.to_i
+      else
+        0
+      end
+    end
+  end
+
+end

data/lib/locomotive/wagon/liquid/tags/consume.rb

@@ -0,0 +1,58 @@
+module Locomotive
+  module Wagon
+    module Liquid
+        module Tags
+
+        # Consume web services as easy as pie directly in liquid !
+        #
+        # Usage:
+        #
+        # {% consume blog from 'http://nocoffee.tumblr.com/api/read.json?num=3' username: 'john', password: 'easy', format: 'json', expires_in: 3000 %}
+        #   {% for post in blog.posts %}
+        #     {{ post.title }}
+        #   {% endfor %}
+        # {% endconsume %}
+        #
+        class Consume < ::Liquid::Block
+
+          Syntax = /(#{::Liquid::VariableSignature}+)\s*from\s*(#{::Liquid::QuotedString}+)/
+
+          def initialize(tag_name, markup, tokens, context)
+            if markup =~ Syntax
+              @target = $1
+              @url = $2.gsub(/['"]/, '')
+              @options = {}
+              markup.scan(::Liquid::TagAttributes) do |key, value|
+                @options[key] = value if key != 'http'
+              end
+              @options.delete('expires_in')
+            else
+              raise ::Liquid::SyntaxError.new("Syntax Error in 'consume' - Valid syntax: consume <var> from \"<url>\" [username: value, password: value]")
+            end
+
+            super
+          end
+
+          def render(context)
+            context.stack do
+              _response = nil
+
+              begin
+                _response = Locomotive::Wagon::Httparty::Webservice.consume(@url, @options.symbolize_keys)
+              rescue Exception => e
+                _response = { 'error' => e.message.to_s }.to_liquid
+              end
+
+              context.scopes.last[@target.to_s] = _response
+
+              render_all(@nodelist, context)
+            end
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('consume', Consume)
+      end
+    end
+  end
+end

data/lib/locomotive/wagon/liquid/tags/csrf.rb

@@ -0,0 +1,34 @@
+module Locomotive
+  module Wagon
+    module Liquid
+      module Tags
+        module Csrf
+
+          class Param < ::Liquid::Tag
+
+            def render(context)
+              %{<input type="hidden" name="authenticity_token" value="helloworld" />}
+            end
+
+          end
+
+          class Meta < ::Liquid::Tag
+
+            def render(context)
+              %{
+                <meta name="csrf-param" content="authenticity_token" />
+                <meta name="csrf-token" content="helloworld" />
+              }
+            end
+
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('csrf_param', Csrf::Param)
+        ::Liquid::Template.register_tag('csrf_meta', Csrf::Meta)
+
+      end
+    end
+  end
+end

data/lib/locomotive/wagon/liquid/tags/editable/base.rb

@@ -0,0 +1,46 @@
+module Locomotive
+  module Wagon
+    module Liquid
+      module Tags
+        module Editable
+          class Base < ::Liquid::Block
+
+            Syntax = /(#{::Liquid::QuotedFragment})(\s*,\s*#{::Liquid::Expression}+)?/
+
+            def initialize(tag_name, markup, tokens, context)
+              if markup =~ Syntax
+                @slug = $1.gsub(/[\"\']/, '')
+                @options = {}
+                markup.scan(::Liquid::TagAttributes) { |key, value| @options[key.to_sym] = value.gsub(/^'/, '').gsub(/'$/, '') }
+              else
+                raise ::Liquid::SyntaxError.new("Syntax Error in 'editable_xxx' - Valid syntax: editable_xxx <slug>(, <options>)")
+              end
+
+              super
+            end
+
+            def render(context)
+              current_page = context.registers[:page]
+
+              element = current_page.find_editable_element(context['block'].try(:name), @slug)
+
+              if element.present?
+                render_element(context, element)
+              else
+                super
+              end
+            end
+
+            protected
+
+            def render_element(context, element)
+              element.content
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/wagon/liquid/tags/editable/control.rb

@@ -0,0 +1,19 @@
+module Locomotive
+  module Wagon
+    module Liquid
+      module Tags
+        module Editable
+          class Control < Base
+
+            def render(context)
+              super
+            end
+
+          end
+
+          ::Liquid::Template.register_tag('editable_control', Control)
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/wagon/liquid/tags/editable/file.rb

@@ -0,0 +1,15 @@
+module Locomotive
+  module Wagon
+    module Liquid
+      module Tags
+        module Editable
+          class File < Base
+
+          end
+
+          ::Liquid::Template.register_tag('editable_file', File)
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/wagon/liquid/tags/editable/long_text.rb

@@ -0,0 +1,15 @@
+module Locomotive
+  module Wagon
+    module Liquid
+      module Tags
+        module Editable
+          class LongText < ShortText
+
+          end
+
+          ::Liquid::Template.register_tag('editable_long_text', LongText)
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/wagon/liquid/tags/editable/short_text.rb

@@ -0,0 +1,15 @@
+module Locomotive
+  module Wagon
+    module Liquid
+      module Tags
+        module Editable
+          class ShortText < Base
+
+          end
+
+          ::Liquid::Template.register_tag('editable_short_text', ShortText)
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/wagon/liquid/tags/editable.rb

@@ -0,0 +1,5 @@
+require 'locomotive/wagon/liquid/tags/editable/base'
+require 'locomotive/wagon/liquid/tags/editable/short_text'
+require 'locomotive/wagon/liquid/tags/editable/long_text'
+require 'locomotive/wagon/liquid/tags/editable/file'
+require 'locomotive/wagon/liquid/tags/editable/control'

data/lib/locomotive/wagon/liquid/tags/extends.rb

@@ -0,0 +1,25 @@
+module Locomotive
+  module Wagon
+    module Liquid
+      module Tags
+        class Extends < ::Liquid::Extends
+
+          def parse_parent_template
+            mounting_point = @context[:mounting_point]
+
+            page = if @template_name == 'parent'
+              @context[:page].parent
+            else
+              mounting_point.pages[@template_name]
+            end
+
+            ::Liquid::Template.parse(page.source, { mounting_point: mounting_point, page: page })
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('extends', Extends)
+      end
+    end
+  end
+end

data/lib/locomotive/wagon/liquid/tags/google_analytics.rb

@@ -0,0 +1,28 @@
+module Locomotive
+  module Wagon
+    module Liquid
+      module Tags
+        class GoogleAnalytics < ::Liquid::Tag
+
+          Syntax = /(#{::Liquid::Expression}+)?/
+
+          def initialize(tag_name, markup, tokens, context)
+            if markup =~ Syntax
+              @account_id = $1.gsub('\'', '')
+            else
+              raise ::Liquid::SyntaxError.new("Syntax Error in 'google_analytics' - Valid syntax: google_analytics <account_id>")
+            end
+
+            super
+          end
+
+          def render(context)
+           "<!-- google analytics for #{@account_id} -->"
+          end
+        end
+
+        ::Liquid::Template.register_tag('google_analytics', GoogleAnalytics)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Locomotive
+  module Wagon
+    module Liquid
+      module Tags
+        class InlineEditor < ::Liquid::Tag
+
+          def render(context)
+            ''
+          end
+        end
+
+        ::Liquid::Template.register_tag('inline_editor', InlineEditor)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+module Locomotive
+  module Wagon
+    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]
+            @default_locale = context.registers[:mounting_point].default_locale
+
+            output = %(<div id="locale-switcher">)
+
+            output += @site.locales.collect do |locale|
+              Locomotive::Mounter.with_locale(locale) do
+                fullpath = localized_fullpath(locale)
+
+                if @page.templatized?
+                  permalink = context['entry']._permalink
+
+                  if permalink
+                    fullpath.gsub!('*', permalink)
+                  else
+                    fullpath = '404'
+                  end
+                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.to_s == current_locale.to_s
+            css.join(' ')
+          end
+
+          def link_label(locale)
+            case @options[:label]
+            when 'iso'     then locale
+            when 'locale'  then I18n.t("locales.#{locale}")
+            when 'title'   then @page.title # FIXME: this returns nil if the page has not been translated in the locale
+            else
+              locale
+            end
+          end
+
+          def localized_fullpath(locale)
+            return nil if @page.fullpath_translations.blank?
+
+            fullpath = @page.safe_fullpath || @page.fullpath_or_default
+
+            if locale.to_s == @default_locale.to_s # no need to specify the locale
+              @page.index? ? '' : fullpath
+            elsif @page.index? # avoid /en/index or /fr/index, prefer /en or /fr instead
+              locale
+            else
+              File.join(locale, fullpath)
+            end
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('locale_switcher', LocaleSwitcher)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+module Locomotive
+  module Wagon
+    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, context)
+            if markup =~ Syntax
+              @source = ($1 || 'page').gsub(/"|'/, '')
+              @options = { :id => 'nav', :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]
+
+              if @options[:snippet]
+                if template = self.parse_snippet_template(context, @options[:snippet])
+                  @options[:liquid_render] = template
+                end
+              end
+            else
+              raise ::Liquid::SyntaxError.new("Syntax Error in 'nav' - Valid syntax: nav <site|parent|page|<path to a page>> <options>")
+            end
+
+            super
+          end
+
+          def render(context)
+            self.set_accessors_from_context(context)
+
+            children_output = []
+
+            entries = self.fetch_entries
+
+            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'
+              output = %{<ul id="#{@options[:id]}" class="#{@options[:class]}">\n#{output}</ul>}
+            end
+
+            output
+          end
+
+          protected
+
+          def set_accessors_from_context(context)
+            self.current_page   = context.registers[:page]
+            self.mounting_point = context.registers[:mounting_point]
+          end
+
+          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
+
+          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.clone
+
+            children.delete_if { |p| !include_page?(p) }
+          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
+
+          # Returns a list element, a link to the page and its children
+          def render_entry_link(page, css, depth)
+            selected = self.current_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' }}
+
+            dropdow = ""
+            link_options = ""
+            href = ::I18n.locale.to_s == self.mounting_point.default_locale.to_s ? "/#{page.fullpath}" : "/#{::I18n.locale}/#{page.fullpath}"
+            caret = ""
+
+            if render_children_for_page?(page, depth) && bootstrap?
+              dropdow = "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} #{dropdow}">}
+            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.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
+
+          def bootstrap?
+            @options[:bootstrap] == 'true' || @options[:bootstrap] == true
+          end
+
+          ::Liquid::Template.register_tag('nav', Nav)
+        end
+      end
+    end
+  end
+end