liquidum 1.0.17

data/lib/liquidum/liquid/liquid_helpers.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Liquidum
+  module LiquidHelpers
+    private
+
+    def initialize(tag, args, tokens)
+      super
+      @blank = false
+      begin
+        @args = Liquidum::Tag::Parser.new(args).args
+      rescue Parslet::ParseFailed => e
+        raise Parslet::ParseFailed, e.message + " (#{tag} #{args})"
+      end
+    end
+
+    def render(context)
+      @context = context
+    end
+
+    def render_body
+      @body.render(@context)
+    end
+
+    # Return named argument
+    def arg(name)
+      raise 'No @context set' unless @context
+
+      attr = @args.find { |a| a[:attr] == name.to_s }
+      return unless attr
+
+      if attr.key? :value
+        attr[:value].to_s
+      elsif attr.key? :lvalue
+        lookup(@context, attr[:lvalue].to_s)
+      end
+    end
+
+    # Returns the first argument - usually reserved for literal or quoted values, not for attribute value pairs
+    # When the first attribute is a pair, it will return nil
+    def argv1
+      raise 'No @context set' unless @context
+
+      argv1 = @args[0]
+      return unless argv1
+
+      if argv1.key? :quoted
+        argv1[:quoted].to_s
+      elsif argv1.key? :literal
+        @context.key?(argv1[:literal].to_s) ? @context[argv1[:literal].to_s] : argv1[:literal].to_s
+      end
+    end
+
+    # Returns the standalone arguments
+    def sargs
+      raise 'No @context set' unless @context
+
+      @args.slice(1..-1).select { |a| a.key?(:quoted) || a.key?(:literal) }.map do |a|
+        if a.key? :quoted
+          a[:quoted].to_s
+        elsif a.key? :literal
+          lookup(@context, a[:literal].to_s) || a[:literal]
+        end
+      end
+    end
+
+    # Returns the attribute-value-pair arguments as a hash
+    def attr_args
+      raise 'No @context set' unless @context
+
+      result = {}
+      @args.select { |a| a.key?(:value) || a.key?(:lvalue) || a.key?(:svalue) }.map do |a|
+        if a.key? :value
+          result[a[:attr].to_sym] = a[:value].to_s
+        elsif a.key? :lvalue
+          result[a[:attr].to_sym] = lookup(@context, a[:lvalue].to_s) || a[:lvalue]
+        elsif a.key? :svalue
+          result[a[:attr].to_sym] = a[:svalue].to_sym
+        end
+      end
+      result
+    end
+
+    # Returns an attribute string if the attribute has a value, for use in making HTML
+    #
+    # @param [Symbol] attr
+    # @param [Object] value
+    # @param [Object] default
+    # @return [String]
+    def attr_str(attr, value, default = nil)
+      v = value || default
+      v.present? ? " #{attr}=\"#{v}\"" : ''
+    end
+
+    def attrs_str(*attrs, reject: [])
+      attrs = @args.map { |a| a[:attr] }.reject { |a| a.nil? || reject.include?(a) } if attrs.empty?
+
+      result = []
+      attrs.each do |attr|
+        result << attr_str(attr, arg(attr))
+      end
+      result.join
+    end
+
+    # Lookup allows access to the assigned variables through the context
+    def lookup(context, name)
+      return unless name
+
+      context[name]
+    end
+
+    # For use with forms and inputs
+    def input(purpose, name)
+      form_model      = lookup(@context, 'form.model')
+      form_class_name = lookup(@context, 'form.class_name')
+
+      # binding.pry if name == 'postal_code'
+
+      # order[order_lines_attributes][xxxx][product_name]
+      #
+      # order[order_attributes]_[lines_attributes][][product_name]
+
+      parts = @context.scopes.select { |scope| scope.key? 'form' }.map do |scope|
+        if scope['form'].attribute
+          scope['form'].attribute.to_s.gsub(/([a-z\-\_]+)/) { "[#{Regexp.last_match(1)}_attributes]" }.gsub(/\[\]$/, "[#{SecureRandom.uuid}]")
+        else
+          scope['form'].class_name.underscore.gsub('/', '_')
+        end
+      end
+      parts = parts.unshift("[#{name}]").reverse
+
+      return unless form_model && form_class_name && name
+
+      case purpose
+      when :id
+        parts.join('_').gsub('][', '_').tr('][', '')
+      when :value
+        # This is executed on the drop, drops provide the values for the form
+        form_model.send(name.to_sym)
+      when :name
+        # The original class's name dictates the name of the fields
+        parts.first + parts.slice(1..-1).join
+      when :error
+        parts.slice(1..-1).join('.')
+      when :checked
+        'checked' if (input(:value, name) ? 1 : 0) == 1
+      end
+    end
+
+    # Returns the path for the input from the main form, say: origin.contact_name
+    def path_for_input(name)
+      parts = @context.scopes.select { |scope| scope.key? 'form' }.select { |scope| scope['form'].attribute }.map do |scope|
+        scope['form'].attribute
+      end
+      parts = parts.unshift(name.to_s).reverse
+      parts.join('.')
+    end
+
+    def real_object_from_drop(drop)
+      drop.instance_variable_get('@object')
+    end
+  end
+end

