bade 0.2.4 → 0.3.1

data/lib/bade/parser/parser_tag.rb

@@ -6,12 +6,12 @@ module Bade
 
   class Parser
     module TagRegexps
-      BLOCK_EXPANSION = /\A:\s+/
+      BLOCK_EXPANSION = /\A:\s+/.freeze
       OUTPUT_CODE = LineIndicatorRegexps::OUTPUT_BLOCK
-      TEXT_START = /\A /
+      TEXT_START = /\A /.freeze
 
-      PARAMS_ARGS_DELIMITER = /\A\s*,/
-      PARAMS_END = /\A\s*\)/
+      PARAMS_ARGS_DELIMITER = /\A\s*,/.freeze
+      PARAMS_END = /\A\s*\)/.freeze
     end
 
     # @param [String] tag  tag name

data/lib/bade/parser/parser_text.rb

@@ -6,8 +6,8 @@ module Bade
 
   class Parser
     module TextRegexps
-      INTERPOLATION_START = /(\\)?(&|#)\{/
-      INTERPOLATION_END = /\A\}/
+      INTERPOLATION_START = /(\\)?(&|#)\{/.freeze
+      INTERPOLATION_END = /\A\}/.freeze
     end
 
     def parse_text
@@ -64,7 +64,7 @@ module Bade
 
           next_line
 
-          @line.remove_indent!(text_indent ? text_indent : indent, @tabsize)
+          @line.remove_indent!(text_indent || indent, @tabsize)
 
           parse_text
 

data/lib/bade/parser.rb

@@ -17,6 +17,8 @@ module Bade
       attr_reader :error, :file, :line, :lineno, :column
 
       def initialize(error, file, line, lineno, column)
+        super(error)
+
         @error = error
         @file = file || '(__TEMPLATE__)'
         @line = line.to_s
