locomotivecms_wagon 1.2.2 → 1.3.0

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

@@ -18,13 +18,13 @@ module Locomotive
 
           attr_accessor :current_page, :mounting_point
 
-          def initialize(tag_name, markup, tokens, context)
+          def initialize(tag_name, markup, tokens, options)
             if markup =~ Syntax
               @source = ($1 || 'page').gsub(/"|'/, '')
 
-              self.set_options(markup, context)
+              self.set_options(markup, options)
             else
-              raise ::Liquid::SyntaxError.new("Syntax Error in 'nav' - Valid syntax: nav <site|parent|page|<path to a page>> <options>")
+              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.nav"), options[:line])
             end
 
             super
@@ -39,7 +39,7 @@ module Locomotive
             if self.no_wrapper?
               output
             else
-              self.render_tag(:nav, id: @options[:id], css: @options[:class]) do
+              self.render_tag(:nav, id: @_options[:id], css: @_options[:class]) do
                 self.render_tag(:ul) { output }
               end
             end
@@ -92,8 +92,8 @@ module Locomotive
           def include_page?(page)
             if !page.listed? || page.templatized? || !page.published?
               false
-            elsif @options[:exclude]
-              (page.fullpath =~ @options[:exclude]).nil?
+            elsif @_options[:exclude]
+              (page.fullpath =~ @_options[:exclude]).nil?
             else
               true
             end
@@ -118,7 +118,7 @@ module Locomotive
           # @return [ Boolean ] True if the children have to be rendered.
           #
           def render_children_for_page?(page, depth)
-            depth.succ <= @options[:depth].to_i &&
+            depth.succ <= @_options[:depth].to_i &&
             (page.children || []).select { |child| self.include_page?(child) }.any?
           end
 
@@ -130,12 +130,12 @@ module Locomotive
           # @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
+            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'
+            elsif @_options[:icon] == 'after'
               "#{title} #{icon}"
             else
               "#{icon} #{title}"
@@ -165,7 +165,7 @@ module Locomotive
           #
           def entry_css(page, css = '')
             _css = 'link'
-            _css += " #{page} #{@options[:active_class]}" if self.page_selected?(page)
+            _css += " #{page} #{@_options[:active_class]}" if self.page_selected?(page)
 
             (_css + " #{css}").strip
           end
@@ -192,7 +192,7 @@ module Locomotive
             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) : ''
+              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
@@ -209,7 +209,7 @@ module Locomotive
             css     = self.bootstrap? ? 'dropdown-menu' : ''
 
             unless entries.empty?
-              self.render_tag(:ul, id: "#{@options[:id]}-#{page.slug.to_s.dasherize}", css: css) do
+              self.render_tag(:ul, id: "#{@_options[:id]}-#{page.slug.to_s.dasherize}", css: css) do
                 self.build_entries_output(entries, depth)
               end
             else
@@ -219,16 +219,16 @@ module Locomotive
 
           # Set the value (default or assigned by the tag) of the options.
           #
