rblade 2.0.2 → 3.0.0

data/lib/rblade/compiler/statements/compiles_stacks.rb

@@ -3,7 +3,7 @@
 module RBlade
   class CompilesStatements
     class CompilesStacks
-      def compileStack args
+      def compile_stack(args)
         if args&.count != 1
           raise RBladeTemplateError.new "Stack statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
         end
@@ -11,7 +11,7 @@ module RBlade
         "@_rblade_stack_manager.initialize_stack(#{args[0]}, @output_buffer);_stacks.push(#{args[0]});"
       end
 
-      def compilePrepend args
+      def compile_prepend(args)
         if args&.count != 1
           raise RBladeTemplateError.new "Prepend statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
         end
@@ -19,7 +19,7 @@ module RBlade
         "@_rblade_stack_manager.prepend(#{args[0]}, @output_buffer) do;"
       end
 
-      def compilePrependIf args
+      def compile_prepend_if(args)
         if args&.count != 2
           raise RBladeTemplateError.new "Prepend if statement: wrong number of arguments (given #{args&.count}, expecting 2)"
         end
@@ -27,7 +27,7 @@ module RBlade
         "(#{args[0]}) && @_rblade_stack_manager.prepend(#{args[1]}, @output_buffer) do;"
       end
 
-      def compilePush args
+      def compile_push(args)
         if args&.count != 1
           raise RBladeTemplateError.new "Push statement: wrong number of arguments (given #{args&.count}, expecting 1)"
         end
@@ -35,7 +35,7 @@ module RBlade
         "@_rblade_stack_manager.push(#{args[0]}, @output_buffer) do;"
       end
 
-      def compilePushIf args
+      def compile_push_if(args)
         if args&.count != 2
           raise RBladeTemplateError.new "Push if statement: wrong number of arguments (given #{args&.count || 0}, expecting 2)"
         end

data/lib/rblade/compiler/tokenizes_components.rb

@@ -8,7 +8,7 @@ module RBlade
       tokens.map! do |token|
         next(token) if token.type != :unprocessed
 
-        segments = tokenizeComponentTags token.value
+        segments = tokenize_component_tags token.value
 
         i = 0
         while i < segments.count
@@ -22,9 +22,9 @@ module RBlade
             i += 1
           elsif segments[i] == "<" && segments[i + 1]&.match?(/x[-:]/)
             name = segments[i + 1][2..]
-            raw_attributes = (segments[i + 2] != ">") ? tokenizeAttributes(segments[i + 2]) : nil
+            raw_attributes = (segments[i + 2] != ">") ? tokenize_attributes(segments[i + 2]) : nil
 
-            attributes = processAttributes raw_attributes
+            attributes = process_attributes raw_attributes
 
             if raw_attributes.nil?
               segments.delete_at i + 1
@@ -54,7 +54,7 @@ module RBlade
 
     private
 
-    def processAttributes raw_attributes
+    def process_attributes(raw_attributes)
       attributes = []
       i = 0
       while i < raw_attributes.count
@@ -84,7 +84,7 @@ module RBlade
           end
 
           # If the entire value is a single interpolated string, make this a ruby value
-          if attribute[:value]&.match?(/\A\{\{([^}]|(?!\}\})\})*\}\}\Z/)
+          if attribute[:value]&.match?(/\A\{\{([^}]++|(?!\}\})\})*\}\}\z/)
             attribute[:type] = "ruby"
             attribute[:name] = name
             attribute[:value] = attribute[:value][2..-3]
@@ -112,75 +112,74 @@ module RBlade
       attributes
     end
 
