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

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

@@ -2,26 +2,38 @@ module Locomotive
   module Steam
     module Liquid
       module Tags
+
         class Hybrid < ::Liquid::Block
+
+          def render_as_block?
+            @render_as_block
+          end
+
           def parse(tokens)
-            nesting = 0
+            if @render_as_block = find_block_delimiter?(tokens)
+              super
+            else
+              @body  = nil
+              @blank = false
+            end
+          end
+
+          def find_block_delimiter?(tokens)
             tokens.each do |token|
-              next unless token =~ IsTag
-              if token =~ FullToken
-                if nesting == 0 && $1 == block_delimiter
-                  @render_as_block = true
-                  super
-                  return
-                elsif $1 == block_name
-                  nesting += 1
-                elsif $1 == block_delimiter
-                  nesting -= 1
+              next if token.empty?
+              if token.start_with?(::Liquid::BlockBody::TAGSTART)
+                if token =~ ::Liquid::BlockBody::FullToken
+                  return false  if $1 == @tag_name
+                  return true   if $1 == block_delimiter
                 end
               end
             end
+            false
           end
+
         end
+
       end
     end
   end
-end
+end

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

@@ -0,0 +1,39 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+        class InheritedBlock < ::Liquid::InheritedBlock
+
+          def parse(tokens)
+            super.tap do
+              if listener = options[:events_listener]
+                listener.emit(:inherited_block, page: options[:page], name: @name, found_super: self.contains_super?(nodelist))
+              end
+            end
+          end
+
+          protected
+
+          def contains_super?(nodes)
+            nodes.any? do |node|
+              if is_node_block_super?(node)
+                true
+              elsif node.respond_to?(:nodelist) && !node.nodelist.nil? && !node.is_a?(Locomotive::Steam::Liquid::Tags::InheritedBlock)
+                contains_super?(node.nodelist)
+              end
+            end
+          end
+
+          def is_node_block_super?(node)
+            return unless node.is_a?(::Liquid::Variable)
+
+            node.raw.strip == 'block.super'
+          end
+
+        end
+
+        ::Liquid::Template.register_tag('block'.freeze, InheritedBlock)
+      end
+    end
+  end
+end

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

@@ -2,15 +2,25 @@ module Locomotive
   module Steam
     module Liquid
       module Tags
-        class InlineEditor < ::Liquid::Tag
 
-          def render(context)
+        # Add custom CSS and JS to let the logged in users
+        # edit their page directly from the page it self.
+        #
+        # @deprecated
+        #
+        class InlineEditor < Solid::Tag
+
+          tag_name :inline_editor
+
+          def display
+            Locomotive::Common::Logger.warn %(The inline_editor liquid tag is no more used.).yellow
             ''
           end
+
         end
 
-        ::Liquid::Template.register_tag('inline_editor', InlineEditor)
       end
     end
   end
-end
+end
+

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

@@ -4,46 +4,35 @@ module Locomotive
       module Tags
         class LinkTo < Hybrid
 