@@ -60,7 +62,7 @@ module Bade
       @file_path = file_path
 
       @tab_re = /\G((?: {#{tabsize}})*) {0,#{tabsize - 1}}\t/
-      @tab = '\1' + ' ' * tabsize
+      @tab = "\1#{' ' * tabsize}"
 
       reset
     end
@@ -106,7 +108,7 @@ module Bade
       @stacks << @stacks.last.dup while indent >= @stacks.length
 
       parent = @stacks[indent].last
-      node = AST::NodeRegistrator.create(type, @lineno)
+      node = AST::NodeRegistrator.create(type, parent, lineno: @lineno, filename: @file_path)
       parent.children << node
 
       node.value = value unless value.nil?
@@ -126,7 +128,9 @@ module Bade
 
     def parse_import
       # TODO: change this to something better
-      path = eval(@line) # rubocop:disable Lint/Eval
+      # rubocop:disable Security/Eval
+      path = eval(@line)
+      # rubocop:enable Security/Eval
       append_node(:import, value: path)
 
       @dependency_paths << path unless @dependency_paths.include?(path)

data/lib/bade/precompiled.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require 'yaml'
-
+require 'psych'
 
 module Bade
   class Precompiled
@@ -26,7 +25,11 @@ module Bade
                file
              end
 
-      hash = YAML.load(file)
+      hash = if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.0')
+               Psych.safe_load(file, filename: file.path, permitted_classes: [Symbol])
+             else
+               Psych.safe_load(file, [Symbol])
+             end
       raise LoadError, 'YAML file is not in valid format' unless hash.is_a?(Hash)
 
       file_path = hash[:source_file_path]

data/lib/bade/renderer.rb

@@ -9,7 +9,7 @@ require_relative 'precompiled'
 
 module Bade
   class Renderer
-    class LoadError < ::RuntimeError
+    class LoadError < Bade::Runtime::RuntimeError
       # @return [String]
       #
       attr_reader :loading_path
@@ -22,18 +22,29 @@ module Bade
       # @param [String] reference_path  reference file from which is load performed
       # @param [String] msg  standard message
       #
-      def initialize(loading_path, reference_path, msg = nil)
-        super(msg)
+      def initialize(loading_path, reference_path, msg, template_backtrace = [])
+        super(msg, template_backtrace)
         @loading_path = loading_path
         @reference_path = reference_path
       end
     end
 
-    def initialize
-      @optimize = false
+    class << self
+      def _globals_tracker
+        @globals_tracker ||= Bade::Runtime::GlobalsTracker.new
+      end
+
+      # When set to true it will remove all constants that template created. Off by default.
+      #
+      # @return [Boolean]
+      attr_accessor :clear_constants
     end
 
-    TEMPLATE_FILE_NAME = '(__template__)'.freeze
+    # @param clear_constants [Boolean] When set to true it will remove all constants that template created. Off by default.
+    def initialize(clear_constants: Bade::Renderer.clear_constants)
+      @optimize = false
+      @clear_constants = clear_constants
+    end
 
     # @return [String]
     #
@@ -59,6 +70,10 @@ module Bade
     #
     attr_accessor :optimize
 
+    # @return [Boolean] When set to true it will remove all constants that template created. Off by default.
+    #
+    attr_accessor :clear_constants
+
 
     # ----------------------------------------------------------------------------- #
     # Internal attributes
@@ -77,8 +92,8 @@ module Bade
     #
     # @return [Renderer] preconfigured instance of this class
     #
-    def self.from_source(source, file_path = nil)
-      inst = new
+    def self.from_source(source, file_path = nil, clear_constants: Bade::Renderer.clear_constants)
+      inst = new(clear_constants: clear_constants)
       inst.source_text = source
       inst.file_path = file_path
       inst
@@ -88,14 +103,14 @@ module Bade
     #
     # @return [Renderer] preconfigured instance of this class
     #
-    def self.from_file(file)
+    def self.from_file(file, clear_constants: Bade::Renderer.clear_constants)
       path = if file.is_a?(File)
                file.path
              else
                file
              end
 
-      from_source(nil, path)
+      from_source(nil, path, clear_constants: clear_constants)
     end
 
     # Method to create Renderer from Precompiled object, for example when you want to reuse precompiled object from disk
@@ -104,8 +119,8 @@ module Bade
     #
     # @return [Renderer] preconfigured instance of this class
     #
-    def self.from_precompiled(precompiled)
-      inst = new
+    def self.from_precompiled(precompiled, clear_constants: Bade::Renderer.clear_constants)
+      inst = new(clear_constants: clear_constants)
       inst.precompiled = precompiled
       inst
     end
@@ -125,11 +140,20 @@ module Bade
       self
     end
 
+    # @return [self]
     def with_binding(binding)
       self.lambda_binding = binding
       self
     end
 
+    # @param [RenderBinding] binding
+    # @return [self]
+    def with_render_binding(binding)
+      self.lambda_binding = nil
+      self.render_binding = binding
+      self
+    end
+
     def optimized
       self.optimize = true
       self
@@ -164,17 +188,21 @@ module Bade
 
     # @return [RenderBinding]
     #
+    # rubocop:disable Lint/DuplicateMethods
     def render_binding
       @render_binding ||= Runtime::RenderBinding.new(locals || {})
     end
+    # rubocop:enable Lint/DuplicateMethods
 
     # @return [Proc]
     #
     def lambda_instance
-      if lambda_binding
-        lambda_binding.eval(lambda_string, file_path || TEMPLATE_FILE_NAME)
-      else
-        render_binding.instance_eval(lambda_string, file_path || TEMPLATE_FILE_NAME)
+      _catching_globals do
+        if lambda_binding
+          lambda_binding.eval(lambda_string, file_path || Bade::Runtime::TEMPLATE_FILE_NAME)
+        else
+          render_binding.instance_eval(lambda_string, file_path || Bade::Runtime::TEMPLATE_FILE_NAME)
+        end
       end
     end
 
@@ -195,13 +223,22 @@ module Bade
         Generator::NEW_LINE_NAME.to_sym => new_line,
         Generator::BASE_INDENT_NAME.to_sym => indent,
       }
-      run_vars.reject! { |_key, value| value.nil? } # remove nil values
+      run_vars.compact! # remove nil values
 
-      lambda_instance.call(**run_vars)
+      begin
+        return _catching_globals do
+          lambda_instance.call(**run_vars)
+        end
+      rescue Bade::Runtime::RuntimeError => e
+        raise e
+      rescue Exception => e
+        msg = "Exception raised during execution of template: #{e}"
+        raise Bade::Runtime::RuntimeError.wrap_existing_error(msg, e, render_binding.__location_stack)
+      ensure
+        self.class._globals_tracker.clear_constants if @clear_constants
+      end
     end
 
-
-
     private
 
     # @param [String] content  source code of the template
@@ -249,6 +286,7 @@ module Bade
 
       if File.exist?(sub_path)
         return if sub_path.end_with?('.rb') # handled in Generator
+
         sub_path
       else
         bade_path = "#{sub_path}.bade"
@@ -272,5 +310,16 @@ module Bade
         end
       end
     end
+
+    def _catching_globals(&block)
+      if @clear_constants
+        self.class._globals_tracker.catch(&block)
+      else
+        block.call
+      end
+    end
   end
 end
+
+# Set default value to clear_constants
+Bade::Renderer.clear_constants = false

data/lib/bade/ruby2_keywords.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+def ruby2_keywords(*) end if RUBY_VERSION < '2.7'

data/lib/bade/ruby_extensions/string.rb

@@ -13,12 +13,10 @@ class String
     %('#{self}')
   end
 
-
   def blank?
     strip.empty?
   end
 
-
   def remove_last(count = 1)
     slice(0, length - count)
   end
@@ -27,7 +25,6 @@ class String
     slice!(length - count, count)
   end
 
-
   def remove_first(count = 1)
     slice(count, length - count)
   end
@@ -67,7 +64,6 @@ class String
     remove_first(__chars_count_for_indent(indent, tabsize))
   end
 
-
   # Remove indent
   #
   # @param [Int] indent
@@ -77,7 +73,6 @@ class String
     remove_first!(__chars_count_for_indent(indent, tabsize))
   end
 
-
   # Calculate indent for line
   #
   # @param [Int] tabsize
@@ -88,9 +83,10 @@ class String
     count = 0
 
     each_char do |char|
-      if char == SPACE_CHAR
+      case char
+      when SPACE_CHAR
         count += 1
-      elsif char == TAB_CHAR
+      when TAB_CHAR
         count += tabsize
       else
         break
@@ -105,7 +101,7 @@ class String
   #
   def strip_heredoc
     min_val = scan(/^[ \t]*(?=\S)/).min
-    indent = (min_val && min_val.size) || 0
+    indent = min_val&.size || 0
     gsub(/^[ \t]{#{indent}}/, '')
   end
 end

data/lib/bade/runtime/block.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
+require_relative '../ruby2_keywords'
+
 module Bade
   module Runtime
-    class RuntimeError < ::StandardError; end
-
     class Block
       class MissingBlockDefinitionError < RuntimeError
         # @return [String]
@@ -14,8 +14,8 @@ module Bade
         #
         attr_accessor :context
 
-        def initialize(name, context, msg = nil)
-          super()
+        def initialize(name, context, msg, template_backtrace)
+          super(msg, template_backtrace)
 
           self.name = name
           self.context = context
@@ -36,34 +36,51 @@ module Bade
       #
       attr_reader :name
 
+      # @return [RenderBinding::Location, nil]
+      #
+      attr_reader :location
+
       # @return [RenderBinding]
       #
       attr_reader :render_binding
 
       # @param [String] name  name of the block
+      # @param [RenderBinding::Location, nil] location
       # @param [RenderBinding] render_binding  reference to current binding instance
       # @param [Proc] block  reference to lambda
       #
-      def initialize(name, render_binding, &block)
+      def initialize(name, location, render_binding, &block)
         @name = name
+        @location = location
         @render_binding = render_binding
         @block = block
       end
 
       # --- Calling methods
 
-      def call(*args)
+      # Calls the block and adds rendered content into current buffer stack.
+      #
+      # @return [Void]
+      ruby2_keywords def call(*args)
         call!(*args) unless @block.nil?
       end
 
-      def call!(*args)
-        raise MissingBlockDefinitionError.new(name, :call) if @block.nil?
+      # Calls the block and adds rendered content into current buffer stack.
+      #
+      # @return [Void]
+      ruby2_keywords def call!(*args)
+        raise MissingBlockDefinitionError.new(name, :call, nil, render_binding.__location_stack) if @block.nil?
 
-        render_binding.__buff.concat(@block.call(*args))
+        __call(*args)
       end
 
       # --- Rendering methods
 
+      # Calls the block and returns rendered content in string.
+      #
+      # Returns empty string when there is no block.
+      #
+      # @return [String]
       def render(*args)
         if @block.nil?
           ''
@@ -72,10 +89,33 @@ module Bade
         end
       end
 
+      # Calls the block and returns rendered content in string.
+      #
+      # Throws error when there is no block.
+      #
+      # @return [String]
       def render!(*args)
-        raise MissingBlockDefinitionError.new(name, :render) if @block.nil?
+        raise MissingBlockDefinitionError.new(name, :render, nil, render_binding.__location_stack) if @block.nil?
+
+        loc = location.dup
+        render_binding.__buffs_push(loc)
+
+        @block.call(*args)
+
+        render_binding.__buffs_pop&.join || ''
+      end
+
+      # Calls the block and adds rendered content into current buffer stack.
+      #
+      # @return [Void]
+      ruby2_keywords def __call(*args)
+        loc = location.dup
+        render_binding.__buffs_push(loc)
+
+        @block.call(*args)
 
-        @block.call(*args).join
+        res = render_binding.__buffs_pop
+        render_binding.__buff&.concat(res) if !res.nil? && !res.empty?
       end
     end
   end

data/lib/bade/runtime/globals_tracker.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative 'utils/where'
+
+module Bade
+  module Runtime
+    # Tracks created global variables and constants in block.
+    class GlobalsTracker
+      # @return [Array<Symbol>]
+      attr_accessor :caught_variables
+
+      # @return [Array<[Object, :Symbol]>]
+      attr_accessor :caught_constants
+
+      # @return [Array<String>, nil]
+      attr_accessor :constants_location_prefixes
+
+      # @param [Array<String>, nil] constants_location_prefixes If given, only constants whose location starts with one
+      #                                                         of the prefixes will be removed. If nil, all constants
+      #                                                         will be removed.
+      def initialize(constants_location_prefixes: nil)
+        @caught_variables = []
+        @caught_constants = []
+        @constants_location_prefixes = constants_location_prefixes
+      end
+
+      # @yieldreturn [T]
+      # @return [T]
+      def catch
+        before_variables = global_variables
+        before_global_constants = Object.constants
+        before_binding_constants = Bade::Runtime::RenderBinding.constants(false)
+
+        res = nil
+        begin
+          res = yield
+        ensure
+          @caught_variables += global_variables - before_variables
+
+          @caught_constants += (Object.constants - before_global_constants)
+                               .map { |name| [Object, name] }
+          @caught_constants += (Bade::Runtime::RenderBinding.constants(false) - before_binding_constants)
+                               .map { |name| [Bade::Runtime::RenderBinding, name] }
+        end
+
+        res
+      end
+
+      def clear_all
+        clear_global_variables
+        clear_constants
+      end
+
+      def clear_constants
+        _filtered_constants.each do |(obj, name)|
+          obj.send(:remove_const, name)
+        end
+        @caught_constants = []
+      end
+
+      def clear_global_variables
+        @caught_variables.each do |name|
+          eval("#{name} = nil", binding, __FILE__, __LINE__)
+        end
+      end
+
+      # Filteres caught constants by location prefixes and returns ones that should be removed.
+      #
+      # @return [Array<[Object, :Symbol]>]
+      def _filtered_constants
+        @caught_constants.select do |(obj, name)|
+          next unless obj.const_defined?(name)
+          next true if constants_location_prefixes.nil?
+
+          konst = obj.const_get(name)
+          begin
+            location = Bade.where_is(konst)
+          rescue ::ArgumentError
+            next
+          end
+
+          path = location.first
+          constants_location_prefixes&.any? { |prefix| path.start_with?(prefix) }
+        end
+      end
+    end
+  end
+end

data/lib/bade/runtime/mixin.rb

@@ -1,43 +1,58 @@
 # frozen_string_literal: true
 
+require_relative '../ruby2_keywords'
+
 module Bade
   module Runtime
     require_relative 'block'
 
     class Mixin < Block
-      def call!(blocks, *args)
-        block.call(blocks, *args)
-      rescue ArgumentError => e
-        case e.message
-        when /\Awrong number of arguments \(given ([0-9]+), expected ([0-9]+)\)\Z/,
-             /\Awrong number of arguments \(([0-9]+) for ([0-9]+)\)\Z/
-          # handle incorrect parameters count
-
-          # minus one, because first argument is always hash of blocks
-          given = $1.to_i - 1
-          expected = $2.to_i - 1
-          raise ArgumentError, "wrong number of arguments (given #{given}, expected #{expected}) for mixin `#{name}`"
-
-        when /\Aunknown keyword: (.*)\Z/
-          # handle unknown key-value parameter
-          key_name = $1
-          raise ArgumentError, "unknown key-value argument `#{key_name}` for mixin `#{name}`"
-
-        else
-          raise
-        end
+      ruby2_keywords def call!(blocks, *args)
+        begin
+          __call(blocks, *args)
+        rescue ::ArgumentError => e
+          case e.message
+          when /\Awrong number of arguments \(given ([0-9]+), expected ([0-9]+)\)\Z/,
+               /\Awrong number of arguments \(([0-9]+) for ([0-9]+)\)\Z/
+            # handle incorrect parameters count
+
+            # minus one, because first argument is always hash of blocks
+            given = $1.to_i - 1
+            expected = $2.to_i - 1
+            msg = "wrong number of arguments (given #{given}, expected #{expected}) for mixin `#{name}`"
+            raise Bade::Runtime::ArgumentError.new(msg, render_binding.__location_stack)
+
+          when /\Aunknown keyword: (.*)\Z/
+            # handle unknown key-value parameter
+            key_name = $1
+            msg = "unknown key-value argument `#{key_name}` for mixin `#{name}`"
+            raise Bade::Runtime::ArgumentError.new(msg, render_binding.__location_stack)
 
-      rescue Block::MissingBlockDefinitionError => e
-        msg = case e.context
-              when :call
-                "Mixin `#{name}` requires block to get called of block `#{e.name}`"
-              when :render
-                "Mixin `#{name}` requires block to get rendered content of block `#{e.name}`"
-              else
-                raise ::ArgumentError, "Unknown context #{e.context} of error #{e}!"
-              end
-
-        raise Block::MissingBlockDefinitionError.new(e.name, e.context, msg)
+          when /\Amissing keyword: :?(.*)\Z/
+            key_name = $1
+            msg = "missing value for required key-value argument `#{key_name}` for mixin `#{name}`"
+            raise Bade::Runtime::ArgumentError.new(msg, render_binding.__location_stack)
+
+          else
+            raise
+          end
+        rescue Block::MissingBlockDefinitionError => e
+          msg = case e.context
+                when :call
+                  "Mixin `#{name}` requires block to get called of block `#{e.name}`"
+                when :render
+                  "Mixin `#{name}` requires block to get rendered content of block `#{e.name}`"
+                else
+                  raise Bade::Runtime::ArgumentError.new("Unknown context #{e.context} of error #{e}!",
+                                                         render_binding.__location_stack)
+                end
+
+          raise Block::MissingBlockDefinitionError.new(e.name, e.context, msg, render_binding.__location_stack)
+
+        rescue Exception => e
+          msg = "Exception raised during execution of mixin `#{name}`: #{e}"
+          raise Bade::Runtime::RuntimeError.wrap_existing_error(msg, e, render_binding.__location_stack)
+        end
       end
     end
   end