scribo 1.0.38

data/lib/scribo/liquid/filters/markdownify.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Markdownify
+  def markdownify(input)
+    # Easiest way at the moment
+    Scribo::ContentRenderService.new(Scribo::Content.new(kind: 'text', data: input), {}, layout: false,
+                                                                                         filter: 'markdown').call
+  end
+end
+
+Liquid::Template.register_filter(Markdownify)

data/lib/scribo/liquid/filters/url_filters.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module URLFilters
+  # Produces an absolute URL based on site.url and site.baseurl.
+  #
+  # input - the URL to make absolute.
+  #
+  # Returns the absolute URL as a String.
+  def absolute_url(input)
+    cache = (@context.registers[:cached_absolute_urls] ||= {})
+    cache[input] ||= compute_absolute_url(input)
+  end
+
+  # Produces a URL relative to the domain root based on site.baseurl
+  # unless it is already an absolute url with an authority (host).
+  #
+  # input - the URL to make relative to the domain root
+  #
+  # Returns a URL relative to the domain root as a String.
+  def relative_url(input)
+    cache = (@context.registers[:cached_relative_urls] ||= {})
+    cache[input] ||= compute_relative_url(input)
+  end
+
+  # Strips trailing `/index.html` from URLs to create pretty permalinks
+  #
+  # input - the URL with a possible `/index.html`
+  #
+  # Returns a URL with the trailing `/index.html` removed
+  def strip_index(input)
+    return if input.nil? || input.to_s.empty?
+
+    input.sub(%r[/index\.html?$], '/')
+  end
+
+  private
+
+  def compute_absolute_url(input)
+    return if input.nil?
+
+    input = input.url if input.respond_to?(:url)
+    return input if Addressable::URI.parse(input.to_s).absolute?
+
+    site = @context.registers['content'].site
+    return relative_url(input) if site.properties['url'].nil?
+
+    Addressable::URI.parse(
+      site.properties['url'].to_s + relative_url(input)
+    ).normalize.to_s
+  end
+
+  def compute_relative_url(input)
+    return if input.nil?
+
+    input = input.url if input.respond_to?(:url)
+    return input if Addressable::URI.parse(input.to_s).absolute?
+
+    parts = [sanitized_baseurl, input]
+    Addressable::URI.parse(
+      parts.compact.map { |part| ensure_leading_slash(part.to_s) }.join
+    ).normalize.to_s
+  end
+
+  def sanitized_baseurl
+    site = @context.registers['content'].site
+    site.properties['baseurl'].to_s.chomp('/')
+  end
+
+  def ensure_leading_slash(input)
+    return input if input.nil? || input.empty? || input.start_with?('/')
+
+    "/#{input}"
+  end
+end
+
+Liquid::Template.register_filter(URLFilters)

data/lib/scribo/liquid/parser.rb

@@ -0,0 +1,32 @@
+require 'parslet'
+
+module Scribo
+class LiquidParser < Parslet::Parser
+  rule(:liquid) { (str('}}').absent? >> any).repeat }
+
+  rule(:space) { match('\s').repeat(1) }
+  rule(:space?) { space.maybe }
+
+  rule(:squote) { str("'").repeat(1) }
+  rule(:dquote) { str('"').repeat(1) }
+
+  rule(:pipe) { str('|').repeat(1) }
+
+  rule(:nsqvalue) { match["^'"] }
+  rule(:ndqvalue) { match['^"'] }
+
+  rule(:squoted_value) { squote >> nsqvalue.repeat.as(:value) >> squote }
+  rule(:dquoted_value) { dquote >> ndqvalue.repeat.as(:value) >> dquote }
+  rule(:quoted_value) { squoted_value | dquoted_value }
+
+  rule(:translation_key) { quoted_value >> space? >> pipe >> liquid.as(:filter) >> space? >> liquid }
+
+  rule(:liquid_code) { translation_key | liquid }
+
+  rule(:liquid_with_brackets) { str('{{') >> liquid_code >> str('}}') }
+  rule(:text) { (str('{{').absent? >> any).repeat(1) }
+
+  rule(:text_with_liquid) { (text | liquid_with_brackets).repeat }
+  root(:text_with_liquid)
+end
+end

data/lib/scribo/liquid/tags/application_assets_tag.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# ApplicationAssets tag
+#
+# == Basic usage:
+#    {%application_assets%}
+class ApplicationAssetsTag < LiquidumTag
+  def render(context)
+    super
+    lookup(context.registers, 'application_assets')
+  end
+end
+
+Liquid::Template.register_tag('application_assets', ApplicationAssetsTag)

