rblade 0.1.0

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

@@ -0,0 +1,65 @@
+module RBlade
+  class CompilesStatements
+    class CompilesStacks
+      def initialize
+        @push_counter = 0
+      end
+
+      def compileStack args
+        if args&.count != 1
+          raise StandardError.new "Stack statement: wrong number of arguments (given #{args&.count}, expecting 1)"
+        end
+
+        "RBlade::StackManager.initialize(#{args[0]}, _out);_stacks.push(#{args[0]});_out = '';"
+      end
+
+      def compilePrepend args
+        if args.nil? || args.count > 2
+          raise StandardError.new "Prepend statement: wrong number of arguments (given #{args&.count}, expecting 1 or 2)"
+        end
+
+        if args.count == 2
+          "RBlade::StackManager.prepend(#{args[0]}, #{args[1]});"
+        else
+          @push_counter += 1
+
+          "_push_#{@push_counter}_name=#{args[0]};_push_#{@push_counter}_buffer=_out;_out='';"
+        end
+      end
+
+      def compileEndPrepend args
+        if !args.nil?
+          raise StandardError.new "End prepend statement: wrong number of arguments (given #{args&.count}, expecting 0)"
+        end
+
+        @push_counter -= 1
+
+        "RBlade::StackManager.prepend(_push_#{@push_counter + 1}_name, _out);_out=_push_#{@push_counter + 1}_buffer;"
+      end
+
+      def compilePush args
+        if args.nil? || args.count > 2
+          raise StandardError.new "Push statement: wrong number of arguments (given #{args&.count}, expecting 1 or 2)"
+        end
+
+        if args.count == 2
+          "RBlade::StackManager.push(#{args[0]}, #{args[1]});"
+        else
+          @push_counter += 1
+
+          "_push_#{@push_counter}_name=#{args[0]};_push_#{@push_counter}_buffer=_out;_out='';"
+        end
+      end
+
+      def compileEndPush args
+        if !args.nil?
+          raise StandardError.new "End push statement: wrong number of arguments (given #{args&.count}, expecting 0)"
+        end
+
+        @push_counter -= 1
+
+        "RBlade::StackManager.push(_push_#{@push_counter + 1}_name, _out);_out=_push_#{@push_counter + 1}_buffer;"
+      end
+    end
+  end
+end

data/lib/rblade/compiler/tokenizes_components.rb

