PixelForce_ETS 0.0.1

data/lib/comfortable_mexican_sofa/configuration.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+class ComfortableMexicanSofa::Configuration
+
+  # Don't like ComfortableMexicanSofa? Set it to whatever you like. :(
+  attr_accessor :cms_title
+
+  # Controller that is inherited from CmsAdmin::BaseController
+  # 'ApplicationController' is the default
+  attr_accessor :admin_base_controller
+
+  # Controller that Comfy::Cms::BaseController will inherit from
+  # 'ApplicationController' is the default
+  attr_accessor :public_base_controller
+
+  # Module that will handle authentication to access cms-admin area
+  attr_accessor :admin_auth
+
+  # Module that will handle authorization against admin cms resources
+  attr_accessor :admin_authorization
+
+  # Module that will handle authentication for public pages
+  attr_accessor :public_auth
+
+  # Module that will handle authorization against public resources
+  attr_accessor :public_authorization
+
+  # When arriving at /cms-admin you may chose to redirect to arbirtary path,
+  # for example '/cms-admin/users'
+  attr_accessor :admin_route_redirect
+
+  # With each page load, files will be synched with the database. Database entries are
+  # destroyed if there's no corresponding file. Seeds are disabled by default.
+  attr_accessor :enable_seeds
+
+  # Path where seeds can be located.
+  attr_accessor :seeds_path
+
+  # Number of revisions kept. Default is 25. If you wish to disable: set this to 0.
+  attr_accessor :revisions_limit
+
+  # Locale definitions. If you want to define your own locale merge
+  # {:locale => 'Locale Title'} with this.
+  attr_accessor :locales
+
+  # Admin interface will respect the locale of the site being managed. However you can
+  # force it to English by setting this to `:en`
+  attr_accessor :admin_locale
+
+  # A class that is included as a sweeper to admin base controller if it's set
+  attr_accessor :admin_cache_sweeper
+
+  # Not allowing erb code to be run inside page content. False by default.
+  # @return [Boolean]
+  attr_accessor :allow_erb
+
+  # Whitelist of all helper methods that can be used via {{cms:helper}} tag. By default
+  # all helpers are allowed except `eval`, `send`, `call` and few others. Empty array
+  # will prevent rendering of all helpers.
+  attr_accessor :allowed_helpers
+
+  # Whitelist of partials paths that can be used via {{cms:partial}} tag. All partials
+  # are accessible by default. Empty array will prevent rendering of all partials.
+  attr_accessor :allowed_partials
+
+  # Whitelist of template paths that can be used via {{cms:template}} tag. All templates
+  # are accessible by default. Empty array will prevent rendering of all templates.
+  attr_accessor :allowed_templates
+
+  # Site aliases, if you want to have aliases for your site. Good for harmonizing
+  # production env with dev/testing envs.
+  # e.g. config.site_aliases = {'host.com' => 'host.inv', 'host_a.com' => ['host.lvh.me', 'host.dev']}
+  # Default is nil (not used)
+  attr_accessor :hostname_aliases
+
+  # Reveal partials that can be overwritten in the admin area.
+  # Default is false.
+  attr_accessor :reveal_cms_partials
+
+  # Auto-setting parameter derived from the routes
+  attr_accessor :public_cms_path
+
+  # Customize returned content from `page.to_json`
+  # Default is set to `methods: [:content], except: [:content_cache]`
+  # For example: include fragments into json data with `config.page_to_json_options = { include: [:fragments] }`
+  attr_accessor :page_to_json_options
+
+  # Configuration defaults
+  def initialize
+    @cms_title              = "PixelForce_ETS"
+    @admin_base_controller  = "ApplicationController"
+    @public_base_controller = "ApplicationController"
+    @admin_auth             = "ComfortableMexicanSofa::AccessControl::AdminAuthentication"
+    @admin_authorization    = "ComfortableMexicanSofa::AccessControl::AdminAuthorization"
+    @public_auth            = "ComfortableMexicanSofa::AccessControl::PublicAuthentication"
+    @public_authorization   = "ComfortableMexicanSofa::AccessControl::PublicAuthorization"
+    @seed_data_path         = nil
+    @admin_route_redirect   = ""
+    @enable_sitemap         = true
+    @enable_seeds           = false
+    @seeds_path             = File.expand_path("db/cms_seeds", Rails.root)
+    @revisions_limit        = 25
+    @locales                = {
+      "ca"    => "Català",
+      "cs"    => "Česky",
+      "da"    => "Dansk",
+      "de"    => "Deutsch",
+      "en"    => "English",
+      "es"    => "Español",
+      "fi"    => "Suomi",
+      "fr"    => "Français",
+      "gr"    => "Ελληνικά",
+      "hr"    => "Hrvatski",
+      "it"    => "Italiano",
+      "ja"    => "日本語",
+      "nb"    => "Norsk",
+      "nl"    => "Nederlands",
+      "pl"    => "Polski",
+      "pt-BR" => "Português Brasileiro",
+      "ru"    => "Русский",
+      "sk"    => "Slovensky",
+      "sv"    => "Svenska",
+      "tr"    => "Türkçe",
+      "uk"    => "Українська",
+      "zh-CN" => "简体中文",
+      "zh-TW" => "正體中文"
+    }
+    @admin_locale         = nil
+    @admin_cache_sweeper  = nil
+    @allow_erb            = false
+    @allowed_helpers      = nil
+    @allowed_partials     = nil
+    @hostname_aliases     = nil
+    @reveal_cms_partials  = false
+    @public_cms_path      = nil
+    @page_to_json_options = { methods: [:content], except: [:content_cache] }
+  end
+
+end