data/lib/scribo/liquid/tags/application_js_tag.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# ApplicationAssets tag
+#
+# == Basic usage:
+#    {%application_js%}
+class ApplicationJsTag < LiquidumTag
+  def render(context)
+    super
+
+    js = lookup(context.registers, 'application_js')
+    "<script>#{js}</script>" if js
+  end
+end
+
+Liquid::Template.register_tag('application_js', ApplicationJsTag)

data/lib/scribo/liquid/tags/asset_tag.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Add assets (by name) from the current Liquidum site
+#
+# == Basic usage:
+#    {%asset 'test.png'%}
+#
+# == Advanced usage:
+#    {%asset 'test.png' height="72px"%}
+#    {%asset 'test.png' style="height: 72px;"%}
+#
+# Note: It will only look at published assets
+class AssetTag < LiquidumTag
+  include Rails.application.routes.url_helpers
+
+  def render(context)
+    super
+
+    current_content = context.registers['content']
+
+    content = current_content.site.contents.published.located(argv1, restricted: false).first
+
+    return "<!-- asset '#{argv1}' not found -->" unless content
+
+    full_path = content.full_path
+    if File.basename(full_path).include?('/_')
+      full_path = context.registers['controller'].helpers.scribo.content_path(content)
+    end
+
+    case content&.media_type
+    when 'image'
+      %[<img] +
+        attr_str(:src, arg(:src), full_path) +
+        attr_str(:alt, content.properties['title'], content.properties['title']) +
+        attr_str(:title, content.properties['caption'], content.properties['caption']) +
+        attr_str(:width, arg(:width)) +
+        attr_str(:height, arg(:height)) +
+        attr_str(:style, arg(:style)) +
+        %[/>]
+    else
+      if content&.content_type == 'text/css'
+        %[<link rel="stylesheet" type="text/css"] +
+          attr_str(:href, arg(:href), full_path) +
+          %[/>]
+      elsif content&.content_type == 'application/javascript'
+        %[<script] +
+          attr_str(:src, arg(:src), full_path) +
+          %[/></script>]
+      else
+        "<!-- unknown asset: #{argv1} -->"
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('asset', AssetTag)

data/lib/scribo/liquid/tags/button_tag.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Adds a (by default submit) button
+#
+# == Basic usage:
+#    {%button name:'commit' value:'save'%}Save{%endbutton%}
+#
+# == Advanced usage:
+#    {%button button name:'commit' value:'save'%}Save{%endbutton%}
+#    {%button reset name:'commit' value:'save'%}Save{%endbutton%}
+#
+class ButtonTag < LiquidumBlock
+  def render(context)
+    super
+
+    %[<button] + attr_str(:type, argv1, 'submit') +
+      attr_str(:name, arg(:name), 'commit') +
+      attr_str(:value, arg(:value)) +
+      attr_str(:class, arg(:class)) +
+      %[>] + render_body + %[</button>]
+  end
+end
+
+Liquid::Template.register_tag('button', ButtonTag)

data/lib/scribo/liquid/tags/check_box_tag.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Add a check-box, either specifying everything manually or using a model object on the form
+#
+# == Basic usage:
+#    {%check_box name:"name" value:"1"%}
+#
+# == Advanced usage:
+#    {%check_box name%}
+#
+# This last usage requires a model on the form
+#
+class CheckBoxTag < LiquidumTag
+  def render(context)
+    super
+
+    if @form_model
+      %[<input ] + attr_str(:name, arg(:name),
+                            input(:name, argv1)) + %[value="0" type="hidden"/>]
+    else
+
+      %[<input ] + attr_str(:name, arg(:name), input(:name, argv1)) +
+        attr_str(:id, arg(:id), input(:id, argv1)) +
+        attr_str(:value, arg(:value), input(:value, argv1) ? 1 : 0) +
+        attr_str(:checked, arg(:checked), input(:checked, argv1)) +
+        attrs_str(:disabled, :maxlength, :placeholder, :class) + %[ type="checkbox"/>]
+    end
+  end
+end
+
+Liquid::Template.register_tag('check_box', CheckBoxTag)

data/lib/scribo/liquid/tags/csrf_meta_tags_tag.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Adds CSRF meta tags
+#
+# == Basic usage:
+#    {%csrf_meta_tags%}
+#
+class CsrfMetaTagsTag < LiquidumTag
+  def render(context)
+    super
+
+    context.registers['controller'].helpers.csrf_meta_tags
+  end
+end
+
+Liquid::Template.register_tag('csrf_meta_tags', CsrfMetaTagsTag)