-    def tokenizeComponentTags value
+    def tokenize_component_tags(value)
       value.split(%r/
         # Opening and self-closing tags
         (?:
           (<)
-            \s*
-            (x[-\:][\w\-\:\.]*)
+            \s*+
+            (x[-\:][\w\-\:\.]++)
             ((?:
-              \s+
+              \s++
               (?:
                 (?:
-                  @class(\( (?: (?>[^()]+) | \g<-1> )* \))
+                  @class(\( (?: [^()]++ | \g<-1> )*+ \))
                 )
                 |
                 (?:
-                  @style(\( (?: (?>[^()]+)| \g<-1> )* \))
+                  @style(\( (?: [^()]++ | \g<-1> )*+ \))
                 )
                 |
                 (
-                  \{\{\s*attributes.*?\s*\}\}
+                  \{\{ \s*+ attributes (?:[^}]++|\})*? \}\}
                 )
                 |
                 (?:
-                  [\w\-:.@%]+
+                  [\w\-:.@%]++
                   (?:
                     =
                     (?:
-                      "(?:[^"{]*?|(?<!@)\{\{.*?\}\}|\{)*"
+                      "(?> [^"{]++ | (?<!@)\{\{ (?:[^}]++|\})*? \}\} | \{ )*+"
                       |
-                      '(?:[^'{]*?|(?<!@)\{\{.*?\}\}|\{)*'
+                      '(?> [^'{]++ | (?<!@)\{\{ (?:[^}]++|\})*? \}\} | \{ )*+'
                       |
-                      (?:[^'"=<>\s\/{]+|(?<!@)\{\{.*?\}\}|\{)*
+                      (?> [^'"=<>\s\/{]++ | (?<!@)\{\{ (?:[^}]++|\})*? \}\} | \{ )++
                     )
                   )?
                 )
               )
-            )*)
-            \s*
-            (?<![=\-])
+            )*+)
+            \s*+
           (\/?>)
         )
         |
         # Closing tags
         (?:
           (<\/)
-            \s*
-            (x[-\:][\w\-\:\.]*)
-            \s*
+            \s*+
+            (x[-\:][\w\-\:\.]++)
+            \s*+
           >
         )
         |
         (<\/\/>)
-      /xm)
+      /x)
     end
 
-    def tokenizeAttributes segment
+    def tokenize_attributes(segment)
       segment.scan(%r/
         (?<=\s|^)
         (?:
           (?:
-            (@class)(\( (?: (?>[^()]+) | \g<-1> )* \))
+            (@class)(\( (?: (?>[^()]+) | \g<-1> )*+ \))
           )
           |
           (?:
-            (@style)(\( (?: (?>[^()]+)| \g<-1> )* \))
+            (@style)(\( (?: (?>[^()]+)| \g<-1> )*+ \))
           )
           |
           (?:
-            (\{\{)\s*(attributes.*?)\s*(\}\})
+            (\{\{) \s*+ (attributes(?:[^}\s]++|\}|\s)*?) \s*+ (\}\})
           )
           |
           (?:
@@ -188,17 +187,17 @@ module RBlade
             (?:
               (=)
               (?:
-                "((?:[^"{]*?|(?<!@)\{\{.*?\}\}|\{)*)"
+                "((?> [^"{]++ | (?<!@)\{\{ (?:[^}]++|\})*? \}\} | \{ )*+)"
                 |
-                '((?:[^'{]*?|(?<!@)\{\{.*?\}\}|\{)*)'
+                '((?> [^'{]++ | (?<!@)\{\{ (?:[^}]++|\})*? \}\} | \{ )*+)'
                 |
-                ((?:[^'"=<>\s\/{]+|(?<!@)\{\{.*?\}\}|\{)*)
+                ((?> [^'"=<>\s\/{]++ | (?<!@)\{\{(?:[^}]++|\})*?\}\} | \{ )*+)
               )
             )?
           )
         )
         (?=\s|$)
-      /xm).flatten.compact
+      /x).flatten.compact
     end
   end
 end

data/lib/rblade/compiler/tokenizes_statements.rb

@@ -14,27 +14,27 @@ module RBlade
           (?:
             (?:
               (@@)
-              (\w+(?!\w)[!\?]?)
+              (\w++[!\?]?)
             )
             |
             (?:
               (@)
-              (\w+(?!\w)[!\?]?)
-              (?:([ \t]*)
-                (\(.*?\))
+              (\w++[!\?]?)
+              (?:([ \t]*+)
+                (\([^)]*+\))
               )?
             )
           )
           (\s)?
