twig_ruby 0.0.1 → 0.0.3

data/lib/twig/environment.rb

@@ -3,7 +3,10 @@
 module Twig
   class Environment
     # @return [Cache::Base]
-    attr_reader :cache
+    attr_reader :cache, :charset
+
+    # @return [Twig::Loader::Base]
+    attr_reader :loader
 
     # @param [::Twig::Loader::Base] loader
     def initialize(loader, options = {})
@@ -12,87 +15,210 @@ module Twig
       @options = {
         cache: false,
         debug: false,
+        charset: 'UTF-8',
+        strict_variables: false,
+        autoescape: :html,
         auto_reload: nil,
+        allow_helper_methods: false,
       }.merge(options)
 
-      @auto_reload = options[:auto_reload].nil? ? options[:debug] : options[:auto_reload]
+      @auto_reload = @options[:auto_reload].nil? ? @options[:debug] : @options[:auto_reload]
+      @charset = @options[:charset]
+      @strict_variables = @options[:strict_variables]
 
       self.cache = @options[:cache]
 
+      @loaded_templates = {}
+      @globals = {}
+      @runtimes = {}
+      @runtime_loaders = []
+      @default_runtime_loader = RuntimeLoader::Factory.new({
+        Runtime::Escaper => -> { Runtime::Escaper.new(@charset) },
+      })
+
       add_extension(Extension::Core.new)
+      add_extension(Extension::Escaper.new(@options[:autoescape]))
     end
 
-    def template_class(name)
+    def template_class(name, index = nil)
       key = loader.get_cache_key(name)
 
-      "Compiled::Template_#{::Digest::SHA256.hexdigest(key)}"
+      "Compiled::Template_#{::Digest::SHA256.hexdigest(key)}#{"___#{index}" if index}"
+    end
+
+    # @param [String, Twig::TemplateWrapper] name
+    # @return [Twig::TemplateWrapper]
+    def load(name)
+      if name.is_a?(Twig::TemplateWrapper)
+        return name
+      end
+
+      cls = template_class(name)
+      TemplateWrapper.new(
+        self,
+        load_template(cls, name)
+      )
+    end
+
+    # @param [String, Twig::TemplateWrapper, Array<String>] name
+    def resolve_template(names)
+      unless names.is_a?(Array)
+        return load(names)
+      end
+
+      count = names.length
+
+      names.each do |name|
+        if name.is_a?(Twig::TemplateWrapper)
+          return name
+        end
+
+        unless count == 1 || loader.exists?(name)
+          next
+        end
+
+        return load(name)
+      end
+
+      raise Error::Loader, "Unable to find one of the following templates: \"#{names.join('", "')}\"."
     end
 
+    # @param [String] cls The class name to load
+    # @param [String] name The template name
+    # @param [Integer, nil] index Index for embedded templates
     # @return [Twig::Template]
-    def load_template(name, **)
-      class_name = template_class(name)
-      cache_key = cache.generate_key(name, class_name)
+    def load_template(cls, name, index: nil)
+      main_cls = cls
 
-      attempt_cache = !@auto_reload || template_fresh?(name, cache.timestamp(cache_key))
+      if index
+        cls += "___#{index}"
+      end
 
-      if attempt_cache
-        @cache.load(cache_key)
+      if !index.nil? && Twig.const_defined?(cls)
+        return @loaded_templates[cls] = Twig.const_get(cls).new(self)
       end
 
-      # Cache didn't load a class or we should load fresh
-      unless attempt_cache && Twig.const_defined?(class_name)
-        code = render_ruby(name)
+      cache_key = cache.generate_key(name, main_cls)
+
+      # If not auto_reloading just use whatever is in the cache
+      if !@auto_reload || template_fresh?(name, cache.timestamp(cache_key))
+        if @loaded_templates.key?(cls)
+          return @loaded_templates[cls]
+        end
 
-        # File cache loader won't rely on eval
-        @cache.write(cache_key, code)
         @cache.load(cache_key)
 
