twig_ruby 0.0.1

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class Array < Expression::Base
+        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)
+        end
+
+        def compile(compiler)
+          compiler.
+            raw('{').
+            indent
+
+          key_value_pairs.each do |key, value|
+            compiler.
+              subcompile(key).
+              raw(' => ').
+              subcompile(value).
+              raw(', ')
+          end
+
+          compiler.
+            outdent.
+            raw('}')
+        end
+
+        private
+
+        def key_value_pairs
+          nodes.each_value.each_slice(2)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'name'
+
+module Twig
+  module Node
+    module Expression
+      class AssignName < Expression::Name
+        # @param [String] name
+        # @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)
+          end
+
+          super
+        end
+
+        def compile(compiler)
+          compiler.
+            raw('context[').
+            string(attributes[:name]).
+            raw(']')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class Base < Node::Base
+        # @return [Expression::Base]
+        def set_explicit_parentheses
+          attributes[:with_parentheses] = true
+
+          self
+        end
+
+        def explicit_parentheses?
+          attributes.key?(:with_parentheses) && attributes[:with_parentheses]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class Base < Expression::Base
+          def initialize(left, right, lineno)
+            super({ left:, right: }, {}, lineno)
+          end
+
+          # @param [Compiler] compiler
+          def compile(compiler)
+            compiler.
+              raw('(').
+              subcompile(nodes[:left]).
+              raw(' ')
+
+            operator(compiler)
+
+            compiler.
+              raw(' ').
+              subcompile(nodes[:right]).
+              raw(')')
+          end
+
+          # @param [Compiler] compiler
+          def operator(compiler)
+            raise 'operator is not implemented'
+          end
+        end
+
+        OPERATORS = {
+          Equal: '==',
+          NotEqual: '!=',
+          Spaceship: '<=>',
+          Less: '<',
+          Greater: '>',
+          LessEqual: '<=',
+          GreaterEqual: '>=',
+
+          Or: '||',
+          Xor: '^',
+          And: '&&',
+          Add: '+',
+          Sub: '-',
+          Concat: '+',
+          Mul: '*',
+          Div: '/',
+        }.freeze
+
+        # Lots of simple operator classes can just be generated dynamically
+        OPERATORS.each do |name, operation|
+          const_set(name.to_s, Class.new(Binary::Base) do
+            def operator(compiler)
+              compiler.raw(self.class.const_get('OPERATOR'))
+            end
+          end).const_set('OPERATOR', operation)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class Call < Expression::Base
+        private
+
+        # @param [Compiler] compiler
+        def compile_callable(compiler)
+          callable = attributes[:twig_callable].callable
+
+          compiler.
+            raw("env.extension(%q[#{callable[0].class.name}]).#{callable[1]}")
+
+          compile_arguments(compiler)
+        end
+
+        def compile_arguments(compiler)
+          compiler.
+            raw('(').
+            subcompile(nodes[:node]).
+            raw(')')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class Constant < Expression::Base
+        def initialize(value, lineno)
+          super({}, { value: }, lineno)
+        end
+
+        def compile(compiler)
+          compiler.repr(attributes[:value])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class Filter < Call
+        # @param [Node::Base] node
+        # @param [TwigFilter|Constant] filter
+        def initialize(node, filter, arguments, lineno)
+          if filter.is_a?(TwigFilter)
+            name = filter.name
+            filter_name = Constant.new(name, lineno)
+          else
+            name = filter.attributes[:value]
+            filter_name = filter
+          end
+
+          super({
+            node:,
+            filter: filter_name,
+            arguments:,
+          }, {
+            name:,
+            type: 'filter',
+          }, lineno)
+
+          if filter.is_a?(Filter)
+            attributes[:twig_callable] = filter
+          end
+        end
+
+        def compile(compiler)
+          name = nodes[:filter].attributes[:value]
+
+          if name != attributes[:name]
+            raise 'Changing the value of a "filter" node is not supported'
+          end
+
+          if name == 'raw'
+            raise 'Cannot create raw filter via expression'
+          end
+
+          unless attributes.key?(:twig_callable)
+            attributes[:twig_callable] = compiler.environment.filter(name)
+          end
+
+          compile_callable(compiler)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class GetAttribute < Expression::Base
+        def initialize(node, attribute, arguments, type, lineno)
+          nodes = { node:, attribute: }
+          nodes[:arguments] = arguments if arguments
+
+          super(nodes, { type: }, lineno)
+        end
+
+        def compile(compiler)
+          var = compiler.var_name
+
+          compiler.
+            raw("(#{var} = ").
+            subcompile(nodes[:node]).
+            raw("\n").
+            write("::Twig::Extension::Core.get_attribute(#{var}, ").
+            subcompile(nodes[:attribute]).
+            raw(', ').
+            repr(attributes[:type]).
+            raw('))')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class HelperMethod < Expression::Base
+        def initialize(name, args, lineno)
+          super({ args: }, { name: }, lineno)
+        end
+
+        def compile(compiler)
+          compiler.
+            raw("@call_context.#{attributes[:name]}(")
+
+          nodes[:args].nodes.each do |key, value|
+            unless key.is_a?(Integer)
+              compiler.raw("#{key}: ")
+            end
+
+            compiler.
+              subcompile(value).
+              raw(',')
+          end
+
+          compiler.
+            raw(')')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class Name < Expression::Base
+        SPECIAL_VARS = {
+          '_self' => 'get_template_name',
+          '_context' => 'context',
+          '_charset' => 'env.charset',
+        }.freeze
+
+        # @param [String] name
+        # @param [Integer] lineno
+        def initialize(name, lineno)
+          super({}, {
+            name:,
+            is_defined_test: false,
+            ignore_strict_check: false,
+            alwways_defined: false,
+          }, lineno)
+        end
+
+        def compile(compiler)
+          name = attributes[:name]
+
+          compiler.
+            raw("(context.key?(:#{name})").
+            raw(" ? context[:#{name}]").
+            raw(' : raise("#{').
+            string(name).
+            raw('} does not exist"))')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class Ternary < Expression::Base
+        def initialize(test, left, right, lineno)
+          super({
+            test:,
+            left:,
+            right:,
+          }, {}, lineno)
+        end
+
+        def compile(compiler)
+          compiler.
+            raw('((').
+            subcompile(nodes[:test]).
+            raw(') ? (').
+            subcompile(nodes[:left]).
+            raw(') : (').
+            subcompile(nodes[:right]).
+            raw('))')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Unary
+        class Base < Expression::Base
+          # @param [Node::Base] node
+          # @param [Integer] lineno
+          def initialize(node, lineno)
+            super({ node: }, { with_parenthesis: false }, lineno)
+          end
+
+          def compile(compiler)
+            if explicit_parentheses?
+              compiler.raw('(')
+            else
+              compiler.raw(' ')
+            end
+
+            operator(compiler)
+            compiler.subcompile(nodes[:node])
+
+            if explicit_parentheses?
+              compiler.raw(')')
+            end
+          end
+
+          # @param [Compiler] compiler
+          def operator(compiler)
+            raise 'operator is not implemented'
+          end
+        end
+
+        OPERATORS = {
+          Not: '!',
+          Neg: '-',
+          Pos: '+',
+        }.freeze
+
+        # Lots of simple operator classes can just be generated dynamically
+        OPERATORS.each do |name, operation|
+          const_set(name.to_s, Class.new(Unary::Base) do
+            def operator(compiler)
+              compiler.raw(self.class.const_get('OPERATOR'))
+            end
+          end).const_set('OPERATOR', operation)
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/variable/assign_context.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Variable
+        class AssignContext < Expression::AssignName; end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/variable/context.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Variable
+        class Context < Expression::Name; end
+      end
+    end
+  end
+end

