twig_ruby 0.0.1 → 0.0.2

data/lib/twig/loader/filesystem.rb

@@ -3,19 +3,71 @@
 module Twig
   module Loader
     class Filesystem < Loader::Base
+      MAIN_NAMESPACE = '__main__'
+
       def initialize(root_path, paths = [])
         super()
 
         @root_path = root_path.to_s
-        @paths = paths.map(&:to_s)
+        @paths = {}
+        @cache = {}
+        @error_cache = {}
+
+        set_paths(paths)
+      end
+
+      def exists?(name)
+        return true if @cache.key?(name)
+
+        !find_template(name, throw: false).nil?
+      end
+
+      def paths(namespace = MAIN_NAMESPACE)
+        @paths[namespace] || []
+      end
+
+      def set_paths(paths, namespace = MAIN_NAMESPACE)
+        paths = [paths] unless paths.is_a?(::Array)
+
+        @paths[namespace] = []
+
+        paths.each do |path|
+          add_path(path, namespace)
+        end
+      end
+
+      def add_path(path, namespace = MAIN_NAMESPACE)
+        @cache = {}
+        @error_cache = {}
+        check_path = path[0] == '/' ? path : File.join(@root_path, path)
+
+        unless File.directory?(check_path)
+          raise Error::Loader, "The \"#{path}\" directory does not exist (#{check_path})."
+        end
+
+        @paths[namespace] ||= []
+        @paths[namespace] << path
+      end
+
+      def prepend_path(path, namespace = MAIN_NAMESPACE)
+        @cache = {}
+        @error_cache = {}
+        check_path = path[0] == '/' ? path : File.join(@root_path, path)
+
+        unless File.directory?(check_path)
+          raise Error::Loader, "The \"#{path}\" directory does not exist (#{check_path})."
+        end
+
+        @paths[namespace] ||= []
+        @paths[namespace].unshift(path)
       end
 
       def get_source_context(name)
         if (file = find_template(name))
-          return Source.new(File.read(file), name)
+          return Source.new(File.read(file), name, file)
         end
 
-        raise "Unable to find '#{name}'"
+        raise Error::Loader, "Unable to find template \"#{name}\" (looked into: #{@paths.inspect})."
       end
 
       def get_cache_key(name)
@@ -34,11 +86,58 @@ module Twig
 
       private
 
-      def find_template(name)
-        @paths.each do |path|
-          absolute = File.join(@root_path, path, name)
-          return absolute if File.file?(absolute)
+      def find_template(name, throw: true)
+        return @cache[name] if @cache.key?(name)
+
+        begin
+          namespace, shortname = parse_name(name)
+        rescue Error::Loader => e
+          return nil unless throw
+          raise e if throw
+        end
+
+        unless @paths.key?(namespace)
+          @error_cache[name] = "There are no registered paths for namespace \"#{namespace}\"."
+
+          unless throw
+            return nil
+          end
+
+          raise Error::Loader, @error_cache[name]
+        end
+
+        paths(namespace).each do |path|
+          absolute = File.join(path, shortname)
+
+          unless path[0] == '/'
+            absolute = File.join(@root_path, absolute)
+          end
+
+          if File.file?(absolute)
+            return @cache[name] = absolute
+          end
+        end
+
+        @error_cache[name] = "Unable to find template \"#{name}\" (looked into: #{@paths.inspect})."
+
+        unless throw
+          return nil
+        end
+
+        raise Error::Loader, @error_cache[name]
+      end
+
+      def parse_name(name)
+        if name[0] == '@'
+          if (pos = name.index('/')).nil?
+            raise Error::Loader, "Malformed namespaced template name \"#{name}\" " \
+                                 '(expecting "@namespace/template_name").'
+          end
+
+          return [name[1...pos], name[(pos + 1)..]]
         end
+
+        [MAIN_NAMESPACE, name]
       end
     end
   end