-        # Finally just eval the generated code if cache does
-        # create the class
-        Twig.module_eval(code) unless Twig.const_defined?(class_name)
+        if Twig.const_defined?(cls)
+          return @loaded_templates[cls] = Twig.const_get(cls).new(self)
+        end
       end
 
-      Twig.const_get(template_class(name)).
-        new(self, **)
-    end
+      # No caches have fresh template at this point, so write it now
+      code = render_ruby(name)
 
-    def render(name)
-      loader.get_source_context(name).code
+      # File cache loader won't rely on eval
+      @cache.write(cache_key, code)
+      @cache.load(cache_key)
+
+      # Finally just eval the generated code if cache doesn't
+      # create the class
+      Twig.module_eval(code) unless Twig.const_defined?(cls)
+
+      @loaded_templates[cls] = Twig.const_get(cls).new(self)
     end
 
-    def render_ruby(name)
-      compile_source(
-        loader.get_source_context(name)
-      )
+    # @return [Twig::Template]
+    def create_template(template, name = nil)
+      hash = ::Digest::SHA256.hexdigest(template)
+      name = if name.nil?
+               "__string_template__#{hash}"
+             else
+               "#{name} (string template #{hash})"
+             end
+
+      chain_loader = Loader::Chain.new([
+        Loader::Array.new({ name => template }),
+        current = loader,
+      ])
+
+      @loader = chain_loader
+
+      cls = template_class(name)
+      TemplateWrapper.new(self, load_template(cls, name))
+    ensure
+      @loader = current
     end
 
     def extension(name)
-      @extension_set.extensions[name]
+      extension_set.get(name)
+    end
+
+    def extension?(name)
+      extension_set.has?(name)
     end
 
     # @param [Extension::Base] extension
     def add_extension(extension)
-      @extension_set.add(extension)
+      extension_set.add(extension)
     end
 
-    # @return [Array]
-    def operators
-      @extension_set.operators
+    def runtime(klass)
+      return runtimes[klass] if runtimes.key?(klass)
+
+      runtime_loaders.each do |loader|
+        if (runtime = loader.load(klass))
+          return runtimes[klass] = runtime
+        end
+      end
+
+      if (runtime = default_runtime_loader.load(klass))
+        return runtimes[klass] = runtime
+      end
+
+      raise Error::Runtime, "Unable to load the \"#{klass}\" runtime."
     end
 
-    # @return [TwigFilter]
+    # @param [RuntimeLoader::Base] loader
+    def add_runtime_loader(loader)
+      runtime_loaders << loader
+    end
+
+    # @return [ExpressionParser::ExpressionParsers]
+    def expression_parsers
+      extension_set.expression_parsers
+    end
+
+    # @return [TwigFilter, nil]
     def filter(name)
-      @extension_set.filter(name)
+      extension_set.filter(name)
+    end
+
+    # @return [TwigFunction, nil]
+    def function(name)
+      extension_set.function(name)
     end
 
-    # @return [TokenParser::Base]
+    # @return [TwigTest, nil]
+    def test(name)
+      extension_set.test(name)
+    end
+
+    # @return [TokenParser::Base, nil]
     def token_parser(name)
-      @extension_set.token_parser(name)
+      extension_set.token_parser(name)
     end
 
-    # @return [Boolean]
-    def helper_method?(name)
-      @extension_set.helper_methods.include?(name)
+    # @return [Array<NodeVisitor::Base>]
+    def node_visitors
+      extension_set.node_visitors
+    end
+
+    def add_global(name, value)
+      @globals[name] = value
+    end
+
+    def globals
+      @resolved_globals ||= extension_set.globals.merge(@globals)
     end
 
     # @param [Source] source
@@ -114,6 +240,9 @@ module Twig
     # @param [Source] source
     def compile_source(source)
       compile(parse(tokenize(source)))
+    rescue Error::Base => e
+      e.source_context = source
+      raise e
     end
 
     # @return [String]
@@ -141,10 +270,38 @@ module Twig
                end
     end
 
+    # @return [Boolean]
+    def allow_helper_methods?
+      @options[:allow_helper_methods]
+    end
+
+    def debug?
+      @options[:debug]
+    end
+
+    def strict_variables?
+      @strict_variables
+    end
+
     private
 
