comfortable_mexican_sofa 1.12.11 → 2.0.0

data/lib/comfortable_mexican_sofa/content.rb

@@ -0,0 +1,28 @@
+module ComfortableMexicanSofa::Content
+  # ...
+end
+
+require_relative 'content/renderer'
+require_relative 'content/params_parser'
+require_relative 'content/tag'
+require_relative 'content/block'
+
+require_relative 'content/tags/fragment'
+
+require_relative 'content/tags/wysiwyg'
+require_relative 'content/tags/text'
+require_relative 'content/tags/textarea'
+require_relative 'content/tags/markdown'
+require_relative 'content/tags/datetime'
+require_relative 'content/tags/date'
+require_relative 'content/tags/number'
+require_relative 'content/tags/checkbox'
+require_relative 'content/tags/file'
+require_relative 'content/tags/files'
+
+require_relative 'content/tags/snippet'
+require_relative 'content/tags/asset'
+require_relative 'content/tags/file_link'
+require_relative 'content/tags/helper'
+require_relative 'content/tags/partial'
+require_relative 'content/tags/template'

data/lib/comfortable_mexican_sofa/content/block.rb

@@ -0,0 +1,11 @@
+# wtf does this mean
+# it means that all nodes between this must be moved into here
+# {{cms:block}} some content {{cms:end_block}}
+class ComfortableMexicanSofa::Content::Block < ComfortableMexicanSofa::Content::Tag
+
+  attr_accessor :nodes
+
+  def nodes
+    @nodes ||= []
+  end
+end

data/lib/comfortable_mexican_sofa/content/params_parser.rb

@@ -0,0 +1,80 @@
+module ComfortableMexicanSofa::Content::ParamsParser
+
+  class Error < StandardError; end
+
+  SINGLE_STRING_LITERAL = /'[^\']*'/
+  DOUBLE_STRING_LITERAL = /"[^\"]*"/
+  IDENTIFIER            = /[a-z0-9][\w\-\/.]*/i
+  COLUMN                = /\:/
+  COMMA                 = /\,/
+
+  def self.parse(text)
+    parameterize(slice(tokenize(text.to_s)))
+  end
+
+  def self.parameterize(token_groups)
+    params = [ ]
+    token_groups.each do |tokens|
+      case
+      when tokens.count == 1
+        collect_param_for_string!(params, tokens[0])
+      when tokens.count == 3
+        collect_param_for_hash!(params, tokens)
+      else
+        raise Error, "Unexpected tokens found: #{tokens}"
+      end
+    end
+    params
+  end
+
+  def self.collect_param_for_string!(params, token)
+    type, value = token
+    raise Error, "Unexpected token: #{token}" unless type == :string
+    params << value
+  end
+
+  def self.collect_param_for_hash!(params, tokens)
+    key, col, val = tokens
+    key_type, key_value = key
+    col_type, _         = col
+    val_type, val_value = val
+
+    unless key_type == :string && col_type == :column && val_type == :string
+      raise Error, "Unexpected tokens: #{tokens}"
+    end
+
+    hash = params.last.is_a?(Hash) ? params.pop : {}
+    hash[key_value] = val_value
+    params << hash
+  end
+
+  # grouping tokens based on the comma and also removing comma tokens
+  def self.slice(tokens)
+    tokens.slice_after do |token|
+      token[0] == :comma
+    end.map do |expression|
+      expression.reject{|t| t[0] == :comma}
+    end
+  end
+
+  # tokenizing input string into a list of touples
+  def self.tokenize(args_string)
+    tokens = []
+    ss = StringScanner.new(args_string)
+    until ss.eos?
+      ss.skip(/\s*/)
+      break if ss.eos?
+      token = case
+        when t = ss.scan(SINGLE_STRING_LITERAL) then [:string, t[1...t.size - 1]]
+        when t = ss.scan(DOUBLE_STRING_LITERAL) then [:string, t[1...t.size - 1]]
+        when t = ss.scan(IDENTIFIER)            then [:string, t]
+        when t = ss.scan(COLUMN)                then [:column, t]
+        when t = ss.scan(COMMA)                 then [:comma, t]
+        else
+          raise Error, "Unexpected char: #{ss.getch}"
+      end
+      tokens << token
+    end
+    tokens
+  end
+end

