scribo 1.0.38

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+class HighlightBlock < Liquid::Block
+  include Liquid::StandardFilters
+
+  # The regular expression syntax checker. Start with the language specifier.
+  # Follow that by zero or more space separated options that take one of three
+  # forms: name, name=value, or name="<quoted list>"
+  #
+  # <quoted list> is a space-separated list of numbers
+  SYNTAX = /^([a-zA-Z0-9.+#_-]+)((\s+\w+(=(\w+|"([0-9]+\s)*[0-9]+"))?)*)$/.freeze
+
+  def initialize(tag_name, markup, tokens)
+    super
+    if markup.strip =~ SYNTAX
+      @lang = Regexp.last_match(1).downcase
+      @highlight_options = parse_options(Regexp.last_match(2))
+    else
+      raise SyntaxError, <<~MSG
+        Syntax Error in tag 'highlight' while parsing the following markup:
+
+        #{markup}
+
+        Valid syntax: highlight <lang> [linenos]
+      MSG
+    end
+  end
+
+  LEADING_OR_TRAILING_LINE_TERMINATORS = /\A(\n|\r)+|(\n|\r)+\z/.freeze
+
+  def render(context)
+    prefix = context['highlighter_prefix'] || ''
+    suffix = context['highlighter_suffix'] || ''
+    code = super.to_s.gsub(LEADING_OR_TRAILING_LINE_TERMINATORS, '')
+
+    output =
+      case context.registers[:site]&.highlighter
+      when 'rouge'
+        render_rouge(code)
+      when 'pygments'
+        render_pygments(code, context)
+      else
+        render_codehighlighter(code)
+      end
+
+    rendered_output = add_code_tag(output)
+    prefix + rendered_output + suffix
+  end
+
+  private
+
+  OPTIONS_REGEX = /(?:\w="[^"]*"|\w=\w|\w)+/.freeze
+
+  def parse_options(input)
+    options = {}
+    return options if input.empty?
+
+    # Split along 3 possible forms -- key="<quoted list>", key=value, or key
+    input.scan(OPTIONS_REGEX) do |opt|
+      key, value = opt.split('=')
+      # If a quoted list, convert to array
+      if value&.include?('"')
+        value.delete!('"')
+        value = value.split
+      end
+      options[key.to_sym] = value || true
+    end
+
+    options[:linenos] = 'inline' if options[:linenos] == true
+    options
+  end
+
+  def render_pygments(code, _context)
+    Scribo.logger.warn 'Warning: Highlight Tag no longer supports rendering with Pygments. Using the default highlighter, Rouge, instead.'
+    render_rouge(code)
+  end
+
+  def render_rouge(code)
+    require 'rouge'
+    formatter = ::Rouge::Formatters::HTMLLegacy.new(
+      line_numbers: @highlight_options[:linenos],
+      wrap: false,
+      css_class: 'highlight',
+      gutter_class: 'gutter',
+      code_class: 'code'
+    )
+    lexer = ::Rouge::Lexer.find_fancy(@lang, code) || Rouge::Lexers::PlainText
+    formatter.format(lexer.lex(code))
+  end
+
+  def render_codehighlighter(code)
+    Scribo.logger.warn 'Warning: Highlight Tag no longer supports rendering with Pygments. Using the default highlighter, Rouge, instead.'
+    render_rouge(code)
+  end
+
+  def add_code_tag(code)
+    code_attributes = [
+      "class=\"language-#{@lang.to_s.tr('+', '-')}\"",
+      "data-lang=\"#{@lang}\""
+    ].join(' ')
+    "<figure class=\"highlight\"><pre><code #{code_attributes}>"\
+    "#{code.chomp}</code></pre></figure>"
+  end
+end
+
+Liquid::Template.register_tag('highlight', HighlightBlock)

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Include other published content
+#
+# == Basic usage:
+#    {%include 'navigation'}
+#
+# == Advanced usage:
+#    {%include 'navigation' title:"Menu"}
+#
+# This allows you pass variables to the included content, which will only available there
+#
+class IncludeTag < LiquidumTag
+  def render(context)
+    super
+
+    content = context.registers['file_system'].read_template_file(argv1)
+
+    result = ''
+    context.stack do
+      context['include'] = Scribo::IncludeDrop.new(attr_args.deep_stringify_keys)
+      result += Liquidum.render(content, context: context, registers: context.registers)
+    end
+    result
+  end
+end
+
+Liquid::Template.register_tag('include', IncludeTag)

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Add a text_field, either specifying everything manually or using a model object on the form
+#
+# == Basic usage:
+#    {%label for:"name"%}Name:{%endlabel%}
+#
+# == Advanced usage:
+#    {%label name%}Name:{%endlabel%}
+#
+# This last usage requires a model on the form
+#
+class LabelTag < LiquidumBlock
+  def render(context)
+    super
+
+    @form_model = lookup(context, 'form.model')
+    @form_class_name = lookup(context, 'form.class_name')
+
+    %[<label] + attr_str(:for, arg(:for), input(:id, argv1)) + %[>] + render_body + %[</label>]
+  end
+end
+
+Liquid::Template.register_tag('label', LabelTag)

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

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

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Add a text-field, either specifying everything manually or using a model object on the form
+#
+# == Basic usage:
+#    {%assign airports = "Eindhoven, Schiphol" | split: ', '%}
+#    {%options_for_select airports%}
+#
+# == Advanced usage:
+#    {%assign airports = "Eindhoven, Schiphol" | split: ', '%}
+#    {%options_for_select airports selected:"Schiphol" disabled:"Eindhoven"%}
+#
+# == Advanced usage:
+#    {%options_for_select airports name value selected:"Schiphol" disabled:"Eindhoven"%}
+#
+# This last usage requires a model on the form
+#
+class OptionsForSelectTag < LiquidumTag
+  def render(context)
+    super
+
+    options = argv1.map(&:to_liquid)
+
+    if sargs.present?
+      options = options.map do |option|
+        result = sargs.map { |a| option[a.to_s] }
+        result = result.first if result.length == 1
+        result
+      end
+    end
+
+    context.registers['controller'].helpers.options_for_select(options, attr_args).to_s
+  end
+end
+
+Liquid::Template.register_tag('options_for_select', OptionsForSelectTag)

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

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

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

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

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Full-text searches content, in both content and properties
+#
+# == Basic usage:
+#    {%search q%}
+#    {{search|size}} results
+#    {%endsearch%}
+#
+# Note: It will only look at published content
+class SearchTag < LiquidumBlock
+  def render(context)
+    super
+
+    current_content = context.registers['content']
+    request = context.registers['controller'].request
+
+    contents = current_content.site.contents.published.search(request.params[argv1])
+
+    result = ''
+    context.stack do
+      context['results'] = contents.map { |content| Scribo::ContentDrop.new(content) }
+      result += render_body
+    end
+    result
+  end
+end
+
+Liquid::Template.register_tag('search', SearchTag)

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Adds a (by default submit) button
+#
+# == Basic usage:
+#    {%select name:'group'%}{%endselect%}
+#
+# == Advanced usage:
+#    {%select group%}{%endselect%}
+#
+class SelectTag < LiquidumBlock
+  def render(context)
+    super
+
+    %[<select] + attr_str(:name, arg(:name), input(:name, argv1)) +
+      attr_str(:id, arg(:id), input(:id, argv1)) +
+      attrs_str(reject: %[name id]) +
+      %[>] + render_body + %[</select>]
+  end
+end
+
+Liquid::Template.register_tag('select', SelectTag)

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Adds SEO tags
+#
+# == Basic usage:
+#    {%seo%}
+#
+class SeoTag < LiquidumTag
+  def render(context)
+    super
+
+    content = context.registers['content']
+    site = content.site
+    request = context.registers['controller'].request
+
+    %[
+<!-- Begin Scribo SEO tag #{Scribo::VERSION} -->
+<title>#{site.properties['title']}</title>
+<meta name="generator" content="Scribo #{Scribo::VERSION}" />
+<meta property="og:title" content="#{content.site.title}" />
+<meta name="author" content="#{site.properties['author'].is_a?(String) ? site.properties['author'] : ''}" />
+<meta property="og:locale" content="en_US" />
+<meta name="description" content="#{site.properties['description']}" />
+<meta property="og:description" content="#{site.properties['description']}" />
+<link rel="canonical" href="#{request.protocol + request.host}" />
+<meta property="og:url" content="#{request.protocol + request.host}" />
+<meta property="og:site_name" content="#{content.site.title}" />
+<script type="application/ld+json">
+{"url":"#{request.protocol + request.host}","headline":"#{site.properties['title']}","name":"#{site.properties['title']}","author":{"@type":"Person","name":"#{site.properties['author']}"},"description":"#{site.properties['description']}","@type":"WebSite","@context":"https://schema.org"}</script>
+<!-- End Scribo SEO tag -->
+    ]
+  end
+end
+
+Liquid::Template.register_tag('seo', SeoTag)

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Sets the value in the session
+#
+# {%set_session name value%}
+# {%set_session locale 'nl'%}
+# {%set_session locale request.query_parameters['lang']%}
+# {%set_session locale request.query_parameters['lang']%}
+# {%set_session coupon_code 'beyou'%}
+class SetSessionTag < LiquidumTag
+  def render(context)
+    super
+
+    context.registers['controller'].session[argv1] = sargs.first
+    ''
+  end
+end
+
+Liquid::Template.register_tag('set_session', SetSessionTag)

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

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

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Add a text-field, either specifying everything manually or using a model object on the form
+#
+# == Basic usage:
+#    {%text_field name:"name" value:"Pencil"%}
+#
+# == Advanced usage:
+#    {%text_field name%}
+#
+# This last usage requires a model on the form
+#
+class TextFieldTag < LiquidumTag
+  attr_accessor :field_type
+
+  def initialize(tag, args, tokens)
+    super
+    @field_type = 'text'
+  end
+
+  def render(context)
+    super
+
+    result = %[<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))
+
+    result += attrs_str(reject: %[name value id])
+    result += %[ type="#{field_type}"/>]
+    result
+  end
+end
+
+Liquid::Template.register_tag('text_field', TextFieldTag)

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Add a text-area, either specifying everything manually or using a model object on the form
+#
+# == Basic usage:
+#    {%textarea name:"name"%}{%endtextarea%}
+#
+# == Advanced usage:
+#    {%textarea name%}{%endtextarea%}
+#
+# This last usage requires a model on the form
+#
+class TextareaTag < LiquidumBlock
+  def render(context)
+    super
+
+    result = %[<textarea] +
+             attr_str(:name, arg(:name), input(:name, argv1)) +
+             attr_str(:id, arg(:id), input(:id, argv1))
+
+    result += attrs_str(reject: %[name id])
+    result += %[>] + render_body + %[</textarea>]
+
+    result
+  end
+end
+
+Liquid::Template.register_tag('textarea', TextareaTag)

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

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

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

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

data/lib/scribo/preamble.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Scribo
+  class Preamble
+    DEFAULTS = {
+      external_encoding: Encoding.default_external
+    }.freeze
+
+    attr_accessor :metadata, :content
+
+    def initialize(metadata, content)
+      @metadata = metadata
+      @content  = content
+    end
+
+    def metadata_with_content
+      @metadata.to_yaml + "---\n" + @content
+    end
+
+    def dump
+      metadata_with_content
+    end
+
+    def save(path, options = {})
+      options = DEFAULTS.merge(options)
+
+      File.open(path, "w:#{options[:external_encoding]}") do |f|
+        f.write metadata_with_content
+      end
+    end
+
+    def self.parse(data)
+      preamble_lines = +''
+      content_lines  = +''
+
+      state = :before_preamble
+
+      f = StringIO.new(data)
+      f.each do |line|
+        stripped = line.strip
+
+        case state
+        when :before_preamble
+
+          new_state = case stripped
+                      when '---'
+                        :preamble
+                      when ''
+                        :before_preamble
+                      else
+                        content_lines << line
+                        :after_preamble
+                      end
+
+        when :preamble
+
+          new_state = case stripped
+                      when '---'
+                        :after_preamble
+                      else
+                        preamble_lines << line
+                        :preamble
+                      end
+
+        when :after_preamble
+          new_state = :after_preamble
+          content_lines << line
+
+        else
+          raise "Invalid State: #{state}"
+        end
+
+        state = new_state
+      end
+
+      new(Scribo::Utility.yaml_safe_parse(preamble_lines), content_lines)
+    end
+
+    def self.load(path, options = {})
+      f = File.open(path, "r:#{options[:external_encoding]}")
+      parse(f.read)
+    end
+
+    def self.load_multiple(*paths)
+      options = paths.last.is_a?(Hash) ? paths.pop : {}
+      paths.map { |path| Preamble.load(path, options) }
+    end
+  end
+end

data/lib/scribo/sassc/importer.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Scribo
+  module SassC
+    class Importer < ::SassC::Importer
+      def imports(path, parent_path)
+        content = options[:content]
+
+        import_path = ''
+        if path.start_with?('/')
+          import_path += path
+        else
+          import_path += content.site.sass_dir
+          import_path += '/' unless import_path.end_with?('/')
+
+          import_path += path
+          import_path += File.extname(content.path)
+          import_path = File.expand_path(import_path, content.site.sass_dir)
+          unless import_path.start_with?(content.site.sass_dir)
+            # import_path always starts with /
+            import_path = content.site.sass_dir + import_path[1..-1]
+          end
+        end
+
+        include_content = content.site.contents.where(kind: 'text').located(import_path, restricted: false)
+        unless include_content.present?
+          # Look for /_file.ext alternative
+          import_path = File.dirname(import_path) + '/_' + File.basename(import_path)
+          include_content = content.site.contents.where(kind: 'text').located(import_path, restricted: false)
+        end
+
+        # Look in parent's folder
+        if include_content.blank? && File.dirname(parent_path) != '.'
+          import_path = content.site.sass_dir + File.dirname(parent_path) + '/' + File.basename(import_path)
+          include_content = content.site.contents.where(kind: 'text').located(import_path, restricted: false)
+        end
+
+        if include_content.empty? && content.site.properties.value_at_keypath('sass.sass_dir')
+          alternate_path = content.site.properties.value_at_keypath('sass.sass_dir')
+          # alternate_path += '/' unless alternate_path.end_with?('/')
+          alternate_path = '/' + alternate_path unless alternate_path.start_with?('/')
+
+          import_path = File.expand_path(path, alternate_path)
+          import_path += File.extname(content.path)
+
+          include_content = content.site.contents.where(kind: 'text').located(import_path, restricted: false)
+
+          unless include_content.present?
+            # Look for /_file.ext alternative
+            import_path = File.dirname(import_path) + '/_' + File.basename(import_path)
+            include_content = content.site.contents.located(import_path, restricted: false)
+          end
+
+        end
+
+        Scribo.config.logger.warn "SassC::Importer: No import found: #{import_path}" unless include_content.first
+        # FIXME: Add context
+        # Here we don't use a filter
+        source = ContentRenderService.new(include_content.first, {}, filter: nil).call || ''
+        ::SassC::Importer::Import.new(path, source: source)
+      end
+    end
+  end
+end
+
+module Tilt
+  class Template
+    def eval_file
+      options[:full_path] || file || '(__TEMPLATE__)'
+    end
+  end
+end