data/lib/twig/node/for.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class For < Node::Base
+      def initialize(key_target, value_target, seq, if_expr, body, else_expr, lineno)
+        loop = ForLoop.new(lineno)
+        body = Nodes.new(AutoHash.new.add(body, loop))
+
+        nodes = {
+          key_target:,
+          value_target:,
+          seq:,
+          body:,
+        }
+
+        unless else_expr.nil?
+          nodes[:else_expr] = else_expr
+        end
+
+        super(nodes, { with_loop: true }, lineno)
+      end
+
+      def compile(compiler)
+        compiler.
+          write("context.push_stack\n").
+          write('context[:_seq] = ::Twig::Extension::Core.ensure_hash(').
+          subcompile(nodes[:seq]).
+          raw(")\n")
+
+        # @todo Missing some more loops stuff here
+
+        if nodes.key?(:else_expr)
+          compiler.write("context[:_iterated] = false\n")
+        end
+
+        compiler.
+          write("context[:_seq].each do |k, v|\n").
+          indent.
+          write('').
+          subcompile(nodes[:key_target]).
+          raw(" = k\n").
+          write('').
+          subcompile(nodes[:value_target]).
+          raw(" = v\n\n").
+          subcompile(nodes[:body]).
+          outdent.
+          write("end\n")
+
+        if nodes.key?(:else_expr)
+          compiler.
+            write("unless context[:_iterated]\n").
+            indent.
+            subcompile(nodes[:else_expr]).
+            outdent.
+            write("end\n")
+        end
+
+        compiler.
+          write("context.pop_stack\n")
+      end
+    end
+  end
+end