@@ -0,0 +1,187 @@
+require "ripper"
+
+module RBlade
+  class TokenizesComponents
+    def tokenize!(tokens)
+      tokens.map! do |token|
+        next(token) if token.type != :unprocessed
+
+        segments = tokenizeComponentOpeningTags token.value
+
+        i = 0
+        while i < segments.count
+          if segments[i] == "</" && segments[i + 1]&.match(/x[-:]/)
+            segments[i] = Token.new(type: :component_end, value: {name: segments[i + 1][2..]})
+
+            segments.delete_at i + 1
+            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
+
+            attributes = processAttributes raw_attributes
+
+            if raw_attributes.nil?
+              segments.delete_at i + 1
+            else
+              while segments[i + 1] != ">" && segments[i + 1] != "/>"
+                segments.delete_at i + 1
+              end
+            end
+
+            token_type = (segments[i + 1] == "/>") ? :component : :component_start
+            segments[i] = Token.new(type: token_type, value: {name:, attributes:})
+            segments.delete_at i + 1
+
+            i += 1
+          elsif !segments[i].nil? && segments[i] != ""
+            segments[i] = Token.new(type: :unprocessed, value: segments[i])
+
+            i += 1
+          else
+            segments.delete_at i
+          end
+        end
+
+        segments
+      end.flatten!
+    end
+
+    private
+
+    def processAttributes raw_attributes
+      attributes = []
+      i = 0
+      while i < raw_attributes.count
+        name = raw_attributes[i]
+        if name == "@class" || name == "@style"
+          attributes.push({type: name[1..], value: raw_attributes[i + 1][1..-2]})
+          i += 2
+        elsif name[0..1] == "{{"
+          attributes.push({type: "attributes", value: raw_attributes[i + 1][2..-2]})
+          i += 1
+        else
+          attribute = {name:}
+
+          if raw_attributes[i + 1] == "="
+            attribute[:value] = raw_attributes[i + 2]
+            i += 3
+          else
+            i += 1
+          end
+
+          # The "::" at the start of attributes is used to escape attribute names beginning with ":"
+          if name[0..1] == "::"
+            attribute[:type] = "string"
+            attribute[:name].delete_prefix! ":"
+            attributes.push(attribute)
+            next
+          end
+
+          if name[0] == ":"
+            attribute[:type] = attribute[:value].nil? ? "pass_through" : "ruby"
+            attribute[:name].delete_prefix! ":"
+            attributes.push(attribute)
+            next
+          end
+
+          attribute[:type] = if attribute[:value].nil?
+            "empty"
+          else
+            "string"
+          end
+          attributes.push(attribute)
+        end
+      end
+
+      attributes
+    end
+
+    def tokenizeComponentOpeningTags value
+      value.split(%r/
+        # Opening and self-closing tags
+        (?:
+          (<)
+            \s*
+            (x[-\:][\w\-\:\.]*)
+            ((?:
+              \s+
+              (?:
+                (?:
+                  @class(\( (?: (?>[^()]+) | \g<-1> )* \))
+                )
+                |
+                (?:
+                  @style(\( (?: (?>[^()]+)| \g<-1> )* \))
+                )
+                |
+                (
+                  \{\{\s*attributes(?:[^}]+?)?\s*\}\}
+                )
+                |
+                (?:
+                  [\w\-:.@%]+
+                  (?:
+                    =
+                    (?:
+                      "[^"]*"
+                      |
+                      '[^\']*'
+                      |
+                      [^'"=<>\s]+
+                    )
+                  )?
+                )
+              )
+            )*)
+            \s*
+            (?<![=\-])
+          (\/?>)
+        )
+        |
+        # Closing tags
+        (?:
+          (<\/)
+            \s*
+            (x[-\:][\w\-\:\.]*)
+            \s*
+          >
+        )
+      /x)
+    end
+
+    def tokenizeAttributes segment
+      segment.scan(%r/
+        (?<=\s|^)
+        (?:
+          (?:
+            (@class)(\( (?: (?>[^()]+) | \g<-1> )* \))
+          )
+          |
+          (?:
+            (@style)(\( (?: (?>[^()]+)| \g<-1> )* \))
+          )
+          |
+          (?:
+            (\{\{)\s*attributes([^}]+?)?\s*(\}\})
+          )
+          |
+          (?:
+            ([\w\-:.@%]+)
+            (?:
+              (=)
+              (?:
+                "([^"]*)"
+                |
+                '([^\']*)'
+                |
+                ([^'"=<>\s]+)
+              )
+            )?
+          )
+        )
+        (?=\s|$)
+      /x).flatten.compact
+    end
+  end
+end

data/lib/rblade/compiler/tokenizes_statements.rb