data/lib/comfortable_mexican_sofa/content/renderer.rb

@@ -0,0 +1,125 @@
+# Processing content follows these stages:
+#
+#   string        - Text with tags. like this: "some {{cms:fragment content}} text"
+#   tokenization  - Splits string into a list of strings and hashes that define tags
+#                   Example: ["some ", {tag_class: "fragment", tag_params: ""}, " text"]
+#   nodefying     - Initializes Tag instances from tag hashes and returns list
+#                   like this: ["some ", (FragmentTagInstance), " text"]
+#   rendering     - Recursively iterates through nodes. Tag instances get their
+#                   `render` method called. Result of that is tokenized, nodefied
+#                   and rendered once again until there are no tags to expand.
+#                   Resulting list is flattened and joined into a final rendered string.
+#
+class ComfortableMexicanSofa::Content::Renderer
+
+  class SyntaxError < StandardError; end
+  class Error < StandardError; end
+
+  MAX_DEPTH = 100
+
+  # tags are in this format: {{ cms:tag_class params }}
+  TAG_REGEX = /\{\{\s*?cms:(?<class>\w+)(?<params>.*?)\}\}/
+
+  class << self
+
+    def tags
+      @tags ||= {}
+    end
+
+    def register_tag(name, klass)
+      tags[name.to_s] = klass
+    end
+  end
+
+  def initialize(context)
+    @context = context
+    @depth   = 0
+  end
+
+  # This is how we render content out. Takes context (cms page) and content
+  # nodes
+  def render(nodes, allow_erb = ComfortableMexicanSofa.config.allow_erb)
+    if (@depth += 1) > MAX_DEPTH
+      raise Error, "Deep tag nesting or recursive nesting detected"
+    end
+
+    nodes.map do |node|
+      case node
+      when String
+        sanitize_erb(node, allow_erb)
+      else
+        tokens  = tokenize(node.render)
+        nodes   = nodes(tokens)
+        render(nodes, allow_erb || node.allow_erb)
+      end
+    end.flatten.join
+  end
+
+  def sanitize_erb(string, allow_erb)
+    if allow_erb
+      string.to_s
+    else
+      string.to_s.gsub('<%', '&lt;%').gsub('%>', '%&gt;')
+    end
+  end
+
+  # Splitting text with tags into tokens we can process down the line
+  def tokenize(string)
+    tokens = []
+    ss = StringScanner.new(string.to_s)
+    while string = ss.scan_until(TAG_REGEX)
+      text = string.sub(ss[0], '')
+      tokens << text if text.length > 0
+      tokens << {tag_class: ss[:class], tag_params: ss[:params].strip}
+    end
+    text = ss.rest
+    tokens << text if text.present?
+    return tokens
+  end
+
+  # Constructing node tree for content. It's a list of strings and tags with
+  # their own `nodes` method that has array of strings and tags with their own
+  # `nodes` method that... you get the idea.
+  def nodes(tokens)
+    nodes = [[]]
+    tokens.each do |token|
+      case token
+
+      # tag signature
+      when Hash
+        case tag_class = token[:tag_class]
+
+        # This handles {{cms:end}} tag. Stopping collecting block nodes.
+        when "end"
+          if nodes.count == 1
+            raise SyntaxError, "closing unopened block"
+          end
+          nodes.pop
+
+        else
+          unless klass = self.class.tags[tag_class]
+            raise SyntaxError, "Unrecognized tag #{tag_class}: #{token}"
+          end
+
+          tag = klass.new(@context, token[:tag_params])
+          nodes.last << tag
+
+          # If it's a block tag we start collecting nodes into it
+          if tag.is_a?(ComfortableMexicanSofa::Content::Block)
+            nodes << tag.nodes
+          end
+        end
+
+      # text
+      else
+        nodes.last << token
+      end
+    end
+
+    if nodes.count > 1
+      raise SyntaxError, "unclosed block detected"
+    end
+
+    nodes.flatten
+  end
+end

data/lib/comfortable_mexican_sofa/content/tag.rb