-        /mx)
+        /x)
 
-        parseSegments! segments
+        parse_segments! segments
       end.flatten!
     end
 
     private
 
-    def parseSegments! segments
+    def parse_segments!(segments)
       i = 0
       while i < segments.count
         segment = segments[i]
@@ -46,12 +46,13 @@ module RBlade
 
           i += 1
         elsif segment == "@"
-          if CompilesStatements.has_handler(segments[i + 1])
-            tokenizeStatement! segments, i
-            handleSpecialCases! segments, i
+          statement_handle = segments[i + 1].downcase.tr "_", ""
+          if CompilesStatements.has_handler(statement_handle)
+            tokenize_statement! statement_handle, segments, i
+            handle_special_cases! segments, i
 
-            segments.delete_at(i + 1) if segments[i + 1]&.match?(/\A\s\Z/)
-            if segments[i - 1].is_a?(Token) && segments[i - 1].type == :unprocessed && segments[i - 1].value.match?(/\A\s\Z/)
+            segments.delete_at(i + 1) if segments[i + 1]&.match?(/\A\s\z/)
+            if segments[i - 1].is_a?(Token) && segments[i - 1].type == :unprocessed && segments[i - 1].value.match?(/\A\s\z/)
               segments.delete_at i - 1
               i -= 1
             end
@@ -60,7 +61,7 @@ module RBlade
             segments[i] = Token.new(type: :unprocessed, value: segments[i] + segments[i + 1])
             segments.delete_at i + 1
 
-            if segments.count > i + 2 && segments[i + 1].match?(/\A[ \t]*\Z/) && segments[i + 2][0] == "("
+            if segments.count > i + 2 && segments[i + 1].match?(/\A[ \t]*+\z/) && segments[i + 2][0] == "("
               segments[i].value += segments[i + 1] + segments[i + 2]
               segments.delete_at i + 1
               segments.delete_at i + 1
@@ -83,19 +84,19 @@ module RBlade
       segments
     end
 
-    def tokenizeStatement!(segments, i)
-      statement_data = {name: segments[i + 1]}
-      statement_name = segments.delete_at i + 1
+    def tokenize_statement!(handle, segments, i)
+      segments.delete_at i + 1
+      statement_data = {name: handle}
 
       # Remove optional whitespace
-      if segments.count > i + 2 && segments[i + 1].match?(/\A[ \t]*\Z/) && segments[i + 2][0] == "("
+      if segments.count > i + 2 && segments[i + 1].match?(/\A[ \t]*+\z/) && segments[i + 2][0] == "("
         segments.delete_at i + 1
       end
 
       if segments.count > i + 1 && segments[i + 1][0] == "("
-        arguments = tokenizeArguments! statement_name, segments, i + 1
+        arguments = tokenize_arguments! handle, segments, i + 1
 
-        if !arguments.nil?
+        unless arguments.nil?
           statement_data[:arguments] = arguments
         end
       end
@@ -103,9 +104,8 @@ module RBlade
       segments[i] = Token.new(type: :statement, value: statement_data)
     end
 
-    def handleSpecialCases!(segments, i)
-      case segments[i][:value][:name]
-      when "case"
+    def handle_special_cases!(segments, i)
+      if segments[i][:value][:name] == "case"
         # Remove any whitespace before a when statement
         until segments[i + 1].nil? || segments[i + 1] == "@"
           segments.delete_at i + 1
@@ -113,12 +113,12 @@ module RBlade
       end
     end
 
-    def tokenizeArguments!(statement_name, segments, segment_index)
-      success = expandSegmentToEndParenthesis! segments, segment_index
+    def tokenize_arguments!(statement_handle, segments, segment_index)
+      success = expand_segment_to_end_parenthesis! segments, segment_index
 
       # If no matching parentheses were found, so we combine the argument string with the next segment
-      if !success
-        if !segments[segment_index + 1].nil?
+      unless success
+        unless segments[segment_index + 1].nil?
           segments[segment_index] <<= segments[segment_index + 1]
           segments.delete_at segment_index + 1
         end