data/lib/scribo/liquid/tags/date_field_tag.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Add a date-field, either specifying everything manually or using a model object on the form
+#
+# == Basic usage:
+#    {%date_field name:"start_date" value:"2019-09-27"%}
+#
+# == Advanced usage:
+#    {%date_field start_date%}
+#
+# This last usage requires a model on the form
+#
+
+require_relative './text_field_tag'
+
+class DateFieldTag < TextFieldTag
+  def initialize(tag, args, tokens)
+    super
+    @field_type = 'date'
+  end
+end
+
+Liquid::Template.register_tag('date_field', DateFieldTag)

data/lib/scribo/liquid/tags/editable_url_tag.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Makes content available for editing, basically adds the right attributes
+#
+# == Basic usage:
+#    <div {%editable%} data-editable-id='fiets'></div>
+#
+class EditableUrlTag < LiquidumTag
+  def render(context)
+    super
+
+    content = context.registers['content']
+
+    # FIXME: Use url helpers
+    %[/scribo/sites/#{content.site.id}/contents/#{content.id}/parts]
+  end
+end
+
+Liquid::Template.register_tag('editable_url', EditableUrlTag)

data/lib/scribo/liquid/tags/email_field_tag.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Add a email-field, either specifying everything manually or using a model object on the form
+#
+# == Basic usage:
+#    {%email_field name:"email" value:"1"%}
+#
+# == Advanced usage:
+#    {%email_field email%}
+#
+# This last usage requires a model on the form
+#
+
+require_relative './text_field_tag'
+
+class EmailFieldTag < TextFieldTag
+  def initialize(tag, args, tokens)
+    super
+    @field_type = 'email'
+  end
+end
+
+Liquid::Template.register_tag('email_field', EmailFieldTag)

data/lib/scribo/liquid/tags/feed_meta_tag.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Adds Feed meta
+#
+# == Basic usage:
+#    {%feed_meta%}
+#
+class FeedMetaTag < LiquidumTag
+  def render(context)
+    super
+
+    content = context.registers['content']
+    site = content.site
+    request = context.registers['controller'].request
+
+    %[
+      <!-- Begin Scribo Feed Meta tag #{Scribo::VERSION} -->
+    ]
+  end
+end
+
+Liquid::Template.register_tag('feed_meta', FeedMetaTag)

data/lib/scribo/liquid/tags/field_error_tag.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Add errors for a specific form field, only works inside a form
+#
+# == Basic usage:
+#    {%field_error name%}
+#
+class FieldErrorTag < LiquidumTag
+  attr_accessor :field_type
+
+  def render(context)
+    super
+
+    error_messages = lookup(context, "form.errors.messages.#{argv1}")
+
+    if error_messages.present?
+      result = %[<span>] +
+               attr_str(:class, arg(:class), input(:class, argv1)) +
+               (error_messages || []).join(', ') + %[</span>]
+    end
+
+    result
+  end
+end
+
+Liquid::Template.register_tag('field_error', FieldErrorTag)

data/lib/scribo/liquid/tags/fields_for_tag.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Exposes additional model objects, similar to form, but it doesn't create a form-tag.
+#
+# == Basic usage:
+#    {%fields_for location%}
+#      {%text_field city%}
+#    {%endform%}
+#
+# It will automatically build the association if need be. For polymorphic it needs a hint:
+#    {%fields_for scribable Domain%}
+#      {%text_field city%}
+#    {%endform%}
+#
+# == Available variables:
+#
+# form.model:: model specified
+# form.class_name:: class name of the model specified (original name, not the drop)
+# form.errors:: errors of the exposed object
+#
+# require_relative '../drops/form_drop'
+
+class FieldsForTag < LiquidumBlock
+  def render(context)
+    super
+
+    result = ''
+
+    context.stack do
+      context['form'] = Scribo::FormDrop.new(new_model, argv1)
+      result += render_body
+
+      if context['form.model.id']
+        result += %[<input] +
+                  attr_str(:id, arg(:id), input(:id, 'id')) +
+                  attr_str(:name, arg(:name), input(:name, 'id')) +
+                  attr_str(:value, arg(:value), input(:value, 'id')) +
+                  %[type="hidden"/>]
+      end
+    end
+
+    result
+  end
+
+  private
+
+  def new_model
+    new_model = begin
+      @context["form.model.#{argv1}"]
+    rescue StandardError
+      nil
+    end
+    unless new_model
+
+      association_name = (Regexp.last_match(0) if argv1.match(/([^\[\]])+/))
+
+      new_model = begin
+        reflection = real_object_from_drop(@context['form.model']).class.reflect_on_association(association_name)
+        if reflection.polymorphic?
+          # If it's polymorphic we need hints on what to do
+          sargs.first.to_s.safe_constantize.new(attr_args)
+        elsif reflection.is_a?(ActiveRecord::Reflection::HasManyReflection) && reflection.constructable?
+          # Do model.association.new
+          real_object_from_drop(@context['form.model']).send(association_name.to_sym).new(attr_args)
+        elsif reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection) && reflection.constructable?
+          # Do model.build_association
+          real_object_from_drop(@context['form.model']).send("build_#{association_name}".to_sym, attr_args)
+        else
+          # Just call new on the class
+          reflection.klass.new(attr_args)
+        end
+      rescue ArgumentError
+        nil
+      end
+
+      new_model
+    end
+    new_model
+  end
+end
+
+Liquid::Template.register_tag('fields_for', FieldsForTag)

