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

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

@@ -4,31 +4,40 @@ module Locomotive
       module Tags
         module Csrf
 
-          class Param < ::Liquid::Tag
-
+          class Base < ::Liquid::Tag
             def render(context)
-              %{<input type="hidden" name="authenticity_token" value="helloworld" />}
-            end
+              service  = context.registers[:services].csrf_protection
 
+              if service.enabled?
+                render_csrf(service)
+
+              else
+                ''
+              end
+            end
           end
 
-          class Meta < ::Liquid::Tag
+          class Param < Base
+            def render_csrf(service)
+              %(<input type="hidden" name="#{service.field}" value="#{service.token}" />)
+            end
+          end
 
-            def render(context)
+          class Meta < Base
+            def render_csrf(service)
               %{
-                <meta name="csrf-param" content="authenticity_token" />
-                <meta name="csrf-token" content="helloworld" />
+                <meta name="csrf-param" content="#{service.field}" />
+                <meta name="csrf-token" content="#{service.token}" />
               }
             end
-
           end
 
         end
 
-        ::Liquid::Template.register_tag('csrf_param', Csrf::Param)
-        ::Liquid::Template.register_tag('csrf_meta', Csrf::Meta)
+        ::Liquid::Template.register_tag('csrf_param'.freeze, Csrf::Param)
+        ::Liquid::Template.register_tag('csrf_meta'.freeze, Csrf::Meta)
 
       end
     end
   end
-end
+end

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

@@ -1,6 +1,4 @@
 require_relative 'editable/base'
 require_relative 'editable/text'
-require_relative 'editable/short_text'
-require_relative 'editable/long_text'
 require_relative 'editable/file'
-require_relative 'editable/control'
+require_relative 'editable/control'

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

@@ -5,40 +5,79 @@ module Locomotive
         module Editable
           class Base < ::Liquid::Block
 