-          Syntax = /(#{::Liquid::Expression}+)(#{::Liquid::TagAttributes}?)/
-
-          include PathHelper
-
-          def initialize(tag_name, markup, tokens, options)
-            if markup =~ Syntax
-              @handle = $1
-              @_options = {}
-              markup.scan(::Liquid::TagAttributes) do |key, value|
-                @_options[key] = value
-              end
-            else
-              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.link_to"), options[:line])
-            end
-
-            super
-          end
+          include Concerns::I18nPage
+          include Concerns::Path
 
           def render(context)
             render_path(context) do |page, path|
               label = label_from_page(page)
 
-              if @render_as_block
-                context.scopes.last['target'] = page
-                label = super.html_safe
+              if render_as_block?
+                context.stack do
+                  context.scopes.last['target'] = page
+                  label = super.html_safe
+                end
               end
 
               %{<a href="#{path}">#{label}</a>}
             end
           end
 
+          def wrong_syntax!
+            raise SyntaxError.new("Syntax Error in 'link_to' - Valid syntax: link_to page_handle, locale es (locale is optional)")
+          end
+
           protected
 
           def label_from_page(page)
-            ::Locomotive::Mounter.with_locale(@_options['locale']) do
-              if page.templatized?
-                page.content_entry._label
-              else
-                page.title
-              end
+            if page.templatized?
+              page.send(:_source).content_entry._label
+            else
+              page.title
             end
           end
 
@@ -53,4 +42,4 @@ module Locomotive
       end
     end
   end
-end
+end

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

@@ -2,6 +2,7 @@ module Locomotive
   module Steam
     module Liquid
       module Tags
+
         # Display the links to change the locale of the current page
         #
         # Usage:
@@ -18,89 +19,77 @@ module Locomotive
         #   - "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, options)
-            @_options = { label: 'iso', sep: ' | ' }
+        class LocaleSwitcher < Solid::Tag
 
-            if markup =~ Syntax
-              markup.scan(::Liquid::TagAttributes) { |key, value| @_options[key.to_sym] = value.gsub(/"|'/, '') }
+          include Concerns::I18nPage
 
-              @_options[:exclude] = Regexp.new(@_options[:exclude]) if @_options[:exclude]
-            else
-              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.locale_switcher"), options[:line])
-            end
+          tag_name :locale_switcher
 
-            super
+          def display(*values)
+            @options = { label: 'iso', sep: ' | ' }.merge(values.first || {})
+            %{<div id="locale-switcher">#{build_site_locales}</div>}
           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
+          private
 
-                css = link_class(locale, context['locale'])
+          def build_site_locales
+            site.locales.map do |locale|
+              change_page_locale(locale, page) do
+                css   = link_class(locale)
+                path  = link_path(locale)
 
-                %(<a href="/#{fullpath}" class="#{css}">#{link_label(locale)}</a>)
+                %(<a href="#{path}" class="#{css}">#{link_label(locale)}</a>)
               end
-            end.join(@_options[:sep])
-
-            output += %(</div>)
+            end.join(@options[:sep])
           end
 
-          private
-
-          def link_class(locale, current_locale)
+          def link_class(locale)
             css = [locale]
-            css << 'current' if locale.to_s == current_locale.to_s
+            css << 'current' if locale.to_sym == current_locale.to_sym
             css.join(' ')
           end
 
+          def link_path(locale)
+            url_builder.url_for(page.send(:_source), locale)
+          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
+            case @options[:label]
+            when 'locale' then I18n.t("locomotive.locales.#{locale}")
+            when 'title' then page_title
             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
+          def page_title
+            if page.templatized?
+              page.send(:_source).content_entry._label
             else
-              File.join(locale, fullpath)
+              page.title
             end
           end
 
+          def site
+            @site ||= current_context.registers[:site]
+          end
+
+          def page
+            @page ||= current_context['page']
+          end
+
+          def url_builder
+            current_context.registers[:services].url_builder
+          end
+
+          def current_locale
+            @current_locale ||= current_context.registers[:locale]
+          end
+
         end
 
-        ::Liquid::Template.register_tag('locale_switcher', LocaleSwitcher)
       end
     end
   end
-end
+end

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

@@ -0,0 +1,72 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+
+        # Display the form html tag with the appropriate hidden fields in order to create
+        # a content entry from a public site.
+        # It handles callbacks, csrf and target url out of the box.
+        #
+        # Usage:
+        #
+        # {% model_form 'newsletter_addresses' %}
+        #    <input type='text' name='content[email]' />
+        #     <input type='submit' value='Add' />
+        # {% endform_form %}
+        #
+        # {% model_form 'newsletter_addresses', class: 'a-css-class', success: 'http://www.google.fr', error: '/error' %}...{% endform_form %}
+        #
+        class ModelForm < Solid::Block
+
+          tag_name :model_form
+
+          def display(*options, &block)
+            name    = options.shift
+            options = options.shift || {}
+
+            form_attributes = { method: 'POST', enctype: 'multipart/form-data' }.merge(options.slice(:id, :class))
+
+            html_content_tag :form,
+              content_type_html(name) + csrf_html + callbacks_html(options) + yield,
+              form_attributes
+          end
+
+          def content_type_html(name)
+            html_tag :input, type: 'hidden', name: 'content_type_slug', value: name
+          end
+
+          def csrf_html
+            service = current_context.registers[:services].csrf_protection
+
+            html_tag :input, type: 'hidden', name: service.field, value: service.token
+          end
+
+          def callbacks_html(options)
+            options.slice(:success, :error).map do |(name, value)|
+              html_tag :input, type: 'hidden', name: "#{name}_callback", value: value
+            end.join('')
+          end
+
+          private
+
+          def html_content_tag(name, content, options = {})
+            "<#{name} #{inline_options(options)}>#{content}</#{name}>"
+          end
+
+          def html_tag(name, options = {})
+            "<#{name} #{inline_options(options)} />"
+          end
+
+          # Write options (Hash) into a string according to the following pattern:
+          # <key1>="<value1>", <key2>="<value2", ...etc
+          def inline_options(options = {})
+            return '' if options.empty?
+            (options.stringify_keys.to_a.collect { |a, b| "#{a}=\"#{b}\"" }).join(' ')
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -14,26 +14,28 @@ module Locomotive
         #
         class Nav < ::Liquid::Tag
 
-          Syntax = /(#{::Liquid::Expression}+)?/
+          Syntax = /(#{::Liquid::VariableSignature}+)/o
 
-          attr_accessor :current_page, :site
+          attr_accessor :current_site, :current_page, :current_locale, :services, :page_repository
 
-          def initialize(tag_name, markup, tokens, options)
-            if markup =~ Syntax
-              @source = ($1 || 'page').gsub(/"|'/, '')
+          def initialize(tag_name, markup, options)
+            markup =~ Syntax
 
-              self.set_options(markup, options)
-            else
-              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.nav"), options[:line])
-            end
+            @source = ($1 || 'page').gsub(/"|'/, '')
+
+            self.set_options(markup, options)
 
             super
           end
 
           def render(context)
-            self.set_accessors_from_context(context)
-            entries = self.fetch_entries
-            output  = self.build_entries_output(entries)
+            self.set_vars_from_context(context)
+
+            set_template_if_asked
+
+            # get all the children of a source: site (index page), parent or page.
+            pages   = children_of(fetch_starting_page)
+            output  = self.build_entries_output(pages)
 
             if self.no_wrapper?
               output
@@ -48,17 +50,17 @@ module Locomotive
 
           # Build recursively the links of all the pages.
           #
-          # @param [ Array ] entries List of pages
+          # @param [ Array ] pages List of pages
           #
           # @return [ String ] The final HTML output
           #
-          def build_entries_output(entries, depth = 1)
+          def build_entries_output(pages, depth = 1)
             output  = []
 
-            entries.each_with_index do |page, index|
+            pages.each_with_index do |page, index|
               css = []
               css << 'first'  if index == 0
-              css << 'last'   if index == entries.size - 1
+              css << 'last'   if index == pages.size - 1
 
               output << self.render_entry_link(page, css.join(' '), depth)
             end
@@ -66,24 +68,26 @@ module Locomotive
             output.join("\n")
           end
 
-          # Get all the children of a source: site (index page), parent or page.
+          # Get the first page used to list all the children.
+          # It depends on the source: site, parent, page or a fullpath
           #
-          # @return [ Array ] List of pages
-          #
-          def fetch_entries
-            children = root.children.try(:clone) || []
-            children.delete_if { |p| !include_page?(p) }
-          end
-
-          def root
+          def fetch_starting_page
             case @source
-            when 'site'     then Locomotive::Models['pages']['index']
-            when 'parent'   then self.current_page.parent || self.current_page
-            when 'page'     then self.current_page
+            when 'site'    then page_repository.root
+            when 'parent'  then page_repository.parent_of(current_page) || current_page
+            when 'page'    then current_page
             else
-              Locomotive::Models['pages'][@source]
+              page_repository.by_fullpath(@source)
             end
           end
+
+          # Get all the children of page. It filters the collection
+          # to only return pages which will be displayed in the nav.
+          def children_of(page)
+            children  = (page_repository.children_of(page) || [])
+            children.select { |child| self.include_page?(child) }
+          end
+
           # Determine whether or not a page should be a part of the menu.
           #
           # @param [ Object ] page The page
@@ -119,8 +123,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 &&
-            (page.children || []).select { |child| self.include_page?(child) }.any?
+            depth.succ <= @_options[:depth].to_i && children_of(page).any?
           end
 
           # Return the label of an entry. It may use or not the template
@@ -150,26 +153,21 @@ module Locomotive
           # @return [ String ] The localized url
           #
           def entry_url(page)
-            if ::I18n.locale.to_s == self.site.default_locale.to_s
-              "/#{page.fullpath}"
-            else
-              "/#{::I18n.locale}/#{page.fullpath}"
-            end
+            services.url_builder.url_for(page)
           end
 
           # Return the css of an entry (page).
           #
           # @param [ Object ] page The page
-          # @param [ String ] css The extra css
+          # @param [ String ] extra_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 += " #{@_options[:active_class]}" if self.page_selected?(page)
-
-            (_css + " #{css}").strip
+          def entry_css(page, extra_css = '')
+            ['link'].tap do |css|
+              css << @_options[:active_class] if self.page_selected?(page)
+              css << extra_css if !extra_css.blank?
+            end.join ' '
           end
 
           # Return the HTML output of a page and its children if requested.
@@ -181,6 +179,7 @@ module Locomotive
           # @return [ String ] The HTML output
           #
           def render_entry_link(page, css, depth)
+            page      = decorate_page(page)
             url       = self.entry_url(page)
             label     = self.entry_label(page)
             css       = self.entry_css(page, css)
@@ -193,7 +192,7 @@ module Locomotive
               options   = %{ class="dropdown-toggle" data-toggle="dropdown"}
             end
 
-            self.render_tag(:li, id: "#{page.slug.dasherize}-link", css: css) do
+            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
@@ -207,11 +206,11 @@ module Locomotive
           # @return [ String ] The HTML code
           #
           def render_entry_children(page, depth)
-            entries = (page.children || []).select { |child| self.include_page?(child) }
+            entries = children_of(page)
             css     = self.bootstrap? ? 'dropdown-menu' : ''
 
             unless entries.empty?
-              self.render_tag(:ul, id: "#{@_options[:id]}-#{page.slug.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
@@ -227,37 +226,41 @@ module Locomotive
             markup.scan(::Liquid::TagAttributes) { |key, value| @_options[key.to_sym] = value.gsub(/"|'/, '') }
 
             @_options[:exclude] = Regexp.new(@_options[:exclude]) if @_options[:exclude]
+          end
 
+          def set_template_if_asked
             if @_options[:snippet]
-              if template = self.parse_snippet_template(options, @_options[:snippet])
+              if template = parse_snippet_template(@_options[:snippet])
                 @_options[:liquid_render] = template
               end
             end
           end
 
-          # Avoid to call context.registers to get the current page
-          # and the site.
+          # Avoid to call context.registers to get the current page.
           #
-          def set_accessors_from_context(context)
-            self.current_page   = context.registers[:page]
-            self.site = context.registers[:site]
+          def set_vars_from_context(context)
+            self.current_site       = context.registers[:site]
+            self.current_page       = context.registers[:page]
+            self.services           = context.registers[:services]
+            self.current_locale     = context.registers[:locale]
+            self.page_repository    = self.services.repositories.page
           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?('{')
+          def parse_snippet_template(template_name)
+            source = if template_name.include?('{{')
               template_name
             else
-              context[:site].snippets[template_name].try(:source)
+              services.snippet_finder.find(template_name).try(:source)
             end
 
             source ? ::Liquid::Template.parse(source) : nil
           end
 
-          # Steam any kind HTML tags. The content of the tag comes from
+          # Render 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).
@@ -273,6 +276,11 @@ module Locomotive
             %{<#{tag_name}#{options.join(' ')}>#{yield}</#{tag_name}>}
           end
 
+          def decorate_page(page)
+            klass = Locomotive::Steam::Decorators::I18nDecorator
+            klass.new(page, current_locale, current_site.default_locale)
+          end
+
           def bootstrap?
             @_options[:bootstrap].to_bool
           end
@@ -281,7 +289,7 @@ module Locomotive
             @_options[:no_wrapper].to_bool
           end
 
-          ::Liquid::Template.register_tag('nav', Nav)
+          ::Liquid::Template.register_tag('nav'.freeze, Nav)
         end
       end
     end