data/lib/scribo/liquid/tags/form_tag.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Form adds a form tag, when you specify a model it will use and expose that to nested fields.
+# Exposing a model will ease the creation of nested fields.
+#
+# == Basic usage:
+#    {%form%}
+#      {%text_field name:"name" value:"Pencil"%}
+#    {%endform%}
+#
+# == Advanced usage:
+#    {%form product%}
+#      {%text_field name%}
+#    {%endform%}
+#
+# == Available variables:
+#
+# form.model:: model specified
+# form.class_name:: class name of the model specified (original name, not the drop)
+# form.errors:: errors of the exposed object
+#
+# require_relative '../drops/form_drop'
+
+class FormTag < LiquidumBlock
+  def render(context)
+    super
+
+    method = arg(:method).to_s.downcase
+    method = argv1.instance_variable_get('@object').persisted? ? 'patch' : 'post' if method.blank? && argv1
+
+    rails_method = nil
+    if %w[get post].exclude? method
+      rails_method = method
+      method       = 'post'
+    end
+
+    result = %[<form] +
+             attr_str(:action, arg(:action)) +
+             attr_str(:method, method) +
+             attrs_str(reject: %[action method]) +
+             %[>]
+
+    if context.registers['controller']
+      result += %[<input name="_method" type="hidden" value="#{rails_method}"/>] if rails_method
+      result += %[<input name="authenticity_token" type="hidden" value="#{context.registers['controller'].helpers.form_authenticity_token}"/>]
+    end
+
+    context.stack do
+      context['form'] = Scribo::FormDrop.new(argv1)
+      result += render_body
+    end
+    result += %[</form>]
+    result
+  end
+end
+
+Liquid::Template.register_tag('form', FormTag)

data/lib/scribo/liquid/tags/google_analytics_javascript_tag.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Adds a Google Analytics Javascript block
+#
+# == Basic usage:
+#    {%google_analytics_javascript 'UA-000000-01'%}
+#
+# == Advanced usage:
+#    {%google_analytics_javascript retailer.code%}
+#
+# Where 'UA-000000-01' is your analytics id
+class GoogleAnalyticsJavascriptTag < LiquidumTag
+  def render(context)
+    super
+
+    return unless Rails.env == 'production'
+    return unless argv1
+
+    Scribo.config.logger.warn "Inserting google analytics with code: #{argv1}"
+    %(<script>(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
+
+  ga('create', '#{argv1}', 'auto');
+  ga('send', 'pageview');</script>)
+  end
+end
+
+Liquid::Template.register_tag('google_analytics_javascript', GoogleAnalyticsJavascriptTag)

data/lib/scribo/liquid/tags/google_tag_manager_javascript_tag.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Adds a Google Tag Manager Javascript block
+#
+# == Basic usage:
+#    {%google_tag_manager_javascript 'GTM-XXXXXXX'%}
+#
+# == Advanced usage:
+#    {%google_tag_manager_javascript retailer.code%}
+#
+# Where 'GTM-XXXXXXX' is your container id
+class GoogleTagManagerJavascriptTag < LiquidumTag
+  def render(context)
+    super
+
+    return unless Rails.env == 'production'
+    return unless argv1
+
+    Scribo.config.logger.warn "Inserting google tag manager with code: #{argv1}"
+    %(<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
+    new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
+    j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
+    'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
+    })(window,document,'script','dataLayer','#{argv1}');</script>)
+  end
+end
+
+Liquid::Template.register_tag('google_tag_manager_javascript', GoogleTagManagerJavascriptTag)

data/lib/scribo/liquid/tags/hidden_field_tag.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Add a text-field, either specifying everything manually or using a model object on the form
+#
+# == Basic usage:
+#    {%hidden_field name:"name" value:"Pencil"%}
+#
+# == Advanced usage:
+#    {%hidden_field name%}
+#
+# This last usage requires a model on the form
+#
+
+require_relative './text_field_tag'
+
+class HiddenFieldTag < TextFieldTag
+  def initialize(tag, args, tokens)
+    super
+    @field_type = 'hidden'
+  end
+end
+
+Liquid::Template.register_tag('hidden_field', HiddenFieldTag)