locomotivecms 3.0.0.pre.alpha

data/lib/locomotive/previous_liquid/tags/path_to.rb

@@ -0,0 +1,21 @@
+module Locomotive
+  module Liquid
+    module Tags
+      class PathTo < ::Liquid::Tag
+
+        include PathHelper
+
+        def render(context)
+          render_path(context)
+        end
+
+        def wrong_syntax!
+          raise SyntaxError.new("Syntax Error in 'path_to' - Valid syntax: path_to <page|page_handle|content_entry>(, locale: [fr|de|...], with: <page_handle>")
+        end
+
+      end
+
+      ::Liquid::Template.register_tag('path_to', PathTo)
+    end
+  end
+end

data/lib/locomotive/previous_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

data/lib/locomotive/previous_liquid/tags/session_assign.rb

@@ -0,0 +1,39 @@
+module Locomotive
+  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, context)
+          if markup =~ Syntax
+            @to = $1
+            @from = $2
+          else
+            raise ::Liquid::SyntaxError.new("Syntax Error in 'session_assign' - Valid syntax: assign [var] = [source]")
+          end
+
+          super
+        end
+
+        def render(context)
+          controller = context.registers[:controller]
+
+          controller.session[@to.to_sym] = context[@from]
+          ''
+        end
+
+      end
+
+      ::Liquid::Template.register_tag('session_assign', SessionAssign)
+    end
+  end
+end

data/lib/locomotive/previous_liquid/tags/snippet.rb

