twig_ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 674b4b6d23d8a81c8dfe49d8b4c55766df7a2b110038f7dd04bb5dbed09095eb
+  data.tar.gz: 41320e049677ff964e222b3e65eb2aefe5d8513387834bed644d17abefd6caac
+SHA512:
+  metadata.gz: a9d8b98237d0c9e1955efd5bf1abf41877159bf590960c223dde2ca6a5a9c09ba6c1ce15d64c7d9beb0a29aa7eef3aa81d1166e45f572308faa249f67d106b73
+  data.tar.gz: c30fdc12854565c6c733eecf77ae9fce7e3134d67ca1630642ee21b1c5473a6e4fd2296ac82cf95abbe880a9de946a814562ce4913a73bbe5754bbccb571db89

data/lib/twig/auto_hash.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Twig
+  class AutoHash < Hash
+    def add(*values)
+      values.each do |value|
+        self[length] = value
+      end
+
+      self
+    end
+
+    def <<(*values)
+      add(*values)
+    end
+  end
+end

data/lib/twig/cache/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Twig
+  module Cache
+    class Base
+      # @param [String] name
+      # @param [String] class_name
+      def generate_key(name, class_name)
+        raise NotImplementedError
+      end
+
+      # @param [String] key
+      # @param [String] content
+      def write(key, content)
+        raise NotImplementedError
+      end
+
+      # @param [String] key
+      # @return [Boolean]
+      def load(key)
+        raise NotImplementedError
+      end
+
+      # @param [String] key
+      # @return [Integer]
+      def timestamp(key)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/twig/cache/filesystem.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Twig
+  module Cache
+    class Filesystem < Cache::Base
+      def initialize(directory)
+        super()
+
+        @directory = directory
+      end
+
+      def generate_key(_name, class_name)
+        hash = ::Digest::SHA256.hexdigest(class_name)
+
+        File.join(directory, hash[0] + hash[1], "#{hash}.rb")
+      end
+
+      def load(key)
+        if File.file?(key)
+          Kernel.load(key)
+
+          true
+        else
+          false
+        end
+      end
+
+      def write(key, content)
+        dirname = File.dirname(key)
+
+        FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+        File.write(key, content)
+      end
+
+      def timestamp(key)
+        return 0 unless File.file?(key)
+
+        File.mtime(key).to_i
+      end
+
+      private
+
+      # @return [String]
+      attr_reader :directory
+    end
+  end
+end

data/lib/twig/cache/nil.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Twig
+  module Cache
+    class Nil < Cache::Base
+      def generate_key(_name, _class_name)
+        ''
+      end
+
+      def timestamp(_key)
+        0
+      end
+
+      def write(_key, _content); end
+      def load(_key); end
+      def remove(_key); end
+    end
+  end
+end

data/lib/twig/callable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Twig
+  class Callable
+    attr_reader :name, :dynamic_name, :callable
+
+    # @param [String] name
+    # @param [Proc|Nil] callable
+    # @param [Hash] options
+    def initialize(name, callable = nil, options = {})
+      @name = @dynamic_name = name
+      @callable = callable
+      @options = {
+        needs_environment: false,
+        needs_context: false,
+        needs_charset: false,
+        is_variadic: false,
+      }.merge(options)
+    end
+  end
+end

data/lib/twig/compiler.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Twig
+  # @!attribute [r] environment
+  #   @return [Environment]
+  class Compiler
+    attr_reader :source, :environment
+
+    # @param [Environment] environment
+    def initialize(environment)
+      @environment = environment
+      @var_name_salt = 0
+    end
+
+    # @param [Node::Base] node
+    # @param [Integer] indentation
+    # @return [Compiler]
+    def compile(node, indentation = 0)
+      reset(indentation)
+      node.compile(self)
+
+      self
+    end
+
+    # @param [Node::Base] node
+    # @param [Boolean] raw
+    # @return [Compiler]
+    def subcompile(node, raw: true)
+      indent_source unless raw
+
+      node.compile(self)
+
+      self
+    end
+
+    # @param [Array<String>] strings
+    # @return [Compiler]
+    def write(*strings)
+      strings.each do |string|
+        indent_source
+        @source << string
+      end
+
+      self
+    end
+
+    # @param [String] value
+    # @return [Compiler]
+    def string(value)
+      @source << "%q[#{value}]"
+
+      self
+    end
+
+    # @param [String] string
+    # @return [Compiler]
+    def raw(string)
+      @source << string
+
+      self
+    end
+
+    def repr(value)
+      case value
+      when Integer, Float
+        raw(value.to_s)
+      when TrueClass, FalseClass
+        raw(value ? 'true' : 'false')
+      when NilClass
+        raw('nil')
+      when Array, Hash
+        raw('Marshal.load(').
+          raw(Marshal.dump(value).inspect).
+          raw(')')
+      when Symbol
+        raw(":#{value}")
+      else
+        string(value)
+      end
+    end
+
+    # @param [Integer] step
+    # @return [Compiler]
+    def indent(step = 1)
+      @indentation += step
+
+      self
+    end
+
+    # @param [Integer] step
+    # @return [Compiler]
+    def outdent(step = 1)
+      @indentation -= step
+
+      self
+    end
+
+    # @return [String]
+    def var_name
+      "_v#{@var_name_salt}"
+    end
+
+    private
+
+    def indent_source
+      @source << ('  ' * @indentation)
+    end
+
+    # @return [Compiler]
+    def reset(indentation = 0)
+      @last_line = nil
+      @source = +''
+      @debug_info = []
+      @source_offset = 0
+      # source code starts at 1 (as we then increment it when we encounter new lines)
+      @source_line = 1
+      @indentation = indentation
+      @var_name_salt = 0
+
+      self
+    end
+  end
+end