@@ -0,0 +1,171 @@
+require "ripper"
+
+module RBlade
+  class TokenizesStatements
+    def tokenize!(tokens)
+      tokens.map! do |token|
+        next(token) if token.type != :unprocessed
+
+        segments = token.value.split(/
+          (?:^|[\b\s])
+          (@@?)
+          (\w+(?:::\w+)?)
+          (?:[ \t]*
+            (\(.*?\))
+          )?/mx)
+
+        parseSegments! segments
+      end.flatten!
+    end
+
+    private
+
+    def parseSegments! segments
+      i = 0
+      while i < segments.count
+        segment = segments[i]
+
+        # The @ symbol is used to escape blade directives so we return it unprocessed
+        if segment == "@@"
+          segments[i] = Token.new(type: :unprocessed, value: segment[1..] + segments[i + 1])
+          segments.delete_at i + 1
+
+          i += 1
+        elsif segment == "@"
+          tokenizeStatement! segments, i
+
+          # Remove trailing whitespace if it exists, but don't double dip when another statement follows
+          if !segments[i + 1].nil? && segments[i + 1].match(/^\s/) && (segments[i + 1].length > 1 || segments[i + 2].nil?)
+            segments[i + 1].slice! 0, 1
+          end
+
+          i += 1
+        elsif !segments[i].nil? && segments[i] != ""
+          segments[i] = Token.new(type: :unprocessed, value: segments[i])
+
+          i += 1
+        else
+          segments.delete_at i
+        end
+      end
+
+      segments
+    end
+
+    def tokenizeStatement!(segments, i)
+      statement_data = {name: segments[i + 1]}
+      segments.delete_at i + 1
+
+      if segments.count > i + 1 && segments[i + 1][0] == "("
+        arguments = tokenizeArguments! segments, i + 1
+
+        if !arguments.nil?
+          statement_data[:arguments] = arguments
+        end
+      end
+
+      segments[i] = Token.new(type: :statement, value: statement_data)
+    end
+
+    def tokenizeArguments!(segments, segment_index)
+      success = expandSegmentToEndParenthesis! 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?
+          segments[segment_index] <<= segments[segment_index + 1]
+          segments.delete_at segment_index + 1
+        end
+
+        return nil
+      end
+
+      arguments = extractArguments segments[segment_index]
+      segments.delete_at segment_index
+
+      arguments
+    end
+
+    def expandSegmentToEndParenthesis! segments, segment_index
+      parentheses_difference = 0
+      tokens = nil
+
+      loop do
+        tokens = Ripper.lex(segments[segment_index]).map { |token| token[1] }
+        parentheses_difference = tokens.count(:on_lparen) - tokens.count(:on_rparen)
+
+        break if parentheses_difference.zero? || segments[segment_index + 1].nil?
+
+        index = segments[segment_index + 1].each_char.find_index { |c| c == ")" && (parentheses_difference -= 1).zero? }
+
+        if index.nil?
+          segments[segment_index] << segments[segment_index + 1]
+          segments.delete_at segment_index + 1
+        else
+          segments[segment_index] << segments[segment_index + 1].slice!(0..index)
+        end
+
+        break if segments[segment_index + 1].nil?
+      end
+
+      parentheses_difference.zero?
+    end
+
+    def extractArguments(segment)
+      # Add a comma to the end to delimit the end of the last argument
+      segment = segment[1..-2] + ","
+      segment_lines = segment.lines
+
+      tokens = Ripper.lex segment
+      arguments = []
+
+      current_line = 1
+      current_index = 0
+      bracket_count = {
+        "[]": 0,
+        "{}": 0,
+        "()": 0
+      }
+      tokens.each do |token|
+        case token[1]
+        when :on_lbracket
+          bracket_count[:[]] += 1
+        when :on_rbracket
+          bracket_count[:[]] -= 1
+        when :on_lbrace
+          bracket_count[:"{}"] += 1
+        when :on_rbrace
+          bracket_count[:"{}"] -= 1
+        when :on_lparen
+          bracket_count[:"()"] += 1
+        when :on_rparen
+          bracket_count[:"()"] -= 1
+        when :on_comma
+          if bracket_count[:[]] != 0 || bracket_count[:"{}"] != 0 || bracket_count[:"()"] != 0
+            next
+          end
+
+          argument = ""
+
+          # Concatenate all lines up to this token's line, including the tail end of the current line
+          if token[0][0] != current_line
+            (current_line...token[0][0]).each do |i|
+              argument << (segment_lines[i - 1].slice(current_index..-1) || "")
+              current_index = 0
+            end
+            current_line = token[0][0]
+          end
+          argument <<= segment_lines[current_line - 1].slice(current_index...token[0][1])
+
+          arguments.push argument.strip
+
+          current_index = token[0][1] + 1
+        end
+      end
+
+      return nil if arguments.count == 1 && arguments.first == ""
+
+      arguments
+    end
+  end
+end

data/lib/rblade/compiler.rb

@@ -0,0 +1,60 @@
+require "rblade/compiler/compiles_comments"
+require "rblade/compiler/compiles_components"
+require "rblade/compiler/compiles_echos"
+require "rblade/compiler/compiles_ruby"
+require "rblade/compiler/compiles_statements"
+require "rblade/compiler/tokenizes_components"
+require "rblade/compiler/tokenizes_statements"
+
+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')
+  end
+
+  class Compiler
+    def self.compileString(string_template)
+      tokens = [Token.new(:unprocessed, string_template)]
+
+      CompilesComments.new.compile! tokens
+      CompilesEchos.new.compile! tokens
+      CompilesRuby.new.compile! tokens
+      TokenizesComponents.new.tokenize! tokens
+      TokenizesStatements.new.tokenize! tokens
+      CompilesStatements.new.compile! tokens
+      CompilesComponents.new.compile! tokens
+
+      compileTokens tokens
+    end
+
+    def self.compileAttributeString(string_template)
+      tokens = [Token.new(:unprocessed, string_template)]
+
+      CompilesRuby.compile! tokens
+      CompilesComments.compile!(tokens)
+      CompilesEchos.compile!(tokens)
+
+      compileTokens tokens
+    end
+
+    def self.compileTokens tokens
+      output = ""
+
+      tokens.each do |token, cake|
+        if token.type == :unprocessed || token.type == :raw_text
+          output << "_out<<'" << RBlade.escape_quotes(token.value) << "';"
+        else
+          output << token.value
+        end
+      end
+
+      output
+    end
+  end
+end