@@ -0,0 +1,75 @@
+module Locomotive
+  module Liquid
+    module Tags
+
+      class Snippet < ::Liquid::Include
+
+        attr_accessor :slug
+        attr_accessor :partial
+
+        def initialize(tag_name, markup, tokens, context)
+          super
+
+          @slug = @template_name.gsub(/['"]/o, '')
+
+          if @context[:snippets].present?
+            (@context[:snippets] << @slug).uniq!
+          else
+            @context[:snippets] = [@slug]
+          end
+
+          if @context[:site].present?
+            snippet = @context[:site].snippets.where(slug: @slug).first
+            self.refresh(snippet) if snippet
+          end
+        end
+
+        def render(context)
+          return '' if @partial.nil?
+
+          variable = context[@variable_name || @template_name[1..-2]]
+
+          context.stack do
+            @attributes.each do |key, value|
+              context[key] = context[value]
+            end
+
+            output = (if variable.is_a?(Array)
+              variable.collect do |variable|
+                context[@template_name[1..-2]] = variable
+                @partial.render(context)
+              end
+            else
+              context[@template_name[1..-2]] = variable
+              @partial.render(context)
+            end)
+
+            output
+          end
+        end
+
+        def refresh(snippet, context = {})
+          if snippet.destroyed?
+            @snippet_id = nil
+            @partial = nil
+          else
+            @snippet_id = snippet.id
+            @partial = ::Liquid::Template.parse(snippet.template, context.merge(@context))
+            @partial.root.context.clear
+          end
+        end
+
+        def nodelist
+          if @partial
+            @partial.root.nodelist
+          else
+            []
+          end
+        end
+
+      end
+
+      ::Liquid::Template.register_tag('include', Snippet)
+    end
+  end
+end

data/lib/locomotive/previous_liquid/tags/with_scope.rb

@@ -0,0 +1,65 @@
+module Locomotive
+  module Liquid
+    module Tags
+
+      # Filter a collection
+      #
+      # Usage:
+      #
+      # {% with_scope main_developer: 'John Doe', providers.in: ['acme'], started_at.le: today, active: true %}
+      #   {% for project in contents.projects %}
+      #     {{ project.name }}
+      #   {% endfor %}
+      # {% endwith_scope %}
+      #
+
+      class WithScope < Solid::Block
+
+        OPERATORS = %w(all exists gt gte in lt lte ne nin size near within)
+
+        SYMBOL_OPERATORS_REGEXP = /(\w+\.(#{OPERATORS.join('|')})){1}\s*\:/
+
+        # register the tag
+        tag_name :with_scope
+
+        def initialize(tag_name, arguments_string, tokens, context = {})
+          # convert symbol operators into valid ruby code
+          arguments_string.gsub!(SYMBOL_OPERATORS_REGEXP, ':"\1" =>')
+
+          super(tag_name, arguments_string, tokens, context)
+        end
+
+        def display(options = {}, &block)
+          current_context.stack do
+            current_context['with_scope'] = self.decode(options)
+            yield
+          end
+        end
+
+        protected
+
+        def decode(options)
+          HashWithIndifferentAccess.new.tap do |hash|
+            options.each do |key, value|
+              _key, _operator = key.to_s.split('.')
+
+              # _slug instead of _permalink
+              _key = '_slug' if _key == '_permalink'
+
+              # key to h4s symbol
+              _key = _key.to_s.to_sym.send(_operator.to_sym) if _operator
+
+              hash[_key] = (case value
+                # regexp inside a string
+              when /^\/[^\/]*\/$/ then Regexp.new(value[1..-2])
+              else
+                value
+              end)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/rails.rb

@@ -0,0 +1 @@
+require 'locomotive/rails/action_view'

data/lib/locomotive/rails/action_view.rb

@@ -0,0 +1,6 @@
+class ActionView::Base
+
+  def escape_json(json)
+    json.html_safe
+  end
+end

data/lib/locomotive/regexps.rb

@@ -0,0 +1,13 @@
+module Locomotive
+  module Regexps
+
+    # SUBDOMAIN           = /^[a-z][a-z0-9_-]*[a-z0-9]{1}$/
+
+    HANDLE              = /^[a-z][a-z0-9_-]*[a-z0-9]{1}$/
+
+    DOMAIN              = /^(([a-z\d])([a-z\d-]){0,61}([a-z\d]))(\.([a-z\d])([a-z\d-]){0,61}([a-z\d]))*$/i
+
+    URL                 = /((http|https|ftp):\/)?\/\S*/
+
+  end
+end

data/lib/locomotive/simple_form.rb

@@ -0,0 +1,137 @@
+module Locomotive
+  module SimpleForm
+    module BootstrapHelpers
+
+      def row_wrapping(options = {}, &block)
+        options.merge!(class: 'row')
+        template.content_tag(:div,
+          template.capture(&block).html_safe,
+          options)
+      end
+
+      def col_wrapping(class_name, column = 6, &block)
+        template.content_tag(:div,
+          template.capture(&block).html_safe,
+          class: "col-md-#{column} #{class_name}")
+      end
+
+    end
+
+    module HeaderLink
+
+      def _header_link(name, type)
+        if _options = options[name]
+          label = _options[:label] || I18n.t(:edit, scope: ['locomotive.shared.form', type])
+          url   = _options[:url]
+          template.link_to(label, url, class: 'action')
+        else
+          ''
+        end
+      end
+
+    end
+  end
+
+  class FormBuilder < ::SimpleForm::FormBuilder
+
+    def inputs(name = nil, options = {}, &block)
+      label = translate_text(name, :titles)
+
+      html = template.content_tag(:legend, template.content_tag(:span, label))
+      html += template.capture(&block)
+
+      options[:class] ||= 'inputs'
+
+      template.content_tag(:fieldset, html, options)
+    end
+
+    def actions(options = {}, &block)
+      if options[:back_url]
+        actions_with_back_button(options)
+      else
+        options[:class] ||= 'text-right form-actions'
+        template.content_tag(:div, options, &block)
+      end
+    end
+
+    def actions_with_back_button(options = {})
+      back_button = back_button_action(options)
+
+      template.content_tag(:div,
+        template.content_tag(:div, back_button, class: 'col-md-6 text-left') +
+        template.content_tag(:div, action, class: 'col-md-6 text-right'),
+        class: 'row')
+    end
+
+    def back_button_action(options = {})
+      label  = template.escape_once('&larr;&nbsp;') + template.t('.back')
+      url    = options[:back_url]
+
+      if options[:use_stored_location]
+        url = template.last_saved_location(url)
+      end
+
+      template.link_to(label, url)
+    end
+
+    def action(misc_class = '')
+      action        = object.persisted? ? :update : :create
+      label         = translate_text(action, :buttons)
+      loading_text  = translate_text(:loading_text, :buttons)
+
+      template.content_tag :button, label,
+        type:   'submit',
+        class:  "btn btn-success btn-sm #{misc_class}",
+        data:   { loading_text: loading_text }
+    end
+
+    def submit_text(action = :submit)
+      translate_text(action, :buttons, action)
+    end
+
+    # Translate text for the submits and titles namespace.
+    # it differs from the simple_form translate_from_namespace method
+    # in that this does not care about the attribute.
+    #
+    def translate_text(key, namespace, default = '')
+      model_names = lookup_model_names.dup
+      lookups     = []
+
+      while !model_names.empty?
+        joined_model_names = model_names.join(".")
+        model_names.shift
+
+        lookups << :"#{joined_model_names}.#{key}"
+      end
+      lookups << :"defaults.locomotive.#{key}"
+      lookups << default.to_s
+
+      I18n.t(lookups.shift, scope: :"#{i18n_scope}.#{namespace}", default: lookups).presence
+    end
+
+    # Extract the model names from the object_name mess, ignoring numeric and
+    # explicit child indexes.
+    # Prefix it by locomotive
+    #
+    # Example:
+    #
+    # route[blocks_attributes][0][blocks_learning_object_attributes][1][foo_attributes]
+    # ["locomotive", "route", "blocks", "blocks_learning_object", "foo"]
+    #
+    def lookup_model_names #:nodoc:
+      @lookup_model_names ||= begin
+        child_index = options[:child_index]
+        names = object_name.to_s.scan(/(?!\d)\w+/).flatten
+        names.unshift('locomotive')
+        names.delete(child_index) if child_index
+        names.each { |name| name.gsub!('_attributes', '') }
+        names.freeze
+      end
+    end
+
+    def i18n_scope
+      ::SimpleForm.i18n_scope
+    end
+
+  end
+end

data/lib/locomotive/simple_token_authentication.rb

@@ -0,0 +1,11 @@
+# Fix bug: https://github.com/gonzalo-bulnes/simple_token_authentication/issues/83
+module SimpleTokenAuthentication
+  class Entity
+    def name
+      @name.gsub('::', '-')
+    end
+    def name_underscore
+      name.underscore.gsub('-', '_')
+    end
+  end
+end