data/lib/comfortable_mexican_sofa/content.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+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/page_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,14 @@
+# frozen_string_literal: true
+
+# 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_writer :nodes
+
+  def nodes
+    @nodes ||= []
+  end
+
+end

data/lib/comfortable_mexican_sofa/content/params_parser.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+class ComfortableMexicanSofa::Content::ParamsParser
+
+  class Error < StandardError; end
+
+  STRING_LITERAL  = %r{'[^']*'|"[^"]*"}
+  IDENTIFIER      = %r{[a-z0-9][\w\-/.]*}i
+  HASH_KEY        = %r{#{IDENTIFIER}:}
+  COMMA           = %r{,}
+  HASH_OPEN       = %r{\{}
+  HASH_CLOSE      = %r{\}}
+  ARRAY_OPEN      = %r{\[}
+  ARRAY_CLOSE     = %r{\]}
+
+  # @param <String> string
+  def initialize(string = "")
+    @string = string
+  end
+
+  # Takes CMS content tag parameters and converts them into array of strings,
+  # hashes and arrays.
+  #
+  # @return [Array<String, {String => String}>]
+  # @raise [Error] if the given `text` is malformed.
+  #
+  # @example
+  #   new("a, b, c").parse
+  #   #=> ["a", "b", "c"]
+  #
+  #   new("a, b: c, d: e").parse
+  #   #=> ["a", {"b" => "c", "d" => "e"}]
+  #
+  #   new("a, b: {c: [d, e]}").parse
+  #   #=> ["a", {"b" => {"c" => ["d", "e"]}}]
+  #
+  def params
+    @tokens = tokenize(@string)
+    parse_params
+  end
+
+private
+
+  # Contructs root-level list of arguments sent via content tag
+  def parse_params
+    params = []
+    while (token = @tokens.shift)
+      params << parse_value(token)
+    end
+    params
+  end
+
+  # Gets token value. Will trigger parsing of hash and array structures
+  def parse_value(token)
+    case token&.first
+    when :string
+      token[1]
+    when :hash_key
+      @tokens.unshift(token)
+      parse_hash
+    when :hash_open
+      parse_hash
+    when :array_open
+      parse_array
+    else
+      raise Error, "Invalid params: #{@string}"
+    end
+  end
+
+  # Hash constructor method. Will handle nested hashes as well
+  def parse_hash
+    opens = 1
+    hash = {}
+
+    while (token = @tokens.shift)
+      case token&.first
+      when :hash_key
+        hash[token[1]] = parse_value(@tokens.shift)
+      when :hash_close
+        opens -= 1
+      when :hash_open
+        opens += 1
+      else
+        raise Error, "Invalid params: #{@string}"
+      end
+
+      return hash if opens.zero?
+    end
+
+    # We're can't really detect unclosed hashes as we can construct them without
+    # opening brakets. For example, `a: b, c: d` is same as `{a: b, c: d}` and
+    # `{a: b, c: d` is also ends up to be a valid hash. It will error out if
+    # unclosed hash is followed by some other unexpected token. Like: `{a: b, c`
+    hash
+  end
+
+  # Array construction method. Will handle nested arrays
+  def parse_array
+    opens = 1
+    array = []
+    while (token = @tokens.shift)
+      case token&.first
+      when :array_close
+        opens -= 1
+      else
+        array << parse_value(token)
+      end
+
+      return array if opens.zero?
+    end
+
+    raise Error, "Unclosed array param: #{@string}"
+  end
+
+  # Tokenizing input string into a list of touples
+  # Also args_string is stripped of "smart" quotes coming from wysiwyg
+  #
+  # @param [String] args_string
+  # @return [Array<String>] tokens
+  def tokenize(args_string)
+    args_string = args_string.tr("“”‘’", %q(""''))
+    ss = StringScanner.new(args_string)
+    tokens = []
+    loop do
+      ss.skip(%r{\s*})
+      break if ss.eos?
+
+      # commas are just separators like spaces
+      next if ss.scan(COMMA)
+
+      tokens <<
+        if    (t = ss.scan(STRING_LITERAL)) then [:string, t[1...-1]]
+        elsif (t = ss.scan(HASH_KEY))       then [:hash_key, t[0...-1]]
+        elsif (t = ss.scan(IDENTIFIER))     then [:string, t]
+        elsif (t = ss.scan(HASH_OPEN))      then [:hash_open, t]
+        elsif (t = ss.scan(HASH_CLOSE))     then [:hash_close, t]
+        elsif (t = ss.scan(ARRAY_OPEN))     then [:array_open, t]
+        elsif (t = ss.scan(ARRAY_CLOSE))    then [:array_close, t]
+        else
+          raise Error, "Unexpected char: #{ss.getch}"
+        end
+    end
+
+    tokens
+  end
+
+end

data/lib/comfortable_mexican_sofa/content/renderer.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+# 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 = %r{\{\{\s*?cms:(?<class>\w+)(?<params>.*?)\}\}}
+
+  class << self
+
+    # @return [Hash<String, Class<ComfortableMexicanSofa::Content::Tag>>]
+    def tags
+      @tags ||= {}
+    end
+
+    # @param [String] name
+    # @param [Class<ComfortableMexicanSofa::Content::Tag>] klass
+    def register_tag(name, klass)
+      tags[name.to_s] = klass
+    end
+
+  end
+
+  # @param [Comfy::Cms::WithFragments, nil] context
+  def initialize(context)
+    @context = context
+    @depth   = 0
+  end
+
+  # This is how we render content out. Takes context (cms page) and content
+  # nodes
+  # @param [Array<String, ComfortableMexicanSofa::Content::Tag>]
+  # @param [Boolean] allow_erb
+  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
+  # @return [Array<String, {Symbol => String}>]
+  def tokenize(string)
+    tokens = []
+    ss = StringScanner.new(string.to_s)
+    while (string = ss.scan_until(TAG_REGEX))
+      text = string.sub(ss[0], "")
+      tokens << text unless text.empty?
+      tokens << {
+        tag_class:  ss[:class],
+        tag_params: ss[:params].strip,
+        source:     ss[0]
+      }
+    end
+    text = ss.rest
+    tokens << text if text.present?
+    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.
+  # @param [Array<String, {Symbol => String}>] tokens
+  # @return [Array<String, ComfortableMexicanSofa::Content::Tag>]
+  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
+          # @type [Class<ComfortableMexicanSofa::Content::Tag>]
+          klass = self.class.tags[tag_class] ||
+            raise(SyntaxError, "Unrecognized tag: #{token[:source]}")
+
+          # @type [ComfortableMexicanSofa::Content::Tag]
+          tag = klass.new(
+            context:  @context,
+            params:   ComfortableMexicanSofa::Content::ParamsParser.new(token[:tag_params]).params,
+            source:   token[:source]
+          )
+          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