rblade 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d9ff80cf4efc20f03172676c57e11c4fe325d5ce304cf855416a4b6d119a654a
+  data.tar.gz: 7283baf017d3b28a4609160551bc265f27355bb501d2f42a9303fe1bb825e837
+SHA512:
+  metadata.gz: dce7d4c704f87acab8e1b2d9999acca4fd77aa5739845fa82417304e5223d6fed5dc5be5a52dc46fe003546635907346029ddc995656b6773bb63aaba19ab90e
+  data.tar.gz: 9336ac0fdb096d3d6c05992916db5bbb594e965ac4c036e99f86b65dd77062842b42f825979fa3b013b84a35f2d8913c3ef6a43a0ec3163cc2c491da521a16bb

data/.gitignore

@@ -0,0 +1,2 @@
+storage
+Gemfile.lock

data/.standard.yml

@@ -0,0 +1,3 @@
+ignore:
+  - storage/**/*
+  

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Rakefile

@@ -0,0 +1,6 @@
+require "minitest/test_task"
+require "standard/rake"
+
+Minitest::TestTask.create
+
+task default: "test"

data/do

@@ -0,0 +1,94 @@
+#!/bin/bash
+set -e
+
+if [ -z "$DOCKER_COMPOSE_COMMAND" ]
+then
+    DOCKER_COMPOSE_COMMAND="docker compose"
+fi
+
+if [ -z "$1" ]
+then
+    echo "Usage:"
+    echo "./do run [command] - run a command"
+    exit 1
+fi
+
+if [ "$1" == "build" ] || [ "$1" == "b" ]
+then
+    echo Running: ${DOCKER_COMPOSE_COMMAND} build
+    ${DOCKER_COMPOSE_COMMAND} build
+    exit 0
+fi
+
+if [ "$1" == "up" ] || [ "$1" == "u" ]
+then
+    echo Running: ${DOCKER_COMPOSE_COMMAND} up -d --remove-orphans
+    ${DOCKER_COMPOSE_COMMAND} up -d --remove-orphans
+    exit 0
+fi
+
+if [ "$1" == "down" ] || [ "$1" == "d" ]
+then
+    echo Running: ${DOCKER_COMPOSE_COMMAND} down "${@:2}"
+    ${DOCKER_COMPOSE_COMMAND} down "${@:2}"
+    exit 0
+fi
+
+if [ "$1" == "restart" ] || [ "$1" == "rs" ]
+then
+    echo Running: ${DOCKER_COMPOSE_COMMAND} restart "${@:2}"
+    ${DOCKER_COMPOSE_COMMAND} restart "${@:2}"
+    exit 0
+fi
+
+if [ "$1" == "run" ] || [ "$1" == "r" ]
+then
+    echo Running: ${DOCKER_COMPOSE_COMMAND} run blade ${@:2}
+    ${DOCKER_COMPOSE_COMMAND} run blade "${@:2}"
+    exit 0
+fi
+
+if [ "$1" == "rake" ] || [ "$1" == "rk" ]
+then
+    echo Running: ${DOCKER_COMPOSE_COMMAND} run blade rake ${@:2}
+    ${DOCKER_COMPOSE_COMMAND} run blade rake "${@:2}"
+    exit 0
+fi
+
+if [ "$1" == "cs" ] || [ "$1" == "c" ]
+then
+    echo Running: ${DOCKER_COMPOSE_COMMAND} run blade rake standard "${@:2}"
+    ${DOCKER_COMPOSE_COMMAND} run blade rake standard "${@:2}"
+    exit 0
+fi
+
+if [ "$1" == "cs:fix" ]
+then
+    echo Running: ${DOCKER_COMPOSE_COMMAND} run blade rake standard:fix "${@:2}"
+    ${DOCKER_COMPOSE_COMMAND} run blade rake standard:fix "${@:2}"
+    exit 0
+fi
+
+if [ "$1" == "test" ] || [ "$1" == "t" ]
+then
+    echo Running: ${DOCKER_COMPOSE_COMMAND} run blade rake test "${@:2}"
+    ${DOCKER_COMPOSE_COMMAND} run blade rake test "${@:2}"
+    exit 0
+fi
+
+if [ "$1" == "l" ] || [ "$1" == "log" ] || [ "$1" == "logs" ]
+then
+    echo Running: ${DOCKER_COMPOSE_COMMAND} logs "${@:2}"
+    ${DOCKER_COMPOSE_COMMAND} logs "${@:2}"
+    exit 0
+fi
+
+if [ "$1" == "ps" ]
+then
+    echo Running: ${DOCKER_COMPOSE_COMMAND} ps "${@:2}"
+    ${DOCKER_COMPOSE_COMMAND} ps "${@:2}"
+    exit 0
+fi
+
+echo Running: ${DOCKER_COMPOSE_COMMAND} "${@:1}"
+${DOCKER_COMPOSE_COMMAND} "${@:1}"