data/lib/liquidum/liquid/liquid_template_extensions.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+#
+# This is here to allow you to block certain tags for certain templates.
+# Say in emails or exports it doesn't make sense to allow forms, you could exclude it as follows:
+#
+#   template = Liquid::Template.parse(data, block_tags: %w[form])
+#
+module Liquid
+  class ParseContext
+    def block_tags
+      @options[:block_tags]
+    end
+  end
+
+  class BlockBody
+    alias parse_without_setting_parse_context parse
+
+    def parse(tokenizer, parse_context, &block)
+      @parse_context = parse_context
+      parse_without_setting_parse_context(tokenizer, parse_context, &block)
+    end
+
+    def registered_tags
+      allowed_tags = Template.tags.dup
+      if @parse_context.block_tags.present?
+        @parse_context.block_tags.each do |tag|
+          allowed_tags.delete(tag)
+        end
+      end
+      allowed_tags
+    end
+  end
+end

data/lib/liquidum/liquid/liquidum_block.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class LiquidumBlock < Liquid::Block
+  include Liquidum::LiquidHelpers
+end

data/lib/liquidum/liquid/liquidum_tag.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class LiquidumTag < Liquid::Tag
+  include Liquidum::LiquidHelpers
+end

data/lib/liquidum/liquid/parser.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Liquidum
+  class Tag
+    require 'parslet'
+
+    class MiniP < Parslet::Parser
+      # Single character rules
+      rule(:squote) { str("'").repeat(1) }
+      rule(:dquote) { str('"').repeat(1) }
+
+      rule(:colon_or_eql) { match[":|="].repeat(1) }
+
+      rule(:space) { match('\s').repeat(1) }
+      rule(:space?) { space.maybe }
+
+      # Things
+      rule(:identifier) { (match('[a-zA-Z]') >> match('[a-zA-Z0-9\.\/\_\-\[\]\'\"]').repeat) }
+      rule(:symbol_literal) { colon_or_eql >> identifier.as(:svalue) }
+
+      rule(:nsqvalue) { match["^'"] }
+      rule(:ndqvalue) { match['^"'] }
+
+      rule(:literal_value) { identifier >> colon_or_eql >> identifier }
+
+      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(:standalone_squoted_value) { squote >> nsqvalue.repeat.as(:quoted) >> squote }
+      rule(:standalone_dquoted_value) { dquote >> ndqvalue.repeat.as(:quoted) >> dquote }
+      rule(:standalone_quoted_value) { standalone_squoted_value | standalone_dquoted_value }
+
+      # Grammar parts
+      rule(:standalone) { identifier.as(:literal) >> space? }
+      rule(:quoted) { standalone_quoted_value >> space? }
+      rule(:attr_with_literal) { identifier.as(:attr) >> space? >> colon_or_eql >> space? >> identifier.as(:lvalue) >> space? }
+      rule(:attr_with_quoted) { identifier.as(:attr) >> space? >> colon_or_eql >> space? >> quoted_value >> space? }
+
+      rule(:attribute) { attr_with_quoted | attr_with_literal | quoted | standalone }
+      rule(:expression) { attribute.repeat }
+      root :expression
+    end
+
+    class Parser
+      attr_reader :args
+
+      def initialize(raw)
+        @args = MiniP.new.parse(raw)
+      end
+    end
+  end
+end