data/lib/twig/node/auto_escape.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class AutoEscape < Node::Base
+      # @param [String, FalseClass] value
+      # @param [Node::Base] body
+      # @param [Integer] lineno
+      def initialize(value, body, lineno)
+        super({ body: }, { value: }, lineno)
+      end
+
+      def compile(compiler)
+        compiler.subcompile(nodes[:body])
+      end
+    end
+  end
+end

data/lib/twig/node/base.rb

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 
+require_relative 'output'
+
 module Twig
   module Node
     class Base
-      attr_reader :tag, :lineno
+      attr_reader :tag
+
+      # @return [Integer]
+      attr_reader :lineno
 
       # @return [Hash]
       attr_reader :attributes
@@ -11,7 +16,7 @@ module Twig
       # @return [Source]
       attr_reader :source_context
 
-      # @return [AutoHash<Node::Base>]
+      # @return [AutoHash{[Symbol, Integer] => Node::Base}]
       attr_reader :nodes
 
       # @param [Hash<Node::Base>] nodes
@@ -56,6 +61,57 @@ module Twig
       def template_name
         source_context.name
       end
+
+      # @return [Integer]
+      def length
+        nodes.length
+      end
+
+      def empty?
+        nodes.empty?
+      end
+
+      def to_s
+        repr = +''
+        repr << self.class.name
+
+        if @tag
+          repr << "\n tag: #{@tag}"
+        end
+
+        attr = attributes.map do |name, value|
+          v = if value.is_a?(Proc) || value.is_a?(Method)
+                '\Closure'
+              elsif value.is_a?(String)
+                value
+              else
+                value.inspect
+              end
+
+          "#{name}: #{v}"
+        end
+
+        unless attr.empty?
+          repr << "\n  attributes:\n    #{attr.join("\n    ")}"
+        end
+
+        unless empty?
+          repr << "\n  nodes:"
+
+          nodes.each do |name, node|
+            len = name.to_s.length + 6
+            node_repr = []
+
+            node.to_s.each_line do |line|
+              node_repr << ((' ' * len) + line.rstrip)
+            end
+
+            repr << "\n    #{name}: #{node_repr.join("\n").lstrip}"
+          end
+        end
+
+        repr
+      end
     end
   end
 end

data/lib/twig/node/block.rb

@@ -9,8 +9,10 @@ module Twig
 
       def compile(compiler)
         compiler.
+          add_debug_info(self).
           write("def block_#{attributes[:name]}(context, blocks)\n").
           indent.
+          write("macros = @macros.dup\n").
           subcompile(nodes[:body]).
           outdent.
           write("end\n\n")

data/lib/twig/node/block_reference.rb

@@ -3,13 +3,17 @@
 module Twig
   module Node
     class BlockReference < Node::Base
+      include Output
+
       def initialize(name, lineno)
         super({}, { name: }, lineno)
       end
 
       def compile(compiler)
         compiler.
-          write("yield_block(:#{attributes[:name]}, context, block_list.merge(blocks));").
+          add_debug_info(self).
+          write('context.output_buffer.safe_append = ').
+          raw("render_block(:#{attributes[:name]}, context, blocks)").
           raw("\n")
       end
     end

data/lib/twig/node/body.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class Body < Base; end
+  end
+end

data/lib/twig/node/cache.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class Cache < Node::Base
+      def initialize(arguments, body, lineno)
+        super({ arguments:, body: }, {}, lineno)
+      end
+
+      def compile(compiler)
+        compiler.
+          add_debug_info(self).
+          # Cache method just writes strings onto the buffer, it doesn't return the fragment
+          # so we can capture any output to the main buffer and output that instead
+          write("context.output_buffer.safe_append = context.call_context.capture do\n").
+          indent.
+          write('context.call_context.cache(')
+
+        first = true
+        nodes[:arguments].nodes.each_value do |argument|
+          compiler.raw(', ') unless first
+          first = false
+
+          compiler.subcompile(argument)
+        end
+
+        compiler.
+          raw(") do\n").
+          indent.
+          # inside a capture block the original buffer is capturing so it's OK if we push strings there
+          write("context.original_buffer.safe_append = context.buffer_and_return do\n").
+          indent
+
+        compiler.
+          write("context.push_stack\n").
+          subcompile(nodes[:body]).
+          raw("\n").
+          write("context.pop_stack\n")
+
+        compiler.
+          write("end.to_s\n").
+          outdent.
+          write("end\n").
+          outdent.
+          write("end\n").
+          outdent
+      end
+    end
+  end
+end