data/docker-compose.yml

@@ -0,0 +1,7 @@
+services:
+  blade:
+    image: ruby:3.3.4
+    working_dir: /var/source
+    volumes:
+      - .:/var/source
+      - ./storage/bundle_cache:/usr/local/bundle

data/lib/rblade/compiler/compiles_comments.rb

@@ -0,0 +1,12 @@
+module RBlade
+  class CompilesComments
+    def compile!(tokens)
+      tokens.each do |token|
+        next if token.type != :unprocessed
+
+        token.value.gsub!(/\{\{--.*?--\}\}/m, "")
+        token.value.gsub!(/<%#.*?%>/m, "")
+      end
+    end
+  end
+end

data/lib/rblade/compiler/compiles_components.rb

@@ -0,0 +1,75 @@
+require "rblade/component_store"
+
+module RBlade
+  class CompilesComponents
+    def compile!(tokens)
+      tokens.each do |token|
+        if [:component, :component_start, :component_end].none? token.type
+          next
+        end
+
+        token.value = if token.type == :component_start
+          compile_token_start token
+        elsif token.type == :component_end
+          compile_token_end token
+        else
+          compile_token_start(token) + compile_token_end(token)
+        end
+      end
+    end
+
+    private
+
+    def compile_token_start token
+      attributes = compile_attributes token
+      "def _component(attributes={#{attributes[:arguments].join(",")}});#{attributes[:assignments].join}_out='';"
+    end
+
+    def compile_token_end token
+      code = "slot=_out;_out='';_stacks=[];"
+      code << ComponentStore.fetchComponent(token.value[:name])
+      code << "RBlade::StackManager.get(_stacks) + _out;end;_out<<_component();"
+
+      code
+    end
+
+    def compile_attributes token
+      attribute_arguments = []
+      attribute_assignments = []
+
+      token.value[:attributes].each do |attribute|
+        if attribute[:type] == "class" || attribute[:type] == "style"
+          attribute_arguments.push "'#{attribute[:type]}': #{attribute[:value]}'"
+
+          next
+        end
+
+        if attribute[:type] == "string"
+          attribute_arguments.push "'#{attribute[:name]}': '#{RBlade.escape_quotes(attribute[:value])}'"
+        end
+
+        if attribute[:type] == "ruby"
+          attribute_arguments.push "'#{attribute[:name]}': (#{attribute[:value]})'"
+        end
+
+        if attribute[:type] == "pass_through"
+          attribute_arguments.push "#{attribute[:name]}:"
+        end
+
+        if attribute[:type] == "empty"
+          attribute_arguments.push "'#{attribute[:name]}': true"
+        end
+
+        variable_name = attribute[:name]&.tr("-", "_")
+        if !variable_name.nil? && variable_name.match(/^[A-Za-z_][A-Za-z0-9_]*$/)
+          keywords = %w[__FILE__ __LINE__ alias and begin BEGIN break case class def defined? do else elsif end END ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield attributes _out slot]
+          next if keywords.include? variable_name
+
+          attribute_assignments.push "#{variable_name} = attributes[:'#{attribute[:name]}'];"
+        end
+      end
+
+      {arguments: attribute_arguments, assignments: attribute_assignments}
+    end
+  end
+end

data/lib/rblade/compiler/compiles_echos.rb

@@ -0,0 +1,59 @@
+module RBlade
+  class CompilesEchos
+    def compile!(tokens)
+      compile_regular_echos!(tokens)
+      compile_unsafe_echos!(tokens)
+    end
+
+    private
+
+    def compile_regular_echos!(tokens)
+      compile_echos! tokens, "{{", "}}", "h"
+      compile_echos! tokens, "<%=", "%>", "h"
+    end
+
+    def compile_unsafe_echos!(tokens)
+      compile_echos! tokens, "{!!", "!!}"
+    end
+
+    def compile_echos!(tokens, start_token, end_token, wrapper_function = nil)
+      tokens.map! do |token|
+        next(token) if token.type != :unprocessed
+
+        start_token_escaped = Regexp.escape start_token
+        end_token_escaped = Regexp.escape end_token
+        segments = token.value.split(/(?:(@)(#{start_token_escaped}.+?#{end_token_escaped})|(#{start_token_escaped})\s*(.+?)\s*(#{end_token_escaped}))/m)
+
+        i = 0
+        while i < segments.count
+          if segments[i] == "@"
+            segments.delete_at i
+            segments[i] = Token.new(type: :raw_text, value: segments[i])
+
+            i += 1
+          elsif segments[i] == start_token
+            segments.delete_at i
+            segments.delete_at i + 1
+            segment_value = "_out<<"
+            # Special case for slot - we want this to be able to output HTML
+            if !wrapper_function.nil? && segments[i] != "slot"
+              segment_value <<= wrapper_function
+            end
+            segment_value <<= "(" + segments[i] + ");"
+            segments[i] = Token.new(:echo, segment_value)
+
+            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
+  end
+end

data/lib/rblade/compiler/compiles_ruby.rb

@@ -0,0 +1,57 @@
+module RBlade
+  class CompilesRuby
+    def compile!(tokens)
+      tokens.map! do |token|
+        next(token) if token.type != :unprocessed
+
+        segments = token.value.split(/
+          # @ escapes blade style tags
+          (@)(@ruby.+?@endruby)
+          |
+          # <%% and %%> are escape ERB style tags
+          (<%%)(.+?)(%%>)
+          |
+          (?:^|[\b\s])(@ruby)\s+(.+?)[\s;]*(@endruby)(?:$|[\b\s])
+          |
+          (<%)\s+(.+?)[\s;]*(%>)
+        /xm)
+
+        i = 0
+        while i < segments.count
+          if segments[i] == "@"
+            segments.delete_at i
+            segments[i] = Token.new(type: :raw_text, value: segments[i])
+
+            i += 1
+          elsif segments[i] == "<%%"
+            segments.delete_at i
+            segments.delete_at i + 1
+            segments[i] = Token.new(type: :raw_text, value: "<%#{segments[i]}%>")
+
+            i += 1
+          elsif segments[i] == "@ruby" || segments[i] == "<%"
+            segments.delete_at i
+            segments.delete_at i + 1
+
+            segments[i].strip!
+            if segments[i][-1] != ";"
+              segments[i] << ";"
+            end
+
+            segments[i] = Token.new(type: :php, value: segments[i])
+
+            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
+  end
+end

data/lib/rblade/compiler/compiles_statements.rb

@@ -0,0 +1,103 @@
+require "rblade/compiler/statements/compiles_conditionals"
+require "rblade/compiler/statements/compiles_inline_ruby"
+require "rblade/compiler/statements/compiles_loops"
+require "rblade/compiler/statements/compiles_stacks"
+
+module RBlade
+  class CompilesStatements
+    def compile!(tokens)
+      token_index = 0
+      while token_index < tokens.count
+        token = tokens[token_index]
+        if token.type != :statement
+          token_index += 1
+          next
+        end
+
+        name = token.value[:name]
+        arguments = token.value[:arguments]
+        handler = getHandler(name)
+
+        handler_arguments = []
+        handler.parameters.each do |parameter|
+          case parameter.last
+          when :args
+            handler_arguments.push arguments
+          when :tokens
+            handler_arguments.push tokens
+          when :token_index
+            handler_arguments.push token_index
+          end
+        end
+
+        token.value = handler.call(*handler_arguments)
+        token_index += 1
+      end
+    end
+
+    def compileEnd
+      "end;"
+    end
+
+    private
+
+    def getHandler(name)
+      handler_class, handler_method = @@statement_handlers[name]
+
+      if !handler_class&.method_defined?(handler_method)
+        raise StandardError.new "Unhandled statement: @#{name}"
+      end
+
+      if handler_class == CompilesStatements
+        @@handler_instances[handler_class] = self
+      else
+        @@handler_instances[handler_class] ||= handler_class.new
+      end
+
+      @@handler_instances[handler_class].method(handler_method)
+    end
+
+    @@handler_instances = {}
+
+    @@statement_handlers = {
+      "break" => [CompilesLoops, :compileBreak],
+      "breakif" => [CompilesLoops, :compileBreakIf],
+      "case" => [CompilesConditionals, :compileCase],
+      "checked" => [CompilesConditionals, :compileChecked],
+      "disabled" => [CompilesConditionals, :compileDisabled],
+      "else" => [CompilesConditionals, :compileElse],
+      "elsif" => [CompilesConditionals, :compileElsif],
+      "each" => [CompilesLoops, :compileEach],
+      "eachelse" => [CompilesLoops, :compileEachElse],
+      "empty" => [CompilesLoops, :compileEmpty],
+      "end" => [CompilesStatements, :compileEnd],
+      "endcase" => [CompilesStatements, :compileEnd],
+      "endeach" => [CompilesStatements, :compileEnd],
+      "endeachelse" => [CompilesStatements, :compileEnd],
+      "endfor" => [CompilesStatements, :compileEnd],
+      "endforelse" => [CompilesStatements, :compileEnd],
+      "endif" => [CompilesStatements, :compileEnd],
+      "endprepend" => [CompilesStacks, :compileEndPrepend],
+      "endpush" => [CompilesStacks, :compileEndPush],
+      "endunless" => [CompilesStatements, :compileEnd],
+      "enduntil" => [CompilesStatements, :compileEnd],
+      "endwhile" => [CompilesStatements, :compileEnd],
+      "for" => [CompilesLoops, :compileFor],
+      "forelse" => [CompilesLoops, :compileForElse],
+      "if" => [CompilesConditionals, :compileIf],
+      "next" => [CompilesLoops, :compileNext],
+      "nextif" => [CompilesLoops, :compileNextIf],
+      "prepend" => [CompilesStacks, :compilePrepend],
+      "push" => [CompilesStacks, :compilePush],
+      "readonly" => [CompilesConditionals, :compileReadonly],
+      "required" => [CompilesConditionals, :compileRequired],
+      "ruby" => [CompilesInlineRuby, :compile],
+      "selected" => [CompilesConditionals, :compileSelected],
+      "stack" => [CompilesStacks, :compileStack],
+      "unless" => [CompilesConditionals, :compileUnless],
+      "until" => [CompilesLoops, :compileUntil],
+      "when" => [CompilesConditionals, :compileWhen],
+      "while" => [CompilesLoops, :compileWhile]
+    }
+  end
+end

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

@@ -0,0 +1,93 @@
+module RBlade
+  class CompilesStatements
+    class CompilesConditionals
+      def compileIf args
+        if args&.count != 1
+          raise StandardError.new "If statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        "if #{args[0]};"
+      end
+
+      def compileElsif args
+        if args&.count != 1
+          raise StandardError.new "Elsif statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        "elsif #{args[0]};"
+      end
+
+      def compileElse args
+        if !args.nil?
+          raise StandardError.new "Else statement: wrong number of arguments (given #{args&.count || 0}, expecting 0)"
+        end
+
+        "else;"
+      end
+
+      def compileUnless args
+        if args&.count != 1
+          raise StandardError.new "Unless statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        "unless #{args[0]};"
+      end
+
+      def compileCase args
+        if args&.count != 1
+          raise StandardError.new "Case statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        "case #{args[0]};"
+      end
+
+      def compileWhen args
+        if args.nil? || args.count == 0
+          raise StandardError.new "When statement: wrong number of arguments (given #{args&.count || 0}, expecting at least 1)"
+        end
+
+        "when #{args.join ","};"
+      end
+
+      def compileChecked args
+        if args&.count != 1
+          raise StandardError.new "Checked statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        "if #{args[0]};_out<<'checked';end;"
+      end
+
+      def compileDisabled args
+        if args&.count != 1
+          raise StandardError.new "Disabled statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        "if #{args[0]};_out<<'disabled';end;"
+      end
+
+      def compileReadonly args
+        if args&.count != 1
+          raise StandardError.new "Readonly statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        "if #{args[0]};_out<<'readonly';end;"
+      end
+
+      def compileRequired args
+        if args&.count != 1
+          raise StandardError.new "Required statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        "if #{args[0]};_out<<'required';end;"
+      end
+
+      def compileSelected args
+        if args&.count != 1
+          raise StandardError.new "Selected statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        "if #{args[0]};_out<<'selected';end;"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module RBlade
+  class CompilesStatements
+    class CompilesInlineRuby
+      def compile args
+        if args&.count != 1
+          raise StandardError.new "Ruby statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        arg = args[0].strip
+        if arg[-1] != ";"
+          arg << ";"
+        end
+        arg
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+module RBlade
+  class CompilesStatements
+    class CompilesLoops
+      def initialize
+        @loop_else_counter = 0
+      end
+
+      def compileBreak args
+        if !args.nil?
+          raise StandardError.new "Break statement: wrong number of arguments (given #{args&.count}, expecting 0)"
+        end
+
+        "break;"
+      end
+
+      def compileBreakIf args
+        if args&.count != 1
+          raise StandardError.new "Break statement: wrong number of arguments (given #{args&.count}, expecting 1)"
+        end
+
+        "if #{args[0]};break;end;"
+      end
+
+      def compileEach args
+        if args&.count != 1
+          raise StandardError.new "Each statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        variables, collection = args[0].split(" in ")
+
+        "#{collection}.each do |#{variables}|;"
+      end
+
+      def compileEachElse args
+        if args&.count != 1
+          raise StandardError.new "Each else statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+        @loop_else_counter += 1
+
+        variables, collection = args[0].split(" in ")
+
+        "_looped_#{@loop_else_counter}=true;#{collection}.each do |#{variables}|;_looped_#{@loop_else_counter}=false;"
+      end
+
+      def compileFor args
+        if args&.count != 1
+          raise StandardError.new "For statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        "for #{args[0]};"
+      end
+
+      def compileForElse args
+        if args&.count != 1
+          raise StandardError.new "For else statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+        @loop_else_counter += 1
+
+        "_looped_#{@loop_else_counter}=true;for #{args[0]};_looped_#{@loop_else_counter}=false;"
+      end
+
+      def compileEmpty
+        @loop_else_counter -= 1
+
+        "end;if _looped_#{@loop_else_counter + 1};"
+      end
+
+      def compileNext args
+        if args&.count&.> 1
+          raise StandardError.new "For statement: wrong number of arguments (given #{args&.count || 0}, expecting 0 or 1)"
+        end
+
+        if args.nil?
+          "next;"
+        else
+          "next #{args[0]};"
+        end
+      end
+
+      def compileNextIf args
+        if args.nil? || args.count > 2
+          raise StandardError.new "For statement: wrong number of arguments (given #{args&.count || 0}, expecting 1 or 2)"
+        end
+
+        if args.count == 1
+          "if #{args[0]};next;end;"
+        else
+          "if #{args[0]};next #{args[1]};end;"
+        end
+      end
+
+      def compileUntil args
+        if args&.count != 1
+          raise StandardError.new "Until statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        "until #{args[0]};"
+      end
+
+      def compileWhile args
+        if args&.count != 1
+          raise StandardError.new "While statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        "while #{args[0]};"
+      end
+    end
+  end
+end