twig_ruby 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 674b4b6d23d8a81c8dfe49d8b4c55766df7a2b110038f7dd04bb5dbed09095eb
-  data.tar.gz: 41320e049677ff964e222b3e65eb2aefe5d8513387834bed644d17abefd6caac
+  metadata.gz: de30e1d0f458a7c5e2683f725036d8cf37e0fd09238bf14b7921d17af9f08998
+  data.tar.gz: bfdc53936b6dc8449c44269e5bb0b717c01e02597911266404550a805cbb34b8
 SHA512:
-  metadata.gz: a9d8b98237d0c9e1955efd5bf1abf41877159bf590960c223dde2ca6a5a9c09ba6c1ce15d64c7d9beb0a29aa7eef3aa81d1166e45f572308faa249f67d106b73
-  data.tar.gz: c30fdc12854565c6c733eecf77ae9fce7e3134d67ca1630642ee21b1c5473a6e4fd2296ac82cf95abbe880a9de946a814562ce4913a73bbe5754bbccb571db89
+  metadata.gz: 6554b109c0e00241e6a5dac0dfd4f8c36e78b50dcc45edff041ff9907cf02609d2abd4b5cdc326ca1ee92b12217ed83a8ba420c60afc65f790bb34567fbc9af9
+  data.tar.gz: 70bf08c22925adf25f6b469bc7afcad62bdd3b4ed45761dbca3cd4619b1a213dcf2a3d70c1595ae7958354b2527fde438b78763c72238281971dc35c2aeaba71

data/README.md