@@ -0,0 +1,37 @@
+class ComfortableMexicanSofa::Content::Tag
+
+  class Error < StandardError; end
+
+  attr_reader :context, :params
+
+  def initialize(context, params_string)
+    @context  = context
+    @params   = parse_params_string(params_string)
+  end
+
+  # Making sure we don't leak erb from tags by accident.
+  # Tag classes can override this, like partials/helpers tags.
+  def allow_erb
+    false || ComfortableMexicanSofa.config.allow_erb
+  end
+
+  # Normally it's a string. However if tag content has tags, we need to expand
+  # them and that produces potentually more stuff
+  def nodes
+    template = ComfortableMexicanSofa::Content::Renderer.new(@context)
+    tokens = template.tokenize(content)
+    template.nodes(tokens)
+  end
+
+  def content
+    raise Error, "This is a base class. It holds no content"
+  end
+
+  def render
+    content
+  end
+
+  def parse_params_string(string)
+    ComfortableMexicanSofa::Content::ParamsParser.parse(string)
+  end
+end

data/lib/comfortable_mexican_sofa/content/tags/asset.rb

@@ -0,0 +1,56 @@
+# This tag allows for linking of js and css content defined on the layout.
+# Looks something like this:
+#   {{cms:asset layout_identifier, type: css, as: tag}}
+#
+# `type` - css | js - what we're outputting here
+# `as`   - url (default) | tag - output url or wrap it in the appropriate tag
+#
+class ComfortableMexicanSofa::Content::Tag::Asset < ComfortableMexicanSofa::Content::Tag
+
+  attr_reader :identifier, :type, :as
+
+  def initialize(context, params_string)
+    super
+
+    options = params.extract_options!
+    @identifier = params[0]
+    @type       = options["type"]
+    @as         = options["as"] || "url"
+
+    unless @identifier.present?
+      raise Error, "Missing layout identifier for asset tag"
+    end
+  end
+
+  def layout
+    @layout ||= context.site.layouts.find_by(identifier: @identifier)
+  end
+
+  def content
+    return "" unless layout
+
+    base = ComfortableMexicanSofa.config.public_cms_path || ''
+    unless base.ends_with?("/")
+      base = base + "/"
+    end
+
+    case @type
+    when "css"
+      out = "#{base}cms-css/#{context.site.id}/#{@identifier}/#{layout.cache_buster}.css"
+      if @as == 'tag'
+        out = "<link href='#{out}' media='screen' rel='stylesheet' type='text/css' />"
+      end
+      out
+    when "js"
+      out = "#{base}cms-js/#{context.site.id}/#{@identifier}/#{layout.cache_buster}.js"
+      if @as == "tag"
+        out = "<script src='#{out}' type='text/javascript'></script>"
+      end
+      out
+    end
+  end
+end
+
+ComfortableMexicanSofa::Content::Renderer.register_tag(
+  :asset, ComfortableMexicanSofa::Content::Tag::Asset
+)

data/lib/comfortable_mexican_sofa/content/tags/checkbox.rb

@@ -0,0 +1,21 @@
+# Tag for boolean content that is going to be rendered using checkbox
+#   {{ cms:checkbox identifier }}
+#
+class ComfortableMexicanSofa::Content::Tag::Checkbox < ComfortableMexicanSofa::Content::Tag::Fragment
+
+  def content
+    fragment.boolean
+  end
+
+  def form_field(object_name, view, index, &block)
+    name = "#{object_name}[fragments_attributes][#{index}][boolean]"
+    checkbox_hidden = view.hidden_field_tag(name, "0", id: nil)
+    checkbox_input  = view.check_box_tag(name, "1", self.content.present?, id: nil)
+
+    yield [checkbox_hidden, checkbox_input].join.html_safe
+  end
+end
+
+ComfortableMexicanSofa::Content::Renderer.register_tag(
+  :checkbox, ComfortableMexicanSofa::Content::Tag::Checkbox
+)

data/lib/comfortable_mexican_sofa/content/tags/date.rb