-            Syntax = /(#{::Liquid::QuotedFragment})(\s*,\s*#{::Liquid::Expression}+)?/
+            Syntax = /(#{::Liquid::QuotedFragment})(\s*,\s*#{::Liquid::Expression}+)?/o
 
-            def initialize(tag_name, markup, tokens, options)
+            attr_accessor :slug
+
+            def initialize(tag_name, markup, options)
               if markup =~ Syntax
-                @slug = $1.gsub(/[\"\']/, '')
-                @_options = {}
-                markup.scan(::Liquid::TagAttributes) { |key, value| @_options[key.to_sym] = value.gsub(/^'/, '').gsub(/'$/, '') }
+                @slug             = $1.gsub(/[\"\']/, '')
+                @element_options  = { fixed: false }
+                markup.scan(::Liquid::TagAttributes) { |key, value| @element_options[key.to_sym] = value.gsub(/^[\"\']/, '').gsub(/[\"\']$/, '') }
               else
-                raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.#{tag_name}"), options[:line])
+                raise ::Liquid::SyntaxError.new("Valid syntax: #{tag_name} <slug>(, <options>)")
               end
 
               super
             end
 
-            def render(context)
-              current_page = context.registers[:page]
+            def parse(tokens)
+              super
 
-              element = current_page.find_editable_element(self.current_block_name(context), @slug)
+              if listener = options[:events_listener]
+                listener.emit(@tag_name.to_sym, page: options[:page], attributes: default_element_attributes)
+              end
+            end
+
+            def render(context)
+              service   = context.registers[:services].editable_element
+              page      = context.registers[:page]
+              block     = context['block'].try(:name)
 
-              if element.present?
+              if element = service.find(page, block, @slug)
                 render_element(context, element)
               else
+                # Locomotive::Common::Logger.error "[#{page.fullpath}] missing #{@tag_name} \"#{@slug}\" (#{context['block'].try(:name) || 'default'})"
                 super
               end
             end
 
             protected
 
-            def render_element(context, element)
-              element.content
+            def default_element_attributes
+              {
+                block:          self.current_inherited_block_name,
+                slug:           @slug,
+                hint:           @element_options[:hint],
+                priority:       @element_options[:priority] || 0,
+                fixed:          !!@element_options[:fixed],
+                disabled:       false,
+                inline_editing: true,
+                from_parent:    false
+              }
+            end
+
+            def current_inherited_block_name
+              @element_options[:block] || current_inherited_block.try(:name)
+            end
+
+            def current_inherited_block
+              options[:inherited_blocks].try(:[], :nested).try(:last)
+            end
+
+            def render_default_content
+              begin
+                if nodelist.all? { |n| n.is_a? String }
+                  @body.render(::Liquid::Context.new)
+                else
+                  raise ::Liquid::SyntaxError.new("No liquid tags are allowed inside the #{@tag_name} \"#{@slug}\" (block: #{current_inherited_block_name || 'default'})")
+                end
+              end
             end
 
-            def current_block_name(context)
-              context['block'].try(:name)
+            #:nocov:
+            def render_element(element)
+              raise 'FIXME: has to be overidden'
             end
 
           end
@@ -47,4 +86,4 @@ module Locomotive
       end
     end
   end
-end
+end

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

@@ -5,15 +5,28 @@ module Locomotive
         module Editable
           class Control < Base
 
-            def render(context)
-              super
+            protected
+
+            def default_element_attributes
+              super.merge({
+                content: render_default_content,
+                options: @element_options[:options]
+              })
+            end
+
+            def render_element(context, element)
+              element.content
+            end
+
+            def render_default_content
+              super.try(:strip)
             end
 
           end
 
-          ::Liquid::Template.register_tag('editable_control', Control)
+          ::Liquid::Template.register_tag('editable_control'.freeze, Control)
         end
       end
     end
   end
-end
+end

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

@@ -5,11 +5,43 @@ module Locomotive
         module Editable
           class File < Base
 
+            protected
+
+            def default_element_attributes
+              super.merge({
+                default_source_url: render_default_content.strip
+              })
+            end
+
+            def render_element(context, element)
+              default_timestamp = context.registers[:page].updated_at.to_i
+
+              url, timestamp = (if element.source
+                [source_url(element), default_timestamp]
+              else
+                if element.default_source_url.present?
+                  [element.default_source_url, default_timestamp]
+                else
+                  [render_default_content, nil]
+                end
+              end)
+
+              context.registers[:services].asset_host.compute(url, timestamp)
+            end
+
+            def source_url(element)
+              if element.source =~ /^https?/
+                element.source
+              else
+                "#{element.base_url}/#{element.source}"
+              end
+            end
+
           end
 
-          ::Liquid::Template.register_tag('editable_file', File)
+          ::Liquid::Template.register_tag('editable_file'.freeze, File)
         end
       end
     end
   end
-end
+end

data/lib/locomotive/steam/liquid/tags/editable/text.rb

@@ -5,11 +5,63 @@ module Locomotive
         module Editable
           class Text < Base
 
+            protected
+
+            def render_element(context, element)
+              with_inline_editing(context, element) do
+                if element.default_content?
+                  render_default_content
+                else
+                  element.content
+                end
+              end
+            end
+
+            def with_inline_editing(context, element, &block)
+              if editable?(context, element)
+                %{<span class="locomotive-editable-text" data-element-id="#{element.id}">#{yield}</span>}
+              else
+                yield
+              end
+            end
+
+            def editable?(context, element)
+              !!context['inline_editing'] && element.inline_editing?
+            end
+
+            def default_element_attributes
+              super.merge(
+                content_from_default: self.render_default_content,
+                format:               @options[:format] || 'html',
+                rows:                 @options[:rows] || 10,
+                line_break:           @options[:line_break].blank? ? true : @options[:line_break]
+              )
+            end
+
+          end
+
+          ::Liquid::Template.register_tag('editable_text'.freeze, Text)
+
+          class ShortText < Text
+            def initialize(tag_name, markup, options)
+               Locomotive::Common::Logger.warn %(The "#{tag_name}" liquid tag is deprecated. Use "editable_text" instead.).yellow
+              super
+            end
+            def default_element_attributes
+              super.merge(format: 'raw', rows: 2, line_break: false)
+            end
+          end
+          ::Liquid::Template.register_tag('editable_short_text'.freeze, ShortText)
+
+          class LongText < ShortText
+            def default_element_attributes
+              super.merge(format: 'html', rows: 15, line_break: true)
+            end
           end
+          ::Liquid::Template.register_tag('editable_long_text'.freeze, LongText)
 
-          ::Liquid::Template.register_tag('editable_text', Text)
         end
       end
     end
   end
-end
+end

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

@@ -4,22 +4,59 @@ module Locomotive
       module Tags
         class Extends < ::Liquid::Extends
 
+          private
+
           def parse_parent_template
-            mounting_point = @options[:mounting_point]
+            parent = options[:parent_finder].find(options[:page], @template_name)
+
+            # no need to go further if the parent does not exist
+            raise PageNotFound.new("Page with fullpath '#{@template_name}' was not found") if parent.nil?
 
-            page = if @template_name == 'parent'
-              @options[:page].parent
-            else
-              mounting_point.pages[@template_name]
+            if listener = options[:events_listener]
+              listener.emit(:extends, page: options[:page], parent: parent)
             end
 
-            ::Liquid::Template.parse(page.source, { mounting_point: mounting_point, page: page })
+            # the source has already been parsed before
+            options[:parser]._parse(parent, options.merge(page: parent))
+            # parent.template || ::Liquid::Template.parse(parent.source, options.merge(page: parent))
           end
 
         end
 
-        ::Liquid::Template.register_tag('extends', Extends)
+        ::Liquid::Template.register_tag('extends'.freeze, Extends)
       end
     end
   end
-end
+end
+
+# def prepare_parsing
+          #   super
+
+          #   parent_page = @context[:parent_page]
+
+          #   @context[:page].merge_editable_elements_from_page(parent_page)
+
+          #   @context[:snippets] = parent_page.snippet_dependencies
+          #   @context[:templates] = ([*parent_page.template_dependencies] + [parent_page.id]).compact
+          # end
+
+# if @template_name == 'parent'
+            #   @context[:parent_page] = @context[:cached_parent] || @context[:page].parent
+            # else
+            #   locale = ::Mongoid::Fields::I18n.locale
+
+            #   @context[:parent_page] = @context[:cached_pages].try(:[], @template_name) ||
+            #     @context[:site].pages.where("fullpath.#{locale}" => @template_name).first
+            # end
+
+            # raise PageNotFound.new("Page with fullpath '#{@template_name}' was not found") if @context[:parent_page].nil?
+
+            # # be sure to work with a copy of the parent template otherwise there will be conflicts
+            # parent_template = @context[:parent_page].template.try(:clone)
+
+            # raise PageNotTranslated.new("Page with fullpath '#{@template_name}' was not translated") if parent_template.nil?
+
+            # # force the page to restore the original version of its template (from the serialized version)
+            # @context[:parent_page].instance_variable_set(:@template, nil)
+
+            # parent_template

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

@@ -0,0 +1,38 @@
+module Locomotive
+  module Steam
+    module Liquid
+      module Tags
+
+        # Fetch a page from its handle and assign it to a liquid variable.
+        #
+        # Usage:
+        #
+        # {% fetch_page about_us as a_page %}
+        # <p>{{ a_page.title }}</p>
+        #
+        class FetchPage < ::Liquid::Tag
+
+          Syntax = /(#{::Liquid::VariableSignature}+)\s+as\s+(#{::Liquid::VariableSignature}+)/o
+
+          def initialize(tag_name, markup, options)
+            if markup =~ Syntax
+              @handle, @var = $1, $2
+            else
+              raise SyntaxError.new("Syntax Error in 'fetch_page' - Valid syntax: fetch_page page_handle as variable")
+            end
+
+            super
+          end
+
+          def render(context)
+            page = context.registers[:repositories].page.by_handle(@handle)
+            context.scopes.last[@var] = page
+            ''
+          end
+        end
+
+        ::Liquid::Template.register_tag('fetch_page'.freeze, FetchPage)
+      end
+    end
+  end
+end

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

@@ -2,27 +2,40 @@ module Locomotive
   module Steam
     module Liquid
       module Tags
-        class GoogleAnalytics < ::Liquid::Tag
+        class GoogleAnalytics < ::Solid::Tag
 
-          Syntax = /(#{::Liquid::Expression}+)?/
+          tag_name :google_analytics
 
-          def initialize(tag_name, markup, tokens, options)
-            if markup =~ Syntax
-              @account_id = $1.gsub('\'', '')
+          def display(account_id = nil)
+            if account_id.blank?
+              raise ::Liquid::SyntaxError.new("Syntax Error in 'google_analytics' - Valid syntax: google_analytics <account_id>")
             else
-              raise ::Liquid::SyntaxError.new(options[:locale].t("errors.syntax.google_analytics"), options[:line])
+              ga_snippet(account_id)
             end
-
-            super
           end
 
-          def render(context)
-           "<!-- google analytics for #{@account_id} -->"
+          private
+
+          def ga_snippet(account_id)
+            %{
+              <script type="text/javascript">
+
+                var _gaq = _gaq || [];
+                _gaq.push(['_setAccount', '#{account_id}']);
+                _gaq.push(['_trackPageview']);
+
+                (function() \{
+                  var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+                  ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+                  var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+                \})();
+
+              </script>}
           end
+
         end
 
-        ::Liquid::Template.register_tag('google_analytics', GoogleAnalytics)
       end
     end
   end
-end
+end