@@ -0,0 +1,116 @@
+# twig-ruby
+
+Implementation of [Twig](https://twig.symfony.com/) in Ruby.
+
+```bash
+bundle add twig-ruby
+```
+
+## Rails
+
+This gem includes a Railtie that will automatically add your views folder and
+register a `:twig` template handler. Just simply create your views such as
+`app/views/welcome/index.html.twig` and it will start rendering them.
+
+```twig
+{# welcome/index.html.twig #}
+
+{% extends 'base.html.twig' %}
+
+{% block body %}
+  Welcome to my site!
+{% endblock %}
+```
+
+You should add `layout false` in your `ApplicationController`
+
+```ruby
+class ApplicationController < ActionController::Base
+  layout false
+end
+```
+
+## Rails Configuration
+
+These are all the defaults. You only need this configuration if you plan to change anything. 
+
+```ruby
+Rails.application.configure do
+  config.twig.root = ::Rails.root, # Used for default Filesystem Loader
+  config.twig.paths = %w[/ app/views/], # Used for default Filesystem Loader
+  config.twig.debug = ::Rails.env.development?,
+  config.twig.allow_helper_methods = true,
+  config.twig.cache = ::Rails.root.join('tmp/cache/twig').to_s,
+  config.twig.charset = 'UTF-8',
+  config.twig.strict_variables = true,
+  config.twig.auto_reload = nil,
+  config.twig.loader = lambda do
+    ::Twig::Loader::Filesystem.new(
+      current.root,
+      current.paths
+    )
+  end
+end
+```
+
+The loader is memoized as late as possible, so if you need to actually access the loader instance, you can
+use `Twig.loader` to create the instance. If you do this, you can no longer set a new loader with the config
+or paths. You would need to use any available methods on the loader to alter it:
+
+```ruby
+config.after_initialize do
+  Twig.loader.prepend_path('app/views/theme', 'theme')
+end
+```
+
+If you plan to create your own loader that loads templates from another source like the database, you can provide
+a different lamba in the config for initializing it. 
+
+## Additions
+
+Twig Ruby supports symbols as Ruby does and can be used in places strings can as 
+hash keys, arguments, etc.
+
+```twig
+{{ name[:first] }}
+{{ user_func(:first, :second) }}
+{% set hash = { key: :value } %}
+```
+
+Since Ruby has the concept of blocks, a new tag is introduced call `yield` it
+can be used with helpers like `form_with`
+
+```twig
+{% yield form_with(url: 'login') do |f| %}
+  {{ f.email_field(:email) }}
+{% endyield %}
+```
+### Cache Tag
+
+The way the `cache` tag works in Rails is that it captures output from the buffer that 
+sends the contents of the response. Twig cannot do this prematurely since a cache might be used within
+a block or other callable meant to return the string. There is a cache tag to handle this instead 
+that is passed the same arguments it normally would, but has extra code to capture the cache. 
+Using `{% yield cache() do %}` WILL NOT WORK CORRECTLY.
+
+```twig
+{% cache(product) %}
+  ...
+{% endyield %}
+```
+
+Macros can also use Ruby notation for default values:
+
+Typical Twig:
+```twig
+{% macro input(name, value, type = "text", size = 20) %}
+  <input type="{{ type }}" name="{{ name }}" value="{{ value|e }}" size="{{ size }}"/>
+{% endmacro %}
+```
+
+Twig Ruby (Both versions work)
+```twig
+{% macro input(name, value, type: "text", size: 20) %}
+  <input type="{{ type }}" name="{{ name }}" value="{{ value|e }}" size="{{ size }}"/>
+{% endmacro %}
+```

data/lib/tasks/twig_parity.rake

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+desc 'Tests against Twig PHP fixtures.'
+
+GIT_LOCATION = "#{__dir__}/../../tmp/twig-php".freeze
+WONT_IMPLEMENT = %w[
+  tags/macro/super_globals.test
+  tags/for/non_countable.test
+  tags/for/generator.test
+  tags/for/objects.test
+  tags/for/iterator_aggregate.test
+  tags/for/objects_countable.test
+  expressions/matches_error_compilation.test
+  expressions/matches_error_runtime.test
+  functions/enum/invalid_dynamic_enum.test
+  functions/enum/invalid_enum.test
+  functions/enum/invalid_literal_type.test
+  functions/enum/valid.test
+  functions/enum_cases/invalid_dynamic_enum.test
+  functions/enum_cases/invalid_enum.test
+  functions/enum_cases/invalid_literal_type.test
+  functions/enum_cases/valid.test
+  functions/attribute.legacy.test
+  functions/attribute_with_wrong_args.legacy.test
+  functions/constant.test
+  functions/dump.test
+  functions/dump_array.test
+  tests/defined_for_attribute.legacy.test
+  filters/date_default_format_interval.test
+  filters/date_interval.test
+  filters/date_immutable.test
+  filters/date_modify.test
+  operators/not_precedence.test
+  operators/concat_vs_add_sub.test
+  functions/include/sandbox_disabling.test
+  functions/include/sandbox.test
+].freeze
+
+class Color
+  def self.colorize(text, color_code)
+    "\e[#{color_code}m#{text}\e[0m"
+  end
+
+  def self.red(text)
+    colorize(text, 31)
+  end
+
+  def self.green(text)
+    colorize(text, 32)
+  end
+end
+
+task :twig_parity, [:file] do |_t, args|
+  require 'rspec/support'
+  require_relative '../twig_ruby'
+  require_relative '../../test/parity'
+
+  `git clone -b 4.x https://github.com/twigphp/Twig.git #{GIT_LOCATION}`
+
+  stats = { pass: 0, fail: 0, total: 0 }
+
+  fixtures = if args[:file]
+               [File.join(GIT_LOCATION, 'tests/Fixtures/', args[:file])]
+             else
+               Dir.glob("#{GIT_LOCATION}/tests/Fixtures/**/*.test")
+             end
+
+  fixtures.each do |fixture|
+    base_name = fixture.delete_prefix("#{GIT_LOCATION}/tests/Fixtures/")
+
+    next if WONT_IMPLEMENT.include?(base_name)
+
+    TwigFixture.new(fixture, base_name).call.each do |data|
+      stats[:total] += 1
+
+      if data[:status]
+        stats[:pass] += 1
+      else
+        stats[:fail] += 1
+        puts '============================='
+        puts "FAIL: #{data[:file].delete_prefix("#{GIT_LOCATION}/tests/Fixtures/")}"
+        puts data[:error]
+        puts "Link: #{data[:file]}:#{data[:lineno]}"
+        puts "Rerun: rake twig_parity[#{base_name}]"
+        puts "=============================\n\n"
+      end
+    end
+  end
+
+  puts <<~STATS
+
+    Stats:
+      #{Color.green("#{stats[:pass]} passed")}
+      #{Color.red("#{stats[:fail]} failed")}
+      correct: #{(stats[:pass] * 100 / stats[:total]).round(2)}%
+  STATS
+
+  if stats[:fail].positive?
+    exit 1
+  else
+    exit 0
+  end
+end
+
+class TwigFixture
+  EXCEPTION_REGEX = /
+    --TEST--\s*(.*?)\s*
+    (?:--CONDITION--\s*(.*))?\s*
+    (?:--DEPRECATION--\s*(.*?))?\s*
+    ((?:--TEMPLATE(?:\(.*?\))?--(?:.*?))+)\s*
+    (?:--DATA--\s*(.*))?\s*
+    --EXCEPTION--\s*(.*)
+  /mx
+
+  EXPECT_REGEX = /
+    --TEST--\s*(.*?)\s*
+    (?:--CONDITION--\s*(.*))?\s*
+    (?:--DEPRECATION--\s*(.*?))?\s*
+    ((?:--TEMPLATE(?:\(.*?\))?--(?:.*?))+)
+    --DATA--.*?
+    --EXPECT--.*
+  /mx
+
+  OUTPUTS_REGEX = /
+    --DATA--(.*?)(?:--CONFIG--(.*?))?--EXPECT--(.*?)(?=--DATA--|\z)
+  /mx
+
+  def initialize(file, base_name)
+    @file = file
+    @base_name = base_name
+  end
+
+  def call
+    parse
+
+    require_relative "#{__dir__}/../../test/fixtures/#{@base_name}.rb"
+    examples = Data.examples
+
+    examples.each.with_index.map do |example, i|
+      build_and_run(example[:data], example[:config], example[:gsub] || {}, outputs[i][2], i)
+    end
+  end
+
+  private
+
+  attr_accessor :message, :condition, :deprecation, :templates, :exception, :outputs
+
+  def build_and_run(data, config, replacements, expected, index)
+    gsub_templates = templates.transform_values do |template|
+      replace(template, replacements[:fixture]) + (' ' * index)
+    end
+
+    loader = ::Twig::Loader::Array.new(gsub_templates)
+    environment = ::Twig::Environment.new(loader, {
+      cache: false,
+      strict_variables: true,
+      auto_reload: true,
+      **config,
+    })
+    environment.add_global('global', 'global')
+    environment.add_extension(::TwigTestExtension.new)
+    environment.add_extension(::Twig::Extension::Debug.new)
+    environment.add_extension(::Twig::Extension::StringLoader.new)
+    environment.add_runtime_loader(::Twig::Parity::Runtime::Loader.new(environment))
+    expected ||= ''
+
+    # Reset timezone
+    ::Time.zone = 'UTC'
+
+    # Pass current environment if test is lazy
+    data = data.call(environment) if data.is_a?(Proc)
+
+    begin
+      output = environment.load('index.twig').render(data).gsub(/\A[\n ]*/, '').gsub(/[\n ]*\z/, '')
+      output = replace(output, replacements[:output])
+      expected = expected.gsub(/\A[\n ]*/, '').gsub(/[\n ]*\z/, '')
+      expected = replace(expected, replacements[:result])
+
+      if output == expected
+        {
+          message:,
+          file: @file,
+          status: true,
+          output:,
+        }
+      else
+        {
+          message:,
+          file: @file,
+          status: false,
+          error: ::RSpec::Support::Differ.new.diff_as_string(output, expected),
+        }
+      end
+    rescue ::Twig::Error::Base => e
+      if exception
+        message_only = exception.match(/Twig\\Error\\\w+: (.*)/)&.captures&.[](0)
+        message_only = replace(message_only, replacements[:exception]) if message_only
+        exception_matches = message_only == e.message
+        error = ::RSpec::Support::Differ.new.diff_as_string(e.message, message_only)
+        # error = "#{Color.red("- #{message_only}")}\n#{Color.green("+ #{e.message}")}"
+      else
+        error = Color.red(e.message)
+      end
+
+      {
+        message:,
+        file: @file,
+        status: exception_matches,
+        lineno: e.lineno,
+        error:,
+      }
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      {
+        message:,
+        file: @file,
+        status: exception_matches,
+        lineno: -1,
+        error: "Full Error: #{e.message}",
+      }
+    end
+  end
+
+  def replace(string, replacements)
+    return string if replacements.nil?
+
+    replacements.each do |find, replace|
+      string = string.gsub(find, replace)
+    end
+
+    string
+  end
+
+  def contents
+    @contents ||= File.read(@file)
+  end
+
+  def parse
+    if (matches = contents.match(EXCEPTION_REGEX))
+      self.message = matches.captures[0]
+      self.condition = matches.captures[1]
+      self.deprecation = matches.captures[2]
+      self.templates = parse_templates(matches.captures[3])
+      self.exception = matches.captures[5]
+      self.outputs = [[nil, matches.captures[4], nil, '']]
+    elsif (matches = contents.match(EXPECT_REGEX))
+      self.message = matches.captures[0]
+      self.condition = matches.captures[1]
+      self.deprecation = matches.captures[2]
+      self.templates = parse_templates(matches.captures[3])
+      self.exception = false
+      self.outputs = contents.scan(OUTPUTS_REGEX)
+    end
+  end
+
+  def parse_templates(test)
+    templates = {}
+    test.scan(/--TEMPLATE(?:\((.*?)\))?--(.*?)(?=--TEMPLATE|\z)/mx).map do |name, contents|
+      templates[name || 'index.twig'] = contents.
+        gsub(/[\n]*\z/, '').
+        gsub('d/m/Y H:i:s P', '%d/%m/%Y %H:%M:%S %:z'). # Change dates to Ruby format
+        gsub('Twig\Tests\TwigTestFoo', 'TwigTestFoo') # Change class name to match Ruby
+    end
+
+    templates
+  end
+
+  def parse_return_value(object)
+    if object.is_a?(Array) && object.length == 1
+      return parse_return_value(object.first)
+    end
+
+    if object.is_a?(Hash)
+      return object.transform_values { |v| parse_return_value(v) }
+    end
+
+    object
+  end
+end

data/lib/twig/auto_hash.rb

@@ -4,7 +4,7 @@ module Twig
   class AutoHash < Hash
     def add(*values)
       values.each do |value|
-        self[length] = value
+        self[next_key] = value
       end
 
       self
@@ -13,5 +13,11 @@ module Twig
     def <<(*values)
       add(*values)
     end
+
+    private
+
+    def next_key
+      (keys.filter { |key| key.is_a?(Integer) }.max || -1) + 1
+    end
   end
 end

data/lib/twig/callable.rb

@@ -2,13 +2,15 @@
 
 module Twig
   class Callable
-    attr_reader :name, :dynamic_name, :callable
+    attr_reader :callable
+    attr_accessor :name, :dynamic_name, :arguments
 
     # @param [String] name
     # @param [Proc|Nil] callable
     # @param [Hash] options
     def initialize(name, callable = nil, options = {})
       @name = @dynamic_name = name
+      @arguments = []
       @callable = callable
       @options = {
         needs_environment: false,
@@ -17,5 +19,30 @@ module Twig
         is_variadic: false,
       }.merge(options)
     end
+
+    def type
+      raise NotImplementedError
+    end
+
+    def needs_charset?
+      @options[:needs_charset]
+    end
+
+    def needs_environment?
+      @options[:needs_environment]
+    end
+
+    def needs_context?
+      @options[:needs_context]
+    end
+
+    def with_dynamic_arguments(name, dynamic_name, arguments)
+      new = clone
+      new.name = name
+      new.dynamic_name = dynamic_name
+      new.arguments = arguments
+
+      new
+    end
   end
 end

data/lib/twig/compiler.rb

@@ -6,6 +6,9 @@ module Twig
   class Compiler
     attr_reader :source, :environment
 
+    # @return [Hash<Integer, Integer>]
+    attr_reader :debug_info
+
     # @param [Environment] environment
     def initialize(environment)
       @environment = environment
@@ -47,7 +50,19 @@ module Twig
     # @param [String] value
     # @return [Compiler]
     def string(value)
-      @source << "%q[#{value}]"
+      @source << "%q[#{value.to_s.gsub(/[\[\]\\]/, '[' => '\[', ']' => '\]', '\\' => '\\\\')}]"
+
+      self
+    end
+
+    # @param [String, Symbol] value
+    # @return [Compiler]
+    def symbol(value)
+      @source << if value.is_a?(Symbol)
+                   value.inspect
+                 else
+                   "%q[#{value}].to_sym"
+                 end
 
       self
     end
@@ -73,12 +88,28 @@ module Twig
           raw(Marshal.dump(value).inspect).
           raw(')')
       when Symbol
-        raw(":#{value}")
+        symbol(value)
       else
         string(value)
       end
     end
 
+    # @param [Node::Base] node
+    # @return [Compiler]
+    def add_debug_info(node)
+      if node.lineno != @last_line
+        write("# line #{node.lineno}\n")
+
+        @source_line += @source[@source_offset..].count("\n")
+        @source_offset = @source.length
+        @debug_info[@source_line] = node.lineno
+
+        @last_line = node.lineno
+      end
+
+      self
+    end
+
     # @param [Integer] step
     # @return [Compiler]
     def indent(step = 1)
@@ -97,6 +128,7 @@ module Twig
 
     # @return [String]
     def var_name
+      @var_name_salt += 1
       "_v#{@var_name_salt}"
     end
 
@@ -110,7 +142,7 @@ module Twig
     def reset(indentation = 0)
       @last_line = nil
       @source = +''
-      @debug_info = []
+      @debug_info = {}
       @source_offset = 0
       # source code starts at 1 (as we then increment it when we encounter new lines)
       @source_line = 1