bade 0.2.5 → 0.3.2

data/lib/bade/ruby_extensions/string.rb

@@ -83,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
@@ -94,13 +95,4 @@ class String
 
     count
   end
-
-  # source: http://apidock.com/rails/String/strip_heredoc
-  # @return [String]
-  #
-  def strip_heredoc
-    min_val = scan(/^[ \t]*(?=\S)/).min
-    indent = (min_val && min_val.size) || 0
-    gsub(/^[ \t]{#{indent}}/, '')
-  end
 end

data/lib/bade/runtime/block.rb

@@ -4,8 +4,6 @@ require_relative '../ruby2_keywords'
 
 module Bade
   module Runtime
-    class RuntimeError < ::StandardError; end
-
     class Block
       class MissingBlockDefinitionError < RuntimeError
         # @return [String]
@@ -16,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
@@ -38,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
 
+      # Calls the block and adds rendered content into current buffer stack.
+      #
+      # @return [Void]
       ruby2_keywords def call(*args)
         call!(*args) unless @block.nil?
       end
 
+      # Calls the block and adds rendered content into current buffer stack.
+      #
+      # @return [Void]
       ruby2_keywords def call!(*args)
-        raise MissingBlockDefinitionError.new(name, :call) if @block.nil?
+        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?
           ''
@@ -74,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

@@ -9,8 +9,8 @@ module Bade
     class Mixin < Block
       ruby2_keywords def call!(blocks, *args)
         begin
-          block.call(blocks, *args)
-        rescue ArgumentError => e
+          __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/
@@ -19,12 +19,19 @@ module Bade
             # 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}`"
+            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
-            raise ArgumentError, "unknown key-value argument `#{key_name}` for mixin `#{name}`"
+            msg = "unknown key-value argument `#{key_name}` for mixin `#{name}`"
+            raise Bade::Runtime::ArgumentError.new(msg, render_binding.__location_stack)
+
+          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
@@ -36,10 +43,18 @@ module Bade
                 when :render
                   "Mixin `#{name}` requires block to get rendered content of block `#{e.name}`"
                 else
-                  raise ::ArgumentError, "Unknown context #{e.context} of error #{e}!"
+                  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)
+          raise Block::MissingBlockDefinitionError.new(e.name, e.context, msg, render_binding.__location_stack)
+
+        rescue RuntimeError
+          raise
+
+        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

data/lib/bade/runtime/render_binding.rb

@@ -5,12 +5,15 @@ require_relative 'block'
 module Bade
   module Runtime
     class RenderBinding
-      class KeyError < ::StandardError; end
+      Location = Bade::Runtime::Location
 
       # @return [Array<Array<String>>]
       #
       attr_accessor :__buffs_stack
 
+      # @return [Array<Location>]
+      attr_accessor :__location_stack
+
       # @return [Hash<String, Mixin>]
       #
       attr_accessor :__mixins
@@ -34,13 +37,14 @@ module Bade
         end
       end
 
-      # Resets this binding to default state, this method should be envoked after running the template lambda
+      # Resets this binding to default state, this method should be evoked after running the template lambda
       #
       # @return [nil]
       #
       def __reset
-        @__buffs_stack = [[]]
-        @__mixins = Hash.new { |_hash, key| raise "Undefined mixin '#{key}'" }
+        @__buffs_stack = []
+        @__location_stack = []
+        @__mixins = Hash.new { |_hash, key| raise Bade::Runtime::KeyError.new("Undefined mixin '#{key}'", __location_stack) }
       end
 
       # @return [Binding]
@@ -51,26 +55,56 @@ module Bade
 
       # Shortcut for creating blocks
       #
-      def __create_block(name, &block)
-        Bade::Runtime::Block.new(name, self, &block)
+      def __create_block(name, location = nil, &block)
+        Bade::Runtime::Block.new(name, location, self, &block)
       end
 
-      def __create_mixin(name, &block)
-        Bade::Runtime::Mixin.new(name, self, &block)
+      def __create_mixin(name, location, &block)
+        Bade::Runtime::Mixin.new(name, location, self, &block)
       end
 
-      # --- Methods for dealing with pushing and poping buffers in stack
+      # --- Methods for dealing with pushing and popping buffers in stack
 
       def __buff
-        __buffs_stack.last
+        __buffs_stack.first
       end
 
-      def __buffs_push
-        __buffs_stack.push([])
+      # @param [RenderBinding::Location, nil] location
+      def __buffs_push(location)
+        __buffs_stack.unshift([])
+        __location_stack.unshift(location) unless location.nil?
       end
 
+      # @return [Array<String>, nil]
       def __buffs_pop
-        __buffs_stack.pop
+        __location_stack.shift
+        __buffs_stack.shift
+      end
+
+      # --- Other internal methods
+
+      # @param [String] filename
+      def __load(filename)
+        # FakeFS does not fake `load` method
+        if Object.const_defined?(:FakeFS) && Object.const_get(:FakeFS).activated?
+          # rubocop:disable Security/Eval
+          eval(File.read(filename), __get_binding, filename)
+          # rubocop:enable Security/Eval
+        else
+          load(filename)
+        end
+      end
+
+      # @param [String] filename
+      def require_relative(filename)
+        # FakeFS does not fake `require_relative` method
+        if Object.const_defined?(:FakeFS) && Object.const_get(:FakeFS).activated?
+          # rubocop:disable Security/Eval
+          eval(File.read(filename), __get_binding, filename)
+          # rubocop:enable Security/Eval
+        else
+          Kernel.require_relative(filename)
+        end
       end
 
       # Escape input text with html escapes
@@ -94,6 +128,15 @@ module Bade
 
         %( #{name}="#{values.join(' ')}")
       end
+
+      def __update_lineno(number)
+        __location_stack.first&.lineno = number
+      end
+
+      # @return [Location, nil]
+      def __current_location
+        __location_stack.first
+      end
     end
   end
 end

data/lib/bade/runtime/utils/where.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# Inspired by https://gist.github.com/wtaysom/1236979
+
+module Bade
+  module Where
+    class << self
+      def is_proc(proc)
+        source_location(proc)
+      end
+
+      def is_method(klass, method_name)
+        source_location(klass.method(method_name))
+      end
+
+      def is_instance_method(klass, method_name)
+        source_location(klass.instance_method(method_name))
+      end
+
+      def are_methods(klass, method_name)
+        are_via_extractor(:method, klass, method_name)
+      end
+
+      def are_instance_methods(klass, method_name)
+        are_via_extractor(:method, klass, method_name)
+      end
+
+      def is_class(klass)
+        defined_methods(klass)
+          .group_by { |sl| sl[0] }
+          .map do |file, sls|
+            lines = sls.map { |sl| sl[1] }
+            count = lines.size
+            line = lines.min
+
+            {
+              file: file,
+              count: count,
+              line: line
+            }
+          end
+          .sort_by { |fc| fc[:count] }
+          .map { |fc| [fc[:file], fc[:line]] }
+      end
+
+      # Raises ArgumentError if klass does not have any Ruby methods defined in it.
+      def is_class_primarily(klass)
+        source_locations = is_class(klass)
+        if source_locations.empty?
+          methods = defined_methods(klass)
+          msg = if methods.empty?
+                  "#{klass} has no methods"
+                else
+                  "#{klass} only has built-in methods (#{methods.size} in total)"
+                end
+
+          raise ::ArgumentError, msg
+        end
+        source_locations[0]
+      end
+
+      private
+
+      def source_location(method)
+        method.source_location || (
+          method.to_s =~ /: (.*)>/
+          Regexp.last_match(1)
+        )
+      end
+
+      def are_via_extractor(extractor, klass, method_name)
+        klass.ancestors
+             .map do |ancestor|
+               method = ancestor.send(extractor, method_name)
+               source_location(method) if method.owner == ancestor
+             end
+             .compact
+      end
+
+      def defined_methods(klass)
+        methods = klass.methods(false).map { |m| klass.method(m) } +
+                  klass.instance_methods(false).map { |m| klass.instance_method(m) }
+        methods
+          .map(&:source_location)
+          .compact
+      end
+    end
+  end
+
+  def self.where_is(klass, method = nil)
+    if method
+      begin
+        Where.is_instance_method(klass, method)
+      rescue NameError
+        Where.is_method(klass, method)
+      end
+    else
+      Where.is_class_primarily(klass)
+    end
+  end
+end

data/lib/bade/runtime.rb

@@ -1,9 +1,116 @@
 # frozen_string_literal: true
 
-module Epuber
+module Bade
   module Runtime
+    Location = Struct.new(:path, :lineno, :label, keyword_init: true) do
+      def template?
+        path == TEMPLATE_FILE_NAME || path&.include?('.bade')
+      end
+
+      def to_s
+        "#{path || TEMPLATE_FILE_NAME}:#{lineno}:in `#{label}'"
+      end
+    end
+
+    class RuntimeError < ::StandardError
+      # @return [Array<Location>]
+      #
+      attr_reader :template_backtrace
+
+      # @return [Boolean]
+      #
+      attr_reader :print_locations_warning
+
+      # @param [String] msg
+      # @param [Array<Location>] template_backtrace
+      # @param [Exception, nil] original
+      def initialize(msg, template_backtrace = [], original: nil, print_locations_warning: false)
+        super(msg)
+        @template_backtrace = template_backtrace
+        @original = original
+        @print_locations_warning = print_locations_warning
+      end
+
+      def message
+        if @template_backtrace.empty?
+          super
+        else
+          warning = if print_locations_warning
+                      <<~TEXT
+
+                        !!! WARNING !!!, filenames and line numbers of functions can be misleading due to using Ruby
+                        functions in different Bade file. Trust only functions names. Mixins are fine.
+
+                        This will be fixed in https://github.com/epuber-io/bade/issues/32
+                      TEXT
+                    else
+                      ''
+                    end
+
+          <<~MSG.rstrip
+            #{super}
+            template backtrace:
+            #{__formatted_backtrace.join("\n")}
+            #{warning}
+          MSG
+        end
+      end
+
+      def cause
+        @original
+      end
+
+      # @return [Array<String>]
+      def __formatted_backtrace
+        bt = @template_backtrace
+
+        # delete first location if is same as second (can happen when arguments are incorrect)
+        last = bt.first
+        bt.delete_at(0) if last && bt.length > 1 && last == bt[1]
+
+        bt.map { |loc| "  #{loc}" }
+      end
+
+      # @param [Array<Thread::Backtrace::Location>, nil] locations
+      def self.process_locations(locations)
+        return [] if locations.nil?
+
+        # map to Bade's Location
+        new_locations = locations.map { |loc| Location.new(path: loc.path, lineno: loc.lineno, label: loc.label) }
+
+        # find location to use or drop
+        index = new_locations.rindex(&:template?)
+        return [] if index.nil?
+
+        # get only locations inside template
+        new_locations = new_locations[0...index] || []
+
+        # filter out not interested locations 
+        new_locations
+          .reject { |loc| loc.path.start_with?(__dir__) }
+          .reject { |loc| loc.template? && loc.label.include?('lambda_instance') }
+      end
+
+      # @param [String] msg
+      # @param [Exception] error
+      # @param [Array<Location>] template_backtrace
+      # @return [RuntimeError]
+      def self.wrap_existing_error(msg, error, template_backtrace)
+        ruby_locs = Bade::Runtime::RuntimeError.process_locations(error.backtrace_locations)
+        locs = ruby_locs + template_backtrace
+        Bade::Runtime::RuntimeError.new(msg, locs, original: error, print_locations_warning: !ruby_locs.empty?)
+      end
+    end
+
+    class KeyError < RuntimeError; end
+
+    class ArgumentError < RuntimeError; end
+
+    TEMPLATE_FILE_NAME = '(__template__)'.freeze
+
     require_relative 'runtime/block'
     require_relative 'runtime/mixin'
     require_relative 'runtime/render_binding'
+    require_relative 'runtime/globals_tracker'
   end
 end

data/lib/bade/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bade
-  VERSION = '0.2.5'.freeze
+  VERSION = '0.3.2'.freeze
 end

data/lib/bade.rb

@@ -7,4 +7,5 @@ module Bade
   require_relative 'bade/generator'
   require_relative 'bade/renderer'
   require_relative 'bade/optimizer'
+  require_relative 'bade/precompiled'
 end