data/lib/rblade/component_store.rb

@@ -0,0 +1,42 @@
+require "rblade/compiler"
+
+module RBlade
+  FILE_EXTENSIONS = [".blade", ".html.blade"]
+
+  class ComponentStore
+    def self.fetchComponent name
+      namespace = nil
+      path = name
+
+      if name.match '::'
+        namespace, path = name.split('::')
+      end
+
+      path.gsub! '.', '/'
+
+      @@templatePaths[namespace]&.each do |base_path|
+        FILE_EXTENSIONS.each do |extension|
+          if File.exist? base_path + path + extension
+            return RBlade::Compiler.compileString File.read(base_path + path + extension)
+          end
+        end
+      end
+
+      raise StandardError.new "Unknown component #{name}"
+    end
+
+    def self.add_path path, namespace = nil
+      path = path.to_s
+      if !path.end_with? "/"
+        path = path + "/"
+      end
+
+      @@templatePaths[namespace] ||= []
+      @@templatePaths[namespace] << path
+    end
+
+    private
+
+    @@templatePaths = {}
+  end
+end

data/lib/rblade/helpers/stack_manager.rb

@@ -0,0 +1,58 @@
+module RBlade
+  class StackManager
+    def self.initialize stack_name, before_stack
+      @@stacks[stack_name] ||= Stack.new
+      @@stacks[stack_name].set_before_stack before_stack
+    end
+
+    def self.clear
+      @@stacks = {}
+    end
+
+    def self.push stack_name, code
+      @@stacks[stack_name] ||= Stack.new
+      @@stacks[stack_name].push code.to_s
+    end
+
+    def self.prepend stack_name, code
+      @@stacks[stack_name] ||= Stack.new
+      @@stacks[stack_name].prepend code.to_s
+    end
+
+    def self.get(stacks)
+      stacks.map do |name|
+        out = @@stacks[name].to_s
+        @@stacks.delete name
+
+        out
+      end.join
+    end
+
+    private
+
+    @@stacks = {}
+
+    class Stack
+      def initialize
+        @prepends = ""
+        @stack = ""
+      end
+
+      def set_before_stack before_stack
+        @before_stack = before_stack
+      end
+
+      def to_s
+        "#{@before_stack}#{@prepends}#{@stack}"
+      end
+
+      def push code
+        @stack << code
+      end
+
+      def prepend code
+        @prepends << code
+      end
+    end
+  end
+end

data/lib/rblade/rails_template.rb

@@ -0,0 +1,14 @@
+require "rails"
+require "rblade/compiler"
+require "rblade/helpers/stack_manager"
+
+module RBlade
+  class RailsTemplate
+    def call(template, source = nil)
+      RBlade::StackManager.clear
+      setup = "foo = 'FOO';bar = 'BAR';_out='';_stacks=[];"
+      setdown = "RBlade::StackManager.get(_stacks) + _out"
+      setup + RBlade::Compiler.compileString(source || template.source) + setdown
+    end
+  end
+end

data/lib/rblade/railtie.rb

@@ -0,0 +1,14 @@
+require "rails"
+require "rblade/rails_template"
+require "rblade/component_store"
+
+module RBlade
+  class Railtie < ::Rails::Railtie
+    initializer :rblade, before: :load_config_initializers do |app|
+      ActionView::Template.register_template_handler(:blade, RBlade::RailsTemplate.new)
+
+      RBlade::ComponentStore.add_path(Rails.root.join("app", "views", "components"))
+      RBlade::ComponentStore.add_path(Rails.root.join("app", "views", "layouts"), "layout")
+    end
+  end
+end

data/lib/rblade.rb

@@ -0,0 +1,2 @@
+require "rails"
+require "rblade/railtie"

data/rblade.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name = "rblade"
+  s.version = "0.1.0"
+  s.summary = "Blade templates for ruby"
+  s.description = "A port of the Laravel blade templating engine to ruby"
+  s.authors = ["Simon J"]
+  s.email = "2857218+mwnciau@users.noreply.github.com"
+  s.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|storage)/}) }
+  s.require_paths = ['lib']
+  s.homepage = "https://rubygems.org/gems/rblade"
+  s.license = "MIT"
+  s.required_ruby_version = ">= 3.0.0"
+
+  s.add_development_dependency "minitest", "~> 5.0"
+  s.add_development_dependency "minitest-reporters", "~> 1.1"
+  s.add_development_dependency "standard", "~> 1.3"
+  s.add_development_dependency "rails", "~> 7.0"
+end