data/lib/twig/node/capture.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class Capture < Node::Base
+      # @param [Node::Base] body
+      # @param [Integer] lineno
+      def initialize(body, lineno)
+        super({ body: }, { raw: false }, lineno)
+      end
+
+      def compile(compiler)
+        compiler.
+          raw("context.buffer_and_return do\n").
+          indent.
+          subcompile(nodes[:body]).
+          outdent.
+          write("end.to_s.html_safe\n")
+      end
+    end
+  end
+end

data/lib/twig/node/deprecated.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class Deprecated < Base
+      def initialize(expr, lineno)
+        super({ expr: }, {}, lineno)
+      end
+
+      def compile(compiler)
+        compiler.add_debug_info(self)
+
+        expr = nodes[:expr]
+
+        unless expr.is_a?(Expression::Constant)
+          var_name = compiler.var_name
+          compiler.
+            write("#{var_name} = ").
+            subcompile(expr).
+            raw("\n")
+        end
+
+        compiler.write('::Twig::Extension::Core.deprecation_notice(')
+
+        if expr.is_a?(Expression::Constant)
+          compiler.subcompile(expr)
+        else
+          compiler.write(var_name)
+        end
+
+        compiler.
+          raw(', ').
+          repr(template_name).
+          raw(', ').
+          repr(lineno)
+
+        if (package = nodes.fetch(:package, nil))
+          compiler.
+            raw(', package: ').
+            subcompile(package)
+        end
+
+        if (version = nodes.fetch(:version, nil))
+          compiler.
+            raw(', version: ').
+            subcompile(version)
+        end
+
+        compiler.raw(")\n")
+      end
+    end
+  end
+end

data/lib/twig/node/do.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class Do < Node::Base
+      # @param [Node::Expression::Base] expr
+      # @param [Integer] lineno
+      def initialize(expr, lineno)
+        super({ expr: }, {}, lineno)
+      end
+
+      def compile(compiler)
+        compiler.
+          subcompile(nodes[:expr], raw: false).
+          raw("\n")
+      end
+    end
+  end
+end

data/lib/twig/node/embed.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'include'
+
+module Twig
+  module Node
+    class Embed < Include
+      # we don't inject the module to avoid node visitors to traverse it twice (as it will
+      # be already visited in the main module)
+      def initialize(name, index, variables, only, ignore_missing, lineno)
+        super(
+          Expression::Constant.new('not_used', lineno),
+          variables,
+          only,
+          ignore_missing,
+          lineno
+        )
+
+        attributes[:name] = name
+        attributes[:index] = index
+      end
+
+      private
+
+      def add_get_template(compiler, template = '')
+        compiler.
+          raw('load(').
+          string(attributes[:name]).
+          raw(', ').
+          repr(lineno).
+          raw(', ').
+          string(attributes[:index]).
+          raw(')')
+
+        if attributes[:ignore_missing]
+          compiler.
+            raw("\n").
+            write("#{template}.get_parent(context)\n")
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/array.rb

@@ -1,48 +1,57 @@
 # frozen_string_literal: true
 
+require_relative 'support_defined_test'
+
 module Twig
   module Node
     module Expression
       class Array < Expression::Base
+        include Expression::SupportDefinedTest
+
+        # @param [AutoHash] elements
+        # @param [Integer] lineno
         def initialize(elements, lineno)
           super(elements, {}, lineno)
-
-          @index = -1
         end
 
         # @param [Expression::Base] value
-        # @param [Expression::Base|nil] key
-        def add_element(value, key = nil)
-          if key.nil?
-            @index += 1
-            key = Constant.new(@index, value.lineno)
-          end
-
-          nodes.add(key, value)
+        def add_element(value)
+          nodes.add(value)
         end
 
         def compile(compiler)