data/lib/twig/node/for_loop.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class ForLoop < Node::Base
+      def initialize(lineno)
+        super({}, { with_loop: false, if_expr: false, else_expr: false }, lineno)
+      end
+
+      def compile(compiler)
+        if attributes.key?(:else_expr)
+          compiler.write("context[:_iterated] = true\n")
+        end
+
+        # @todo if with loop
+        compiler.
+          write("context[:loop] = {\n").
+          write("  index0: 0,\n").
+          write("  index: 1,\n").
+          write("  first: true,\n").
+          write("}\n")
+
+        if attributes.key?(:with_loop)
+          compiler.
+            write("context[:loop][:index0] += 1\n").
+            write("context[:loop][:index] += 1\n").
+            write("context[:loop][:first] = false\n").
+            write("if context[:loop].key?(:revindex0) && context[:loop].key?(:revindex)\n").
+            indent.
+            write("context[:loop][:revindex0] -= 1\n").
+            write("context[:loop][:revindex] -= 1\n").
+            write("context[:loop][:last] = (context[:loop][:revindex0] == 0)\n").
+            outdent.
+            write("end\n")
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/if.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class If < Node::Base
+      def initialize(tests, else_node, lineno)
+        nodes = { tests: }
+        nodes[:else] = else_node if else_node
+
+        super(nodes, {}, lineno)
+      end
+
+      def compile(compiler)
+        (0...nodes[:tests].nodes.length).step(2).each do |i|
+          if i.zero?
+            compiler.
+              raw("\n").
+              write('if (')
+          else
+            compiler.
+              outdent.
+              write('elsif (')
+          end
+
+          compiler.
+            subcompile(nodes[:tests].nodes[i]).
+            raw(")\n").
+            indent
+
+          if nodes[:tests].nodes.key?(i + 1)
+            compiler.
+              subcompile(nodes[:tests].nodes[i + 1])
+          end
+        end
+
+        if nodes.key?(:else)
+          compiler.
+            outdent.
+            write("else\n").
+            indent.
+            subcompile(nodes[:else])
+        end
+
+        compiler.
+          outdent.
+          write("end\n\n")
+      end
+    end
+  end
+end

data/lib/twig/node/include.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class Include < Node::Base
+      # @param [Expression::Base] expr
+      # @param [Expression::Base, nil] variables
+      # @param [Boolean] only
+      # @param [Boolean] ignore_missing
+      # @param [Integer] lineno
+      def initialize(expr, variables, only, ignore_missing, lineno)
+        nodes = { expr: }
+        nodes[:variables] = variables if variables
+
+        super(nodes, {
+          only:,
+          ignore_missing:,
+        }, lineno)
+      end
+
+      def compile(compiler)
+        if attributes[:ignore_missing]
+          # @todo
+          raise 'not implemented yet'
+        else
+          compiler.
+            write('')
+
+          add_get_template(compiler)
+
+          compiler.
+            raw('.render(')
+
+          add_template_arguments(compiler)
+
+          compiler.
+            raw(");\n")
+        end
+      end
+
+      private
+
+      # @param [Compiler] compiler
+      def add_get_template(compiler)
+        compiler.
+          raw('load_template(').
+          subcompile(nodes[:expr]).
+          raw(', ').
+          repr(template_name).
+          raw(', ').
+          repr(lineno).
+          raw(')')
+      end
+
+      # @param [Compiler] compiler
+      def add_template_arguments(compiler)
+        if !nodes.key?(:variables)
+          compiler.raw(attributes[:only] == false ? 'context' : '{}')
+        elsif attributes[:only] == false
+          compiler.
+            raw('context.merge(').
+            subcompile(nodes[:variables]).
+            raw(')')
+        else
+          compiler.
+            subcompile(nodes[:variables])
+        end
+      end
+    end
+  end
+end