-          def set_options(markup, context)
-            @options = { id: 'nav', class: '', active_class: 'on', bootstrap: false, no_wrapper: false }
+          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(/"|'/, '') }
+            markup.scan(::Liquid::TagAttributes) { |key, value| @_options[key.to_sym] = value.gsub(/"|'/, '') }
 
-            @options[:exclude] = Regexp.new(@options[:exclude]) if @options[:exclude]
+            @_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
+            if @_options[:snippet]
+              if template = self.parse_snippet_template(options, @_options[:snippet])
+                @_options[:liquid_render] = template
               end
             end
           end
@@ -272,11 +272,11 @@ module Locomotive
           end
 
           def bootstrap?
-            @options[:bootstrap].to_bool
+            @_options[:bootstrap].to_bool
           end
 
           def no_wrapper?
-            @options[:no_wrapper].to_bool
+            @_options[:no_wrapper].to_bool
           end
 
           ::Liquid::Template.register_tag('nav', Nav)

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

@@ -18,12 +18,12 @@ module Locomotive
 
           Syntax = /(#{::Liquid::Expression}+)\s+by\s+([0-9]+)/
 
-          def initialize(tag_name, markup, tokens, context)
+          def initialize(tag_name, markup, tokens, options)
             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>")
+              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.paginate"), options[:line])
             end
 
             super

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

@@ -0,0 +1,41 @@
+module Locomotive
+  module Wagon
+    module Liquid
+      module Tags
+
+        # Assign sets a variable in your session.
+        #
+        #   {% session_assign foo = 'monkey' %}
+        #
+        # You can then use the variable later in the page.
+        #
+        #   {{ session.foo }}
+        #
+        class SessionAssign < ::Liquid::Tag
+          Syntax = /(#{::Liquid::VariableSignature}+)\s*=\s*(#{::Liquid::QuotedFragment}+)/
+
+          def initialize(tag_name, markup, tokens, options)
+            if markup =~ Syntax
+              @to = $1
+              @from = $2
+            else
+              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.session_assign"), options[:line])
+            end
+
+            super
+          end
+
+          def render(context)
+            request = context.registers[:request]
+
+            request.session[@to.to_sym] = context[@from]
+            ''
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('session_assign', SessionAssign)
+      end
+    end
+  end
+end

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

@@ -6,15 +6,14 @@ module Locomotive
         class Snippet < ::Liquid::Include
 
           def render(context)
-            name = @template_name.gsub(/[\"\']/, '')
+            name    = @template_name.gsub(/[\"\']/, '')
+            snippet = context.registers[:mounting_point].snippets[name]
 
-            source = context.registers[:mounting_point].snippets[name].try(:source)
+            raise ::Liquid::StandardError.new("Unknown snippet \"#{name}\"") if snippet.nil?
 
-            Locomotive::Wagon::Logger.info "  Rendered snippet #{name}"
+            partial   = self.parse_template(snippet)
 
-            partial = ::Liquid::Template.parse(source)
-
-            variable = context[@variable_name || @template_name[1..-2]]
+            variable  = context[@variable_name || @template_name[1..-2]]
 
             context.stack do
               @attributes.each do |key, value|
@@ -31,10 +30,30 @@ module Locomotive
                 partial.render(context)
               end)
 
+              Locomotive::Wagon::Logger.info "  Rendered snippet #{name}"
+
               output
             end
           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
+          end
+
         end
 
         ::Liquid::Template.register_tag('include', Snippet)

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

@@ -4,19 +4,20 @@ module Locomotive
       module Tags
         class WithScope < ::Liquid::Block
 
-          def initialize(tag_name, markup, tokens, context)
-            @options = {}
+          SlashedString = /\/[^\/]*\//
+          TagAttributes = /(\w+|\w+\.\w+)\s*\:\s*(#{SlashedString}|#{::Liquid::QuotedFragment})/
 
-            markup.scan(::Liquid::TagAttributes) do |key, value|
-              @options[key] = value
+          def initialize(tag_name, markup, tokens, options)
+            @tag_options = HashWithIndifferentAccess.new
+            markup.scan(TagAttributes) do |key, value|
+              @tag_options[key] = value
             end
-
             super
           end
 
           def render(context)
             context.stack do
-              context['with_scope'] = decode(@options, context)
+              context['with_scope'] = decode(@tag_options, context)
               render_all(@nodelist, context)
             end
           end
@@ -26,8 +27,8 @@ module Locomotive
           def decode(attributes, context)
             attributes.each_pair do |key, value|
               attributes[key] = (case value
-              when /^true|false$/i then value == 'true'
-              when /^[0-9]+$/ then value.to_i
+              when /^true|false$/i    then value == 'true'
+              when /^\/[^\/]*\/$/     then Regexp.new(value[1..-2])
               when /^["|'](.+)["|']$/ then $1.gsub(/^["|']/, '').gsub(/["|']$/, '')
               else
                 context[value] || value

data/lib/locomotive/wagon/misc.rb

@@ -2,4 +2,8 @@ require 'locomotive/wagon/misc/core_ext.rb'
 require 'locomotive/wagon/misc/will_paginate.rb'
 require 'locomotive/wagon/misc/httparty.rb'
 require 'locomotive/wagon/misc/dragonfly.rb'
-require 'locomotive/wagon/misc/i18n.rb'
+require 'locomotive/wagon/misc/i18n.rb'
+require 'locomotive/wagon/misc/mounter.rb'
+require 'locomotive/wagon/misc/markdown.rb'
+require 'locomotive/wagon/misc/haml.rb'
+require 'locomotive/wagon/misc/better_errors.rb'

data/lib/locomotive/wagon/misc/better_errors.rb

@@ -0,0 +1,70 @@
+require 'ostruct'
+
+module BetterErrors
+  class MiddlewareWrapper
+
+    def initialize(app)
+      @@middleware ||= BetterErrors::Middleware.new(app)
+      @@middleware.instance_variable_set(:@app, app)
+    end
+
+    def call(env)
+      env['action_dispatch.request.parameters'] = Rack::Request.new(env).params
+
+      @@middleware.call(env)
+    end
+
+  end
+
+  module FrameWithLiquidContext
+
+    extend ActiveSupport::Concern
+
+    included do
+
+      attr_accessor :liquid_context
+
+      alias_method_chain :local_variables, :liquid_context
+
+      class << self
+
+        alias_method_chain :from_exception, :liquid_context
+
+      end
+    end
+
+    def local_variables_with_liquid_context
+      if self.liquid_context
+        scope = self.liquid_context.scopes.last.clone
+
+        scope.delete_if { |k, _| %w(models contents params session).include?(k) }.tap do |_scope|
+          _scope['site'] = _scope['site']._source.to_hash
+          _scope['page'] = _scope['page'].to_hash.delete_if { |k, _| %w(template).include?(k) }
+        end
+      else
+        self.local_variables_without_liquid_context
+      end
+    rescue Exception => e
+      puts "[BetterError] Fatal error: #{e.message}".red
+      puts e.backtrace.join("\n")
+      {}
+    end
+
+    module ClassMethods
+
+      def from_exception_with_liquid_context(exception)
+        from_exception_without_liquid_context(exception).tap do |list|
+          if exception.respond_to?(:liquid_context)
+            list.first.liquid_context = exception.liquid_context
+          end
+        end
+      end
+
+    end
+  end
+
+  class StackFrame
+    include FrameWithLiquidContext
+  end
+
+end

data/lib/locomotive/wagon/misc/core_ext.rb

@@ -44,4 +44,11 @@ unless String.instance_methods.include?(:to_bool)
   class FalseClass
     def to_bool; self; end
   end
-end
+end
+
+unless Array.instance_methods.include?(:contains?)
+  class Array
+    def contains?(other); (self & other) == other; end
+  end
+end
+

data/lib/locomotive/wagon/misc/haml.rb

@@ -0,0 +1,15 @@
+module Haml::Filters
+
+  remove_filter("Markdown") #remove the existing Markdown filter
+
+  module Markdown # the contents of this are as before, but without the lazy_require call
+
+    include Haml::Filters::Base
+
+    def render text
+      Locomotive::Wagon::Markdown.render text
+    end
+
+  end
+
+end

data/lib/locomotive/wagon/misc/markdown.rb

@@ -0,0 +1,27 @@
+require 'redcarpet'
+
+module Locomotive
+  module Wagon
+    module Markdown
+
+      def self.render(text)
+        self.parser.render(text)
+      end
+
+      def self.parser
+        @@markdown ||= Redcarpet::Markdown.new Redcarpet::Render::HTML, {
+          autolink:         true,
+          fenced_code:      true,
+          generate_toc:     true,
+          gh_blockcode:     true,
+          hard_wrap:        true,
+          no_intraemphasis: true,
+          strikethrough:    true,
+          tables:           true,
+          xhtml:            true
+        }
+      end
+
+    end
+  end
+end

data/lib/locomotive/wagon/misc/mounter.rb

@@ -0,0 +1,32 @@
+module Locomotive
+  module Mounter
+    module Models
+      class Page
+
+        def render(context)
+          self.parse(context).render(context)
+        end
+
+        protected
+
+        def parse(context)
+          options =  {
+            page:           self,
+            mounting_point: context.registers[:mounting_point],
+            error_mode:     :strict,
+            count_lines:    true
+          }
+
+          begin
+            template = ::Liquid::Template.parse(self.source, options)
+          rescue Liquid::SyntaxError => e
+            # do it again on the raw source instead so that the error line matches
+            # the source file.
+            ::Liquid::Template.parse(self.template.raw_source, options)
+          end
+        end
+
+      end
+    end
+  end
+end