twig_ruby 0.0.1 → 0.0.2

data/lib/twig/extension/debug.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Twig
+  module Extension
+    class Debug < Extension::Base
+      def functions
+        [
+          TwigFunction.new('dump', method(:dump), needs_environment: true, needs_context: true),
+        ]
+      end
+
+      def dump(environment, context, *vars)
+        return '' unless environment.debug?
+
+        begin
+          if vars.empty?
+            context
+          else
+            vars.one? ? vars.first : vars
+          end
+        end.inspect
+      end
+    end
+  end
+end

data/lib/twig/extension/escaper.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Twig
+  module Extension
+    class Escaper < Base
+      def initialize(default_strategy = :html)
+        super()
+
+        self.default_strategy = default_strategy
+      end
+
+      def filters
+        [
+          TwigFilter.new('escape', runtime(Runtime::Escaper, :escape), {
+            is_safe_callback: static(:escape_filter_is_safe),
+          }),
+          TwigFilter.new('e', runtime(Runtime::Escaper, :escape), {
+            is_safe_callback: static(:escape_filter_is_safe),
+          }),
+          TwigFilter.new('raw', nil, {
+            is_safe: [:all], node_class: Node::Expression::Filter::Raw
+          }),
+        ]
+      end
+
+      def token_parsers
+        [
+          TokenParser::AutoEscape.new,
+        ]
+      end
+
+      def node_visitors
+        [
+          NodeVisitor::Escaper.new,
+        ]
+      end
+
+      # Sets the default strategy to use when not defined by the user.
+      #
+      # @param [Symbol, String, false, Proc] strategy An escaping strategy
+      def default_strategy=(strategy)
+        @default_strategy = if [:name, 'name'].include?(strategy)
+                              ->(name) { FileExtensionEscapingStrategy.guess(name) }
+                            else
+                              strategy
+                            end
+      end
+
+      # Gets the default strategy to use when not defined by the user.
+      #
+      # @param [String] name The template name
+      # @return [Symbol, false] The default strategy to use for the template
+      def default_strategy(name)
+        if @default_strategy.is_a?(Proc)
+          @default_strategy.call(name)
+        else
+          @default_strategy
+        end
+      end
+
+      # @param [Node::Base] filter_args
+      def self.escape_filter_is_safe(filter_args)
+        filter_args.nodes.each_value do |arg|
+          if arg.is_a?(Node::Expression::Constant)
+            return [arg.attributes[:value]]
+          end
+        end
+
+        [:html]
+      end
+    end
+  end
+end

data/lib/twig/extension/rails.rb

@@ -4,67 +4,20 @@ module Twig
   module Extension
     class Rails < Extension::Base
       def filters
-        {}
+        [
+          TwigFilter.new('striptags', method(:strip_tags)),
+        ]
       end
 