-    # @return [Twig::Loader::Base]
-    attr_reader :loader
+    # @return [ExtensionSet]
+    attr_reader :extension_set
+
+    # @return [RuntimeLoader::Base]
+    attr_reader :default_runtime_loader
+
+    # @return [Array<RuntimeLoader::Base>]
+    attr_reader :runtime_loaders
+
+    # @return [Hash{String => Object}]
+    attr_reader :runtimes
+
+    def render_ruby(name)
+      compile_source(
+        loader.get_source_context(name)
+      )
+    end
 
     def lexer
       @lexer ||= Lexer.new(self)

data/lib/twig/error/base.rb

@@ -3,34 +3,99 @@
 module Twig
   module Error
     class Base < StandardError
+      # @return [Integer]
       attr_reader :lineno
 
       # @param [String] message
       # @param [Integer] lineno
       # @param [Source] source
-      def initialize(message, lineno = -1, source = nil)
-        super(message)
-
-        if source
-          name = source.name
-          @source_code = source.code
-          @source_path = source.path
-        else
-          name = nil
-        end
+      def initialize(message, lineno = -1, source = nil, previous = nil)
+        super('')
 
         @lineno = lineno
-        @name = name
+        @source = source
         @raw_message = message
+        @previous = previous
+
+        update_repr
+      end
+
+      # @return [Source, nil]
+      def source_context
+        @source
+      end
+
+      # @param [Source, nil] source
+      def source_context=(source)
+        @source = source
+        update_repr
       end
 
       def to_s
-        parts = [@raw_message]
-        parts << [" in #{@name}"] if @name
-        parts << [":#{@lineno}"] if @name && @lineno
-        parts << [" on line #{@lineno}"] if !@name && @lineno
+        @message
+      end
+
+      def lineno=(lineno)
+        @lineno = lineno
+        update_repr
+      end
+
+      def append_message(raw_message)
+        @raw_message += raw_message
+        update_repr
+      end
+
+      def guess
+        locations = [self, @previous].compact.map(&:backtrace_locations).flatten
+        locations.each do |location|
+          next if location.nil?
+          next unless location.label&.start_with?('Twig::Compiled::')
+
+          klass, _method = location.label.split('#')
+          klass = Twig::Compiled.const_get(klass)
+
+          next unless source.name == klass.source_context.name
+
+          klass.debug_info.each do |source_line, template_line|
+            next unless source_line <= location.lineno
 
-        parts.join
+            self.lineno = template_line
+            update_repr
+            return # rubocop:disable Lint/NonLocalExitFromIterator
+          end
+        end
+      end
+
+      private
+
+      # @return [Source, nil]
+      attr_reader :source
+
+      def update_repr
+        if !source.nil? && source.path
+          # only update file and line together
+          @file = source.path
+          @line = lineno.positive? ? lineno : -1
+        end
+
+        @message = @raw_message.dup
+        last = @message[-1]
+
+        if (punctuation = %w[. ?].include?(last) ? last : '')
+          @message = @message[0...-1]
+        end
+
+        if !source.nil? && source.name
+          @message += " in \"#{source.name}\""
+        end
+
+        if lineno.positive?
+          @message += " at line #{lineno}"
+        end
+
+        unless punctuation.empty?
+          @message += punctuation
+        end
       end
     end
   end

data/lib/twig/error/loader.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Twig
+  module Error
+    class Loader < Error::Base
+    end
+  end
+end

data/lib/twig/error/logic.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Twig
+  module Error
+    class Logic < Error::Base
+    end
+  end
+end

data/lib/twig/error/runtime.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Twig
+  module Error
+    class Runtime < Error::Base
+    end
+  end
+end

data/lib/twig/expression_parser/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'infix/parses_arguments'
+
+module Twig
+  module ExpressionParser
+    class Base
+      def to_s
+        "Some kinda EP: #{name}"
+      end
+
+      def name
+        raise NotImplementedError
+      end
+
+      def precedence
+        raise NotImplementedError
+      end
+
+      # @return [Symbol]
+      def type
+        raise NotImplementedError
+      end
+
+      def aliases
+        []
+      end
+    end
+  end
+end