@@ -130,21 +130,20 @@ module RBlade
       argument_string = segments[segment_index][1..-2]
 
       # Special case for the props statement: remove the wrapping braces if they exist
-      if statement_name == "props"
+      if statement_handle == "props"
         if argument_string.start_with?("{") && argument_string.end_with?("}")
           argument_string = argument_string[1..-2]
         end
       end
 
-      arguments = Tokenizer.extractCommaSeparatedValues argument_string
+      arguments = Tokenizer.extract_comma_separated_values argument_string
       segments.delete_at segment_index
 
       arguments
     end
 
-    def expandSegmentToEndParenthesis! segments, segment_index
+    def expand_segment_to_end_parenthesis!(segments, segment_index)
       parentheses_difference = 0
-      tokens = nil
 
       loop do
         tokens = Ripper.lex(segments[segment_index]).map { |token| token[1] }

data/lib/rblade/compiler.rb

@@ -2,8 +2,7 @@
 
 require "rblade/compiler/compiles_comments"
 require "rblade/compiler/compiles_components"
-require "rblade/compiler/compiles_prints"
-require "rblade/compiler/compiles_ruby"
+require "rblade/compiler/compiles_injections"
 require "rblade/compiler/compiles_verbatim"
 require "rblade/compiler/compiles_statements"
 require "rblade/compiler/tokenizes_components"
@@ -12,57 +11,59 @@ require "active_support/core_ext/string/output_safety"
 
 Token = Struct.new(:type, :value)
 
-if !defined?(h)
-  require "erb/escape"
-  define_method(:h, ERB::Escape.instance_method(:html_escape))
-end
-
 module RBlade