-      def helper_methods
-        %w[
-          render
-
-          distance_of_time_in_words
-          time_ago_in_words
-
-          number_to_currency
-          number_to_human
-          number_to_human_size
-          number_to_percentage
-          number_to_phone
-          number_with_delimiter
-          number_with_precision
-
-          excerpt
-          pluralize
-          truncate
-          word_wrap
-
-          button_to
-          current_page?
-          link_to
-          mail_to
-          url_for
-
-          raw
-          sanitize
-          sanitize_css
-          strip_links
-          strip_tags
-
-          audio_tag
-          auto_discovery_link_tag
-          favicon_link_tag
-          image_tag
-          javascript_include_tag
-          picture_tag
-          preload_link_tag
-          stylesheet_link_tag
-          video_tag
-
-          escape_javascript
-          javascript_tag
-
-          benchmark
-          cache
-          debug
-
-          tag
-          token_list
-
-          form_for
-          form_with
-
-          date_test
+      def token_parsers
+        [
+          TokenParser::Cache.new,
         ]
       end
+
+      def strip_tags(string, tags = [])
+        ApplicationController.helpers.sanitize(string, tags:)
+      end
     end
   end
 end

data/lib/twig/extension/string_loader.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Twig
+  module Extension
+    class StringLoader < Extension::Base
+      def functions
+        [
+          TwigFunction.new('template_from_string', static(:template_from_string), needs_environment: true),
+        ]
+      end
+
+      # @param [Environment] environment
+      # @param [String] string
+      def self.template_from_string(environment, string, name = nil)
+        environment.create_template(string, name)
+      end
+    end
+  end
+end

data/lib/twig/extension_set.rb

@@ -15,55 +15,152 @@ module Twig
 
     # @param [Extension::Base] extension
     def add(extension)
-      raise "Extension #{extension.class.name} already added" if has?(extension)
+      raise "Extension #{extension.class} already added" if has?(extension)
 
-      @extensions[extension.class.name] = extension
+      @extensions[key(extension)] = extension
     end
 
     # @param [Object, String] extension
     # @return [Boolean]
     def has?(extension)
-      extension = extension.class.name unless extension.is_a?(String)
-      extensions.key?(extension.to_s)
+      extensions.key?(key(extension))
     end
 
-    def operators
-      all_unary = {}
-      all_binary = {}
+    # @return [Extension::Base]
+    def get(extension)
+      extensions[key(extension)]
+    end
 
-      extensions.values.map(&:operators).each do |unary, binary|
-        all_unary.merge!(unary)
-        all_binary.merge!(binary)
+    def expression_parsers
+      @expression_parsers ||= ExpressionParser::ExpressionParsers.new.tap do |parsers|
+        extensions.each_value do |extension|
+          parsers.add(extension.expression_parsers)
+        end
       end
+    end
 
-      [all_unary, all_binary]
+    # @return [Hash{String => TwigFilter}]
+    def filters
+      @filters ||= extensions.
+        values.
+        map(&:filters).
+        flatten.
+        to_h { |filter| [filter.name, filter] }
     end
 
-    def helper_methods
-      @helper_methods ||= extensions.
+    # @return [Hash{String => TwigFunction}]
+    def functions
+      @functions ||= extensions.
         values.
-        map(&:helper_methods).
-        reduce([], :concat).
-        map(&:to_sym)
+        map(&:functions).
+        flatten.
+        to_h { |function| [function.name, function] }
     end
 
-    def filters
-      @filters ||= extensions.values.map(&:filters).reduce({}, :merge)
+    # @return [Hash{String => TwigTest}]
+    def tests
+      @tests ||= extensions.
+        values.
+        map(&:tests).
+        flatten.
+        to_h { |test| [test.name, test] }
     end
 
+    # @return [TwigFilter, nil]
     def filter(name)
-      filters[name.to_sym]
+      return filters[name] if filters.key?(name)
+
+      dynamic_filters.each do |pattern, filter|
+        if (match = Regexp.new(pattern).match(name))
+          return filter.with_dynamic_arguments(name, filter.name, match.captures)
+        end
+      end
+
+      nil
     end
 
+    # @return [TwigFunction, nil]
+    def function(name)
+      return functions[name] if functions.key?(name)
+
+      dynamic_functions.each do |pattern, function|
+        if (match = Regexp.new(pattern).match(name))
+          return function.with_dynamic_arguments(name, function.name, match.captures)
+        end
+      end
+
+      nil
+    end
+
+    # @return [TwigTest, nil]
+    def test(name)
+      return tests[name] if tests.key?(name)
+
+      dynamic_tests.each do |pattern, test|
+        if (match = Regexp.new(pattern).match(name))
+          return test.with_dynamic_arguments(name, test.name, match.captures)
+        end
+      end
+
+      nil
+    end
+
+    # @return [Array<TokenParser::Base>]
     def token_parsers
       @token_parsers ||= extensions.
         values.map(&:token_parsers).reduce([], :concat).
         to_h { |token_parser| [token_parser.tag.to_sym, token_parser] }
     end
 
-    # @return [TokenParser::Base|nil]
+    # @return [TokenParser::Base, nil]
     def token_parser(name)
       token_parsers[name.to_sym]
     end
+
+    # @return [Array<NodeVisitor::Base>]
+    def node_visitors
+      @node_visitors ||= extensions.
+        values.map(&:node_visitors).reduce([], :concat)
+    end
+
+    def globals
+      @globals ||= extensions.
+        values.map(&:globals).reduce({}, :merge)
+    end
+
+    private
+
+    def dynamic_filters
+      @dynamic_filters ||= filters.
+        select { |name, _| name.include?('*') }.
+        transform_keys { |name| dynamic_callable_regex(name) }
+    end
+
+    def dynamic_functions
+      @dynamic_functions ||= functions.
+        select { |name, _| name.include?('*') }.
+        transform_keys { |name| dynamic_callable_regex(name) }
+    end
+
+    def dynamic_tests
+      @dynamic_tests ||= tests.
+        select { |name, _| name.include?('*') }.
+        transform_keys { |name| dynamic_callable_regex(name) }
+    end
+
+    def dynamic_callable_regex(name)
+      "^#{Regexp.quote(name).gsub('\\*', '(.*?)')}$"
+    end
+
+    def key(object)
+      case object
+      when String
+        object
+      when Class
+        object.to_s
+      else
+        object.class.to_s
+      end
+    end
   end
 end

data/lib/twig/file_extension_escaping_strategy.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Twig
+  class FileExtensionEscapingStrategy
+    # Guesses the best autoescaping strategy based on the file name.
+    #
+    # @param [String] name The template name
+    # @return [Symbol, false] The escaping strategy name to use or false to disable
+    def self.guess(name)
+      # Return html for directories
+      if name.end_with?('/') || name.end_with?('\\')
+        return :html
+      end
+
+      # Remove .twig extension if present
+      if name.end_with?('.twig')
+        name = name[0...-5]
+      end
+
+      # Get file extension
+      extension = File.extname(name)[1..]
+
+      case extension
+      when 'js', 'json'
+        :js
+      when 'css'
+        :css
+      when 'txt'
+        false
+      else
+        :html
+      end
+    end
+  end
+end