data/lib/twig/expression_parser/expression_parsers.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Twig
+  module ExpressionParser
+    class ExpressionParsers
+      # @param [Array<Twig::ExpressionParser::Base>] parsers
+      def initialize(parsers = [])
+        @parsers_by_name = {}
+        @parsers_by_class = {}
+
+        add(parsers)
+      end
+
+      # @param [Array<Twig::ExpressionParser::Base>] parsers
+      def add(parsers)
+        parsers.each do |parser|
+          if parser.precedence > 512 || parser.precedence.negative?
+            raise(
+              ArgumentError,
+              "Precedence for \"#{parser.name}\" must be between 0 and 512, got #{parser.precedence}."
+            )
+          end
+
+          parsers_by_name[parser.type] ||= {}
+          parsers_by_name[parser.type][parser.name] = parser
+          parsers_by_class[parser.class.name] = parser
+
+          parser.aliases.each do |alias_name|
+            parsers_by_name[parser.type][alias_name] = parser
+          end
+        end
+      end
+
+      def each(&)
+        parsers_by_name.values.map(&:values).flatten.each(&)
+      end
+
+      # @return [ExpressionParser::Base, nil]
+      def by_class(klass)
+        parsers_by_class[klass]
+      end
+
+      # @return [ExpressionParser::Base, nil]
+      def by_name(type, name)
+        parsers_by_name[type][name]
+      end
+
+      private
+
+      # @return [Hash<Array<Twig::ExpressionParser::Base>>]]
+      attr_reader :parsers_by_name
+
+      # @return [Hash<Twig::ExpressionParser::Base>]
+      attr_reader :parsers_by_class
+    end
+  end
+end

data/lib/twig/expression_parser/infix/arrow.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Twig
+  module ExpressionParser
+    module Infix
+      class Arrow < InfixExpressionParser
+        def parse(parser, left, token)
+          # As the expression of the arrow function is independent from the current precedence,
+          # we want a precedence of 0
+          Node::Expression::ArrowFunction.new(parser.parse_expression, left, token.lineno)
+        end
+
+        def name
+          '=>'
+        end
+
+        def description
+          'Arrow function (x => expr)'
+        end
+
+        def precedence
+          250
+        end
+
+        def associativity
+          LEFT
+        end
+      end
+    end
+  end
+end

data/lib/twig/expression_parser/infix/binary.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Twig
+  module ExpressionParser
+    module Infix
+      class Binary < InfixExpressionParser
+        attr_reader :associativity, :precedence, :aliases, :name
+
+        def initialize(node_class, name, precedence, associativity = LEFT, description: nil, aliases: [])
+          super()
+
+          @node_class = node_class
+          @name = name
+          @precedence = precedence
+          @associativity = associativity
+          @description = description
+          @aliases = aliases
+        end
+
+        def parse(parser, left, token)
+          right = parser.parse_expression(
+            left? ? precedence + 1 : precedence
+          )
+
+          @node_class.new(left, right, token.lineno)
+        end
+
+        def description
+          @description || ''
+        end
+      end
+    end
+  end
+end

data/lib/twig/expression_parser/infix/conditional_ternary.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Twig
+  module ExpressionParser
+    module Infix
+      class ConditionalTernary < InfixExpressionParser
+        def parse(parser, left, token)
+          then_expr = parser.parse_expression(precedence)
+
+          else_expr = if parser.stream.next_if(Token::PUNCTUATION_TYPE, ':')
+                        # Ternary operator (expr ? expr2 : expr3)
+                        parser.parse_expression(precedence)
+                      else
+                        # Ternary without else (expr ? expr2)
+                        Node::Expression::Constant.new('', token.lineno)
+                      end
+
+          Node::Expression::Ternary.new(left, then_expr, else_expr, token.lineno)
+        end
+
+        def name
+          '?'
+        end
+
+        def description
+          'Conditional operator (a ? b : c)'
+        end
+
+        def precedence
+          0
+        end
+
+        def associativity
+          LEFT
+        end
+      end
+    end
+  end
+end