data/lib/liquidum/liquid/tags/helper_tag.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Allow you to use helpers
+#
+# == Basic usage:
+#    {%helper 'user_index_path'%}
+#    {%helper 'check_box_tag' pet_dog%}
+#
+# == Advanced usage:
+#    {%helper 'user_index_path' user%}
+#
+
+class HelperTag < LiquidumTag
+  include Rails.application.routes.url_helpers
+
+  def render(context)
+    super
+
+    helper_args = sargs
+    helper_args = helper_args.concat([attr_args]) if attr_args.present?
+
+    if respond_to?(argv1.to_sym)
+      send(argv1.to_sym, *helper_args)
+    else
+      context.registers['controller'].helpers.send(argv1.to_sym, *helper_args)
+    end
+  end
+end
+
+Liquid::Template.register_tag('helper', HelperTag)

data/lib/liquidum/liquid/tags/render_tag.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Render content from variable
+#
+# == Basic usage:
+#    {%render product.description}
+#
+class RenderTag < LiquidumTag
+  def render(context)
+    super
+
+    return unless argv1
+
+    template = Liquid::Template.parse(argv1)
+    template.render(context, registers: context.registers)
+  end
+end
+
+Liquid::Template.register_tag('render', RenderTag)

data/lib/liquidum/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Liquidum
+  VERSION = '1.0.17'
+end

data/lib/liquidum.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'liquid'
+require 'tilt'
+require 'sassc'
+require "addressable/uri"
+
+require 'liquidum/version'
+require 'liquidum/engine'
+require 'liquidum/configuration'
+require 'liquidum/drop'
+
+require 'liquidum/liquid/liquid_helpers'
+require 'liquidum/liquid/liquid_template_extensions'
+require 'liquidum/liquid/liquidum_block'
+require 'liquidum/liquid/liquidum_tag'
+require 'liquidum/liquid/parser'
+
+module Liquidum
+  class Error < StandardError; end
+  class UnknownStepTypeError < Error; end
+
+  class LiquidumFileSystem
+    attr_reader :registers
+    def initialize(registers)
+      @registers = registers
+    end
+
+    def read_template_file(template_path)
+      current_content = registers['content']
+
+      contents = current_content.site.contents.published
+
+      content = contents.include(template_path).first
+      content&.data || ''
+    end
+  end
+
+  class << self
+    attr_reader :config
+
+    def setup
+      @config = Configuration.new
+      yield config
+    end
+
+    def render(content, options = {})
+      template = Liquid::Template.parse(content)
+      options[:assigns] ||= {}
+      options[:registers] ||= {}
+      options[:registers]['file_system'] = Liquidum.config.liquidum_file_system.constantize.new(options[:registers])
+      result = template.render(options[:context] || options[:assigns].stringify_keys, registers: options[:registers])
+
+      if template.errors.present?
+        Liquidum.config.logger.error '--- Template rendering errors: ' + '-' * 49
+        template.errors.map do |error|
+          next unless error.cause
+
+          Liquidum.config.logger.error error
+          Liquidum.config.logger.error '=> ' + error.cause.backtrace.first.to_s + ': ' + error.cause.message
+        end
+        Liquidum.config.logger.error '-' * 80
+      end
+
+      assigns = options[:assigns].deep_stringify_keys
+      assigns = assigns.merge(template.assigns.stringify_keys) if template.assigns
+      options[:registers].deep_merge!(template.registers.stringify_keys) if template.registers
+
+      result = Tilt[options[:filter]].new(options[:filter_options]) { result }.render if options[:filter].present? && Tilt[options[:filter]]
+      if options[:layout].present?
+        result = render(options[:layout], assigns: assigns.merge('content' => result), registers: options[:registers])
+      end
+
+      result
+    end
+  end
+end