@@ -0,0 +1,22 @@
+# Tag for text content that is going to be rendered using text input with date widget
+#   {{ cms:date identifier }}
+#
+class ComfortableMexicanSofa::Content::Tag::Date < ComfortableMexicanSofa::Content::Tag::Fragment
+
+  def content
+    fragment.datetime
+  end
+
+  def form_field(object_name, view, index, &block)
+    name    = "#{object_name}[fragments_attributes][#{index}][datetime]"
+    options = {id: nil, class: "form-control", data: {"cms-date" => true}}
+    value   = self.content.present?? self.content.to_s(:db) : ""
+    input   = view.send(:text_field_tag, name, value, options)
+
+    yield input
+  end
+end
+
+ComfortableMexicanSofa::Content::Renderer.register_tag(
+  :date, ComfortableMexicanSofa::Content::Tag::Date
+)

data/lib/comfortable_mexican_sofa/content/tags/datetime.rb

@@ -0,0 +1,22 @@
+# Tag for text content that is going to be rendered using text input with datetime widget
+#   {{ cms:datetime identifier }}
+#
+class ComfortableMexicanSofa::Content::Tag::Datetime < ComfortableMexicanSofa::Content::Tag::Fragment
+
+  def content
+    fragment.datetime
+  end
+
+  def form_field(object_name, view, index, &block)
+    name    = "#{object_name}[fragments_attributes][#{index}][datetime]"
+    options = {id: nil, class: "form-control", data: {"cms-datetime" => true}}
+    value   = self.content.present?? self.content.to_s(:db) : ""
+    input   = view.send(:text_field_tag, name, value, options)
+
+    yield input
+  end
+end
+
+ComfortableMexicanSofa::Content::Renderer.register_tag(
+  :datetime, ComfortableMexicanSofa::Content::Tag::Datetime
+)

data/lib/comfortable_mexican_sofa/content/tags/file.rb

@@ -0,0 +1,77 @@
+# File tag allows attaching of file to the page. This controls how files are
+# uploaded and then displayed on the page. Example tag:
+#   {{cms:file identifier, as: link, label: "My File"}}
+#
+# `as`      - url (default) | link | image - render out link or image tag
+# `label`   - attach label attribute to link or image tag
+# `resize`  - imagemagic option. For example: "100x50>"
+# `gravity` - imagemagic option. For example: "center"
+# `crop`    - imagemagic option. For example: "100x50+0+0"
+#
+class ComfortableMexicanSofa::Content::Tag::File < ComfortableMexicanSofa::Content::Tag::Fragment
+
+  attr_reader :as, :variant_attrs
+
+  def initialize(context, params_string)
+    super
+    @as             = options["as"] || "url"
+    @label          = options["label"]
+    @variant_attrs  = options.slice("resize", "gravity", "crop")
+  end
+
+  def content(file = attachment)
+    return "" unless file
+
+    if @variant_attrs.present? && attachment.image?
+      file = file.variant(@variant_attrs)
+    end
+
+    case @as
+    when "link"
+      "<a href='#{url_for(file)}' target='_blank'>#{label}</a>"
+    when "image"
+      "<img src='#{url_for(file)}' alt='#{label}'/>"
+    else
+      url_for(file)
+    end
+  end
+
+  def form_field(object_name, view, index, &block)
+    name    = "#{object_name}[fragments_attributes][#{index}][files]"
+    input   = view.send(:file_field_tag, name, {id: nil})
+
+    attachments_partial = if fragment.attachments
+      view.render(
+        partial: "comfy/admin/cms/pages/fragment_attachments",
+        locals: {
+          object_name:  object_name,
+          index:        index,
+          attachments:  fragment.attachments
+        }
+      )
+    end
+
+    yield [input, attachments_partial].join.html_safe
+  end
+
+protected
+
+  def attachment
+    fragment.attachments.first
+  end
+
+  def label
+    @label || attachment && attachment.filename
+  end
+
+  def url_for(attachment)
+    ApplicationController.render(
+      inline: "<%= url_for(@attachment) %>",
+      assigns: {attachment: attachment}
+    )
+  end
+end
+
+ComfortableMexicanSofa::Content::Renderer.register_tag(
+  :file, ComfortableMexicanSofa::Content::Tag::File
+)