-  def self.escape_quotes string
-    string.gsub(/['\\\x0]/, '\\\\\0')
+  def self.escape_quotes(string)
+    string&.gsub(/['\\\x0]/, '\\\\\0')
   end
 
   class RBladeTemplateError < StandardError; end
 
-  # Register a new custom directive by providing a class and method that will compile the directive into ruby code.
+  # Register a new custom directive by providing a proc that will return a value to be output
   #
   # @param [String] name The directive tag without the "@", e.g. "if" for the "@if" directive
-  # @param [Proc] block The block that will return the compiled ruby code for the directive. Any arguments will be passed to this Proc as an array.
+  # @param [Proc] block The block that will return the compiled ruby code for the directive. Can accept `:args`, `:tokens` and `:token_index` as arguments.
   # @return [void]
   def self.register_directive_handler(name, &)
     CompilesStatements.register_handler(name, &)
   end
 
+  # Register a new custom directive by providing a proc that will return ruby code to add to the template. The code must end in a semi-colon.
+  #
+  # @param [String] name The directive tag without the "@", e.g. "if" for the "@if" directive
+  # @param [Proc] block The block that will return the compiled ruby code for the directive. Can accept `:args`, `:tokens` and `:token_index` as arguments.
+  # @return [void]
+  def self.register_raw_directive_handler(name, &)
+    CompilesStatements.register_raw_handler(name, &)
+  end
+
   class Compiler
-    def self.compileString(string_template, component_store)
+    def self.compile_string(string_template, component_store)
       tokens = [Token.new(:unprocessed, string_template)]
 
       CompilesVerbatim.new.compile! tokens
       CompilesComments.new.compile! tokens
-      CompilesRuby.new.compile! tokens
       TokenizesComponents.new.tokenize! tokens
-      CompilesPrints.new.compile! tokens
+      CompilesInjections.new.compile! tokens
       TokenizesStatements.new.tokenize! tokens
       CompilesStatements.new.compile! tokens
 
       component_compiler = CompilesComponents.new(component_store)
       component_compiler.compile! tokens
       component_compiler.ensure_all_tags_closed
-
-      compileTokens tokens
+      compile_tokens tokens
     end
 
-    def self.compileAttributeString(string_template)
+    def self.compile_attribute_string(string_template)
       tokens = [Token.new(:unprocessed, string_template)]
 
       CompilesComments.compile!(tokens)
       CompilesRuby.compile! tokens
       CompilesPrints.compile!(tokens)
 
-      compileTokens tokens
+      compile_tokens tokens
     end
 
-    def self.compileTokens tokens
+    def self.compile_tokens(tokens)
       output = +""
 
       i = 0

data/lib/rblade/component_store.rb

@@ -14,7 +14,7 @@ module RBlade
     def component(full_name)
       # If this is a relative path, prepend with the previous component name's base
       if full_name.start_with? "."
-        full_name = @component_name_stack.last.gsub(/\.[^\.]+\Z/, "") + full_name
+        full_name = @component_name_stack.last.sub(/[^.]++\z/, "") + full_name.delete_prefix(".")
       end
 
       # Ensure each component is only compiled once
@@ -24,14 +24,7 @@ module RBlade
 
       @component_name_stack << full_name
 
-      namespace = nil
-      name = full_name
-
-      if name.match? "::"
-        namespace, name = full_name.split("::")
-      end
-
-      method_name = compile_component full_name, File.read(find_component_file(namespace, name))
+      method_name = compile_component full_name, File.read(find_component_file(full_name, @component_name_stack))
       @component_name_stack.pop
 
       method_name
@@ -43,31 +36,37 @@ module RBlade
         path << "/"
       end
 
-      @@template_paths[namespace] ||= []
-      @@template_paths[namespace] << path
+      template_paths[namespace] ||= []
+      template_paths[namespace] << path
     end
 
     def view_name(view_name)
       @component_name_stack.push view_name
     end
 
+    def current_view_name
+      @component_name_stack.last
+    end
+
     def get
       @component_definitions
     end
 
-    private
+    def self.find_component_file(name, name_stack = nil)
+      if name.match? "::"
+        namespace, name = name.split("::", 2)
+      end
 
-    def find_component_file(namespace, name)
       file_path = name.tr ".", "/"
 
-      @@template_paths[namespace]&.each do |base_path|
+      template_paths[namespace]&.each do |base_path|
         FILE_EXTENSIONS.each do |extension|
           if File.exist? base_path + file_path + extension
             return "#{base_path}#{file_path}#{extension}"
           end
           if File.exist? base_path + file_path + "/index" + extension
             # Account for index files for relative components
-            @component_name_stack << @component_name_stack.pop + ".index"
+            name_stack << name_stack.pop + ".index" if name_stack
             return "#{base_path}#{file_path}/index#{extension}"
           end
         end
@@ -75,6 +74,9 @@ module RBlade
 
       raise RBladeTemplateError.new "Unknown component #{namespace}::#{name}"
     end
+    delegate :find_component_file, to: :class
+
+    private
 
     def compile_component(name, template)
       escaped_name = name.gsub(/[^0-9a-zA-Z_]/) do |match|
@@ -82,15 +84,13 @@ module RBlade
         (match == ".") ? "__" : "_#{match.unpack1("H*")}_"
       end
 
-      compiled_component = RBlade::Compiler.compileString(template, self)
-
-      slot_assignment = compiled_component.match?(/\Wslot\W/) ? "slot=" : ""
+      compiled_component = RBlade::Compiler.compile_string(template, self)
 
-      @component_definitions << "def self._rblade_component_#{escaped_name}(attributes,&);#{slot_assignment}if block_given?;RBlade::SlotManager.new(@output_buffer.capture(->(name, slot_attributes, &slot_block)do;attributes[name]=RBlade::SlotManager.new(@output_buffer.capture(&slot_block), slot_attributes);end,&));end;_stacks=[];@output_buffer.raw_buffer<<@output_buffer.capture do;#{compiled_component}@output_buffer.raw_buffer.prepend(@_rblade_stack_manager.get(_stacks));end;end;"
+      @component_definitions << "def self._rblade_component_#{escaped_name}(attributes,&);slot=if block_given?;RBlade::SlotManager.new(@output_buffer.capture(->(name, slot_attributes, &slot_block)do;attributes[name]=RBlade::SlotManager.new(@output_buffer.capture(&slot_block), slot_attributes);end,&));end;_stacks=[];@output_buffer.raw_buffer<<@output_buffer.capture do;#{compiled_component}@output_buffer.raw_buffer.prepend(@_rblade_stack_manager.get(_stacks));end;end;"
 
       @component_method_names[name] = "_rblade_component_#{escaped_name}"
     end
 
-    @@template_paths = {}
+    cattr_accessor :template_paths, default: {}
   end
 end

data/lib/rblade/helpers/attributes_manager.rb

@@ -2,8 +2,9 @@
 
 module RBlade
   class AttributesManager
-    @attributes = {}
-    def initialize attributes
+    delegate :delete, to: :@attributes
+
+    def initialize(attributes)
       @attributes = attributes
     end
 
@@ -37,11 +38,11 @@ module RBlade
       true
     end
 
-    def to_str attributes = nil
+    def to_str(attributes = nil)
       attributes ||= @attributes
 
       attributes.map do |key, value|
-        (value == true) ? key : "#{key}=\"#{h(value)}\""
+        (value == true) ? key : "#{key}=\"#{CGI.escape_html(value.to_s)}\""
       end.join(" ")
     end
 
@@ -72,7 +73,7 @@ module RBlade
     def class(new_classes)
       new_classes = ClassManager.new(new_classes).to_s
       attributes = @attributes.dup
-      attributes[:class] = mergeClasses attributes[:class], new_classes
+      attributes[:class] = merge_classes attributes[:class], new_classes
 
       AttributesManager.new attributes
     end
@@ -82,12 +83,12 @@ module RBlade
 
       @attributes.each do |key, value|
         if key == :class && !new_attributes[key].nil?
-          new_attributes[key] = mergeClasses(new_attributes[key], value.to_s)
+          new_attributes[key] = merge_classes(new_attributes[key], value.to_s)
           next
         end
 
         if key == :style && !new_attributes[key].nil?
-          new_attributes[key] = mergeStyles(new_attributes[key], value.to_s)
+          new_attributes[key] = merge_styles(new_attributes[key], value.to_s)
           next
         end
 
@@ -105,7 +106,7 @@ module RBlade
 
     private
 
-    def mergeClasses(classes_1, classes_2)
+    def merge_classes(classes_1, classes_2)
       if classes_1.nil?
         return classes_2
       end
@@ -122,7 +123,7 @@ module RBlade
       classes_combined
     end
 
-    def mergeStyles(styles_1, styles_2)
+    def merge_styles(styles_1, styles_2)
       if styles_1.nil?
         return styles_2
       end

data/lib/rblade/helpers/class_manager.rb

@@ -2,7 +2,7 @@
 
 module RBlade
   class ClassManager
-    def initialize classes
+    def initialize(classes)
       if classes.is_a? String
         @classes = classes
       elsif classes.is_a? Array

data/lib/rblade/helpers/slot_manager.rb

@@ -4,7 +4,7 @@ require "rblade/helpers/attributes_manager"
 
 module RBlade
   class SlotManager
-    def initialize content, attributes = nil
+    def initialize(content, attributes = nil)
       @content = content
       @attributes = attributes && AttributesManager.new(attributes)
     end
@@ -30,7 +30,7 @@ module RBlade
     end
 
     # Wraps var in a slot manager if it's a string
-    def self.wrap var
+    def self.wrap(var)
       var.is_a?(String) ? new(var) : var
     end
 

data/lib/rblade/helpers/stack_manager.rb

@@ -40,7 +40,7 @@ module RBlade
         @stack = +""
       end
 
-      def set_before_stack before_stack
+      def set_before_stack(before_stack)
         @before_stack = before_stack
       end
 
@@ -52,11 +52,11 @@ module RBlade
         to_s
       end
 
-      def push code
+      def push(code)
         @stack << code
       end
 
-      def prepend code
+      def prepend(code)
         @prepends << code
       end
     end

data/lib/rblade/helpers/style_manager.rb

@@ -2,7 +2,7 @@
 
 module RBlade
   class StyleManager
-    def initialize styles
+    def initialize(styles)
       if styles.is_a? String
         @styles = styles.strip
         unless @styles == "" || @styles.end_with?(";")