+          if define_test_enabled?
+            return compiler.repr(true)
+          end
+
           compiler.
-            raw('{').
+            raw('[').
             indent
 
-          key_value_pairs.each do |key, value|
+          first = true
+
+          values.each do |value|
+            unless first
+              compiler.raw(', ')
+            end
+
+            first = false
+
             compiler.
-              subcompile(key).
-              raw(' => ').
-              subcompile(value).
-              raw(', ')
+              subcompile(value)
           end
 
           compiler.
             outdent.
-            raw('}')
+            raw(']')
         end
 
-        private
+        def values
+          nodes.values
+        end
 
-        def key_value_pairs
-          nodes.each_value.each_slice(2)
+        def each_value(&)
+          values.each(&)
         end
       end
     end

data/lib/twig/node/expression/arrow_function.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class ArrowFunction < Expression::Base
+        # @param [Expression::Base] expr
+        # @param [Node::Nodes] names
+        # @param [Integer] lineno
+        def initialize(expr, names, lineno)
+          if !names.is_a?(Expression::Array) && !names.is_a?(Expression::Variable::Context)
+            raise Error::Syntax.new(
+              'The arrow function argument must be a list of variables or a single variable.',
+              names.lineno,
+              names.source_context
+            )
+          end
+
+          if names.is_a?(Expression::Variable::Context)
+            names = Expression::Array.new(AutoHash.new.add(
+              Expression::Variable::AssignContext.new(names.attributes[:name], names.lineno)
+            ), names.lineno)
+          end
+
+          super({ expr:, names: }, {}, lineno)
+        end
+
+        def compile(compiler)
+          compiler.
+            add_debug_info(self).
+            raw('-> (')
+
+          first = true
+          nodes[:names].each_value do |name|
+            compiler.raw(', ') unless first
+            compiler.raw("__#{name.attributes[:name]}__")
+            first = false
+          end
+
+          compiler.raw(') { ')
+
+          nodes[:names].nodes.each_value do |name|
+            compiler.
+              raw("context[:#{name.attributes[:name]}] = ").
+              raw("__#{name.attributes[:name]}__; ")
+          end
+
+          compiler.
+            subcompile(nodes[:expr]).
+            raw('}')
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/assign_name.rb

@@ -10,7 +10,7 @@ module Twig
         # @param [Integer] lineno
         def initialize(name, lineno)
           if %w[true false none null nil].include?(name.downcase)
-            raise Error::Syntax.new("You cannot assign a value to #{name}", lineno)
+            raise Error::Syntax.new("You cannot assign a value to \"#{name}\".", lineno, source_context)
           end
 
           super

data/lib/twig/node/expression/binary/and.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'boolean'
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class And < Boolean
+          def operator(compiler)
+            compiler.raw('&&')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/binary/base.rb

@@ -31,6 +31,9 @@ module Twig
         end
 
         OPERATORS = {
+          BitwiseOr: '|',
+          BitwiseXor: '^',
+          BitwiseAnd: '&',
           Equal: '==',
           NotEqual: '!=',
           Spaceship: '<=>',
@@ -39,14 +42,13 @@ module Twig
           LessEqual: '<=',
           GreaterEqual: '>=',
 
-          Or: '||',
-          Xor: '^',
-          And: '&&',
+          Range: '..',
           Add: '+',
           Sub: '-',
-          Concat: '+',
           Mul: '*',
           Div: '/',
+          Mod: '%',
+          Power: '**',
         }.freeze
 
         # Lots of simple operator classes can just be generated dynamically

data/lib/twig/node/expression/binary/boolean.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class Boolean < Binary::Base
+          def compile(compiler)
+            compiler.
+              raw('(::Twig::Extension::Core.bool(').
+              subcompile(nodes[:left]).
+              raw(') ')
+
+            operator(compiler)
+
+            compiler.raw(' ::Twig::Extension::Core.bool(').
+              subcompile(nodes[:right]).
+              raw('))')
+          end
+        end
+      end
+    end
+  end
+end