data/lib/twig/context.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Twig
+  class Context < Hash
+    def initialize(initial_context = {})
+      super()
+
+      merge!(initial_context)
+    end
+
+    def merge!(other)
+      unless other.class <= Hash
+        raise 'Must merge! another Hash'
+      end
+
+      other.each do |k, v|
+        self[k] = v
+      end
+    end
+
+    def merge(other)
+      self.class.new(self).merge!(other)
+    end
+
+    def push_stack
+      stack.push({ remove: [], replace: {} })
+    end
+
+    def pop_stack
+      return unless stack.last
+
+      frame = stack.pop
+
+      frame[:remove].each do |k|
+        delete(k)
+      end
+      frame[:replace].each { |k, v| self[k] = v }
+    end
+
+    def [](key)
+      super(key.to_sym)
+    end
+
+    def []=(key, value)
+      key = key.to_sym
+
+      if (frame = stack.last)
+        if key?(key) && !frame[:replace].key?(key) && !frame[:remove].include?(key)
+          frame[:replace][key] = self[key]
+        else
+          frame[:remove].push(key)
+        end
+      end
+
+      super
+    end
+
+    private
+
+    def stack
+      @stack ||= []
+    end
+  end
+end

data/lib/twig/environment.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Twig
+  class Environment
+    # @return [Cache::Base]
+    attr_reader :cache
+
+    # @param [::Twig::Loader::Base] loader
+    def initialize(loader, options = {})
+      @loader = loader
+      @extension_set = ExtensionSet.new
+      @options = {
+        cache: false,
+        debug: false,
+        auto_reload: nil,
+      }.merge(options)
+
+      @auto_reload = options[:auto_reload].nil? ? options[:debug] : options[:auto_reload]
+
+      self.cache = @options[:cache]
+
+      add_extension(Extension::Core.new)
+    end
+
+    def template_class(name)
+      key = loader.get_cache_key(name)
+
+      "Compiled::Template_#{::Digest::SHA256.hexdigest(key)}"
+    end
+
+    # @return [Twig::Template]
+    def load_template(name, **)
+      class_name = template_class(name)
+      cache_key = cache.generate_key(name, class_name)
+
+      attempt_cache = !@auto_reload || template_fresh?(name, cache.timestamp(cache_key))
+
+      if attempt_cache
+        @cache.load(cache_key)
+      end
+
+      # Cache didn't load a class or we should load fresh
+      unless attempt_cache && Twig.const_defined?(class_name)
+        code = render_ruby(name)
+
+        # 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)
+      end
+
+      Twig.const_get(template_class(name)).
+        new(self, **)
+    end
+
+    def render(name)
+      loader.get_source_context(name).code
+    end
+
+    def render_ruby(name)
+      compile_source(
+        loader.get_source_context(name)
+      )
+    end
+
+    def extension(name)
+      @extension_set.extensions[name]
+    end
+
+    # @param [Extension::Base] extension
+    def add_extension(extension)
+      @extension_set.add(extension)
+    end
+
+    # @return [Array]
+    def operators
+      @extension_set.operators
+    end
+
+    # @return [TwigFilter]
+    def filter(name)
+      @extension_set.filter(name)
+    end
+
+    # @return [TokenParser::Base]
+    def token_parser(name)
+      @extension_set.token_parser(name)
+    end
+
+    # @return [Boolean]
+    def helper_method?(name)
+      @extension_set.helper_methods.include?(name)
+    end
+
+    # @param [Source] source
+    # @return [TokenStream]
+    def tokenize(source)
+      lexer.tokenize(source)
+    end
+
+    # @param [TokenStream] stream
+    def parse(stream)
+      parser.parse(stream)
+    end
+
+    # @param [Node::Base] node
+    def compile(node)
+      compiler.compile(node).source
+    end
+
+    # @param [Source] source
+    def compile_source(source)
+      compile(parse(tokenize(source)))
+    end
+
+    # @return [String]
+    def load_and_compile(name)
+      source = loader.get_source_context(name)
+      compile_source(source)
+    end
+
+    # @param [String] name
+    # @param [Integer] time
+    def template_fresh?(name, time)
+      # @todo check extension set last modified
+      loader.fresh?(name, time)
+    end
+
+    def cache=(cache)
+      @cache = if cache.is_a?(String)
+                 Cache::Filesystem.new(cache)
+               elsif cache == false
+                 Cache::Nil.new
+               elsif cache.class < Cache::Base
+                 cache
+               else
+                 raise "Cache must be string, false, or implement Twig::Cache::Base, got #{cache.inspect}"
+               end
+    end
+
+    private
+
+    # @return [Twig::Loader::Base]
+    attr_reader :loader
+
+    def lexer
+      @lexer ||= Lexer.new(self)
+    end
+
+    def parser
+      @parser ||= Parser.new(self)
+    end
+
+    def compiler
+      @compiler ||= Compiler.new(self)
+    end
+  end
+end

data/lib/twig/error/base.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Twig
+  module Error
+    class Base < StandardError
+      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
+
+        @lineno = lineno
+        @name = name
+        @raw_message = message
+      end
+
+      def to_s
+        parts = [@raw_message]
+        parts << [" in #{@name}"] if @name
+        parts << [":#{@lineno}"] if @name && @lineno
+        parts << [" on line #{@lineno}"] if !@name && @lineno
+
+        parts.join
+      end
+    end
+  end
+end

data/lib/twig/error/syntax.rb

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