rblade 0.6.1 → 1.0.1

data/REFERENCE.md

@@ -0,0 +1,138 @@
+<a name="quick-reference"></a>
+# Quick Reference
+
+A table below provides a quick overview of RBlade syntax and directives. The [readme](README.md) has a more in depth look at RBlade's capabilities.
+
+| Syntax                                                  | Description                                                                               |
+|:--------------------------------------------------------|:------------------------------------------------------------------------------------------|
+| `{{ RUBY_EXPRESSION }}`<br/>`<%= RUBY_EXPRESSION %>`    | Print the string value of the ruby expression, escaping HTML special characters           |
+| `{!! RUBY_EXPRESSION !!}`<br/>`<%== RUBY_EXPRESSION %>` | Print the string value of the ruby expression, _without_ escaping HTML special characters |
+| `@ruby( RUBY_EXPRESSION )`                              | Execute an inline ruby expression                                                         |
+| `@ruby ... @endRuby`                                    | Execute a block of ruby code                                                              |
+| `{{-- ... --}}`<br/>`<%# ... %>`                        | Comments, removed from the compiled template with no performance cost                     |
+| `@verbatim ... @endVerbatim`                            | Print the given content without parsing RBlade directives                                 |
+
+<a name="quick-reference-components"></a>
+## Components
+
+By default, RBlade will look for components in the `app/views/components` folder. Additionally, components in the `layout` namespace are found in the `app/views/layouts` folder, and components in the `view` namespace are found in the `app/views` folder.
+
+| Syntax                                                   | Description                                                                                                                                |
+|:---------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------|
+| `<x-component.name/>`                                    | Render the component found at `app/views/components/name{.rblade,.html.rblade}` or `app/views/components/name/index{.rblade,.html.rblade}` |
+| `<x-layout::name/>`                                      | Render the "name" component found in the "layout" namespace folder                                                                         |
+| `<x-component.name>...</x-component.name>`               | Render the component with the given slot content                                                                                           |
+| `<x-component.name>...<//>`                              | Short closing tag syntax (note: this bypasses some sanity checking during compilation)                                                     |
+| `<x-name attribute="STRING"/>`                           | Pass a string value to a component                                                                                                         |
+| `<x-name :attribute="RUBY_EXPRESSION"/>`                 | Pass a ruby expression, executed in the local scope, to a component                                                                        |
+| `<x-name :attribute/>`                                   | Pass the `attribute` local variable into a component                                                                                       |
+| `<x-name @class({'bg-red-600': is_error})/>`             | Conditionally pass classes to a component                                                                                                  |
+| `<x-name @style({'bg-red-600': is_error})/>`             | Conditionally pass styles to a component                                                                                                   |
+| `<x-name attribute/>`                                    | Pass an attribute to a component with value `true`                                                                                         |
+| `<x-name {{ attributes }}/>`                             | Pass attributes to a child component                                                                                                       |
+| `@props({header: "Header"})`                             | Remove `header` from the attributes Hash and introduce it as a local variable, using the specified value as a default                      |
+| `@props({header: required})`                             | Remove `header` from the attributes Hash and introduce it as a local variable, raising an error if it is not set                           |
+| `{{ slot }}`                                             | Output the block content passed into the current component                                                                                 |
+| `<x-name><x-slot::header><h1>Header</h1><//>Content<//>` | Pass a named block to a component                                                                                                          |
+| `{{ header }}`                                           | Output the contents of a named block                                                                                                       |
+| `<div {{ header.attributes }}>`                          | Output the attributes passed into a named block                                                                                            |
+
+<a name="quick-reference-attributes"></a>
+## Attributes
+
+The attributes variable is an instance of a class that manages attributes. As well as the methods used in the examples below, you can use any method belonging to the Hash class.
+
+| Syntax                                                                   | Description                                                                                                |
+|:-------------------------------------------------------------------------|:-----------------------------------------------------------------------------------------------------------|
+| `<div {{ attributes }}>`                                                 | Print the contents of attributes as HTML attributes                                                        |
+| `<div {{ attributes.merge({class: "text-black", type: "button"}) }}>`    | Merge in additional attributes, combining the `:class` and `:style`, and setting defaults for other values |
+| `<div {{ attributes.except(['type']) }}>`                                | Output the attributes array excluding the given keys                                                       |
+| `<div {{ attributes.only(['type']) }}>`                                  | Output only the given keys of the attributes array                                                         |
+| `<div {{ attributes.filter { \|key, value\| key.start_with? "on:" } }}>` | Output the attributes for which the block returns true                                                     |
+| `<div @class({'bg-red-600': is_error})>`                                 | Conditionally print classes in an HTML class attribute                                                     |
+| `<div @style({'bg-red-600': is_error})>`                                 | Conditionally print styles in an HTML style attribute                                                      |
+
+<a name="quick-reference-conditions"></a>
+## Conditions
+
+| Syntax                                                                | Description                                                                                                        |
+|:----------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------|
+| `@if( RUBY_EXPRESSION ) ... @endIf`                                   | Compiles to a Ruby if statement                                                                                    |
+| `@if( RUBY_EXPRESSION ) ... @else ... @endIf`                         | Compiles to a Ruby if/else statement                                                                               |
+| `@if( RUBY_EXPRESSION ) ... @elsif( RUBY_EXPRESSION ) ... @endIf`     | Compiles to a Ruby if/elsif statement                                                                              |
+| `@unless( RUBY_EXPRESSION ) ... @endunless`                           | Compiles to a Ruby unless statement                                                                                |
+| `@case( RUBY_EXPRESSION ) @when(1) ... @when(2) ... @else ... @endIf` | Compiles to a Ruby case statement                                                                                  |
+| `@blank?( RUBY_EXPRESSION ) ... @endBlank?`                           | Compiles to a Ruby if statement that calls `blank?` method on the given expression                                 |
+| `@defined?( RUBY_EXPRESSION ) ... @endDefined?`                       | Compiles to a Ruby if statement that calls `defined?` function on the given expression                             |
+| `@empty?( RUBY_EXPRESSION ) ... @endEmpty?`                           | Compiles to a Ruby if statement that calls `empty?` method on the given expression                                 |
+| `@nil?( RUBY_EXPRESSION ) ... @endNil?`                               | Compiles to a Ruby if statement that calls `nil?` method on the given expression                                   |
+| `@present?( RUBY_EXPRESSION ) ... @endPresent?`                       | Compiles to a Ruby if statement that calls `present?` method on the given expression                               |
+| `@env(['development', 'test']) ... @endEnv`                           | Compiles to a Ruby if statement that checks if the current Rails environment matches any of the given environments |
+| `@production ... @endProduction`                                      | Shortcut for `@env('production')`                                                                                  |
+| `@once ... @endOnce`                                                  | Render the given block the first time it appears in the template                                                   |
+| `@once('unique key') ... @endOnce`                                    | Render the given block the first time "unique key" is used in the template                                         |
+
+<a name="quick-reference-loops"></a>
+## Loops
+
+| Syntax                                                | Description                                                                                                |
+|:------------------------------------------------------|:-----------------------------------------------------------------------------------------------------------|
+| `@while( looping ) ... @endWhile`                     | Compiles to a Ruby while statement                                                                         |
+| `@until( finished ) ... @endUntil`                    | Compiles to a Ruby until statement                                                                         |
+| `@for( i in 1..10 ) ... @endFor`                      | Compiles to a Ruby for loop                                                                                |
+| `@each( i in 1..10 ) ... @endEach`                    | Calls `each` on the given collection, with `\|i\|` as the block argument                                   |
+| `@each( key, value in {a: 1} ) ... @endEach`          | Calls `each` on the given Hash, with `\|key, value\|` as the block arguments                               |
+| `@forElse( i in 1..10 ) ... @empty ... @endForElse`   | Compiles to a for loop as above, but the block after `@empty` is printed if the given collection is empty  |
+| `@eachElse( i in 1..10 ) ... @empty ... @endEachElse` | Compiles to a each loop as above, but the block after `@empty` is printed if the given collection is empty |
+| `@break`                                              | Break out of the current loop                                                                              |
+| `@next`                                               | Go to the next iteration in the current loop                                                               |
+| `@break( RUBY_EXPRESSION )`                           | Break out of the current loop if the expression evaluate to true                                           |
+| `@next( RUBY_EXPRESSION )`                            | Go to the next iteration in the current loop if the expression evaluate to true                            |
+
+<a name="quick-reference-forms"></a>
+## Forms
+
+| Syntax                           | Description                                                                                                      |
+|:---------------------------------|:-----------------------------------------------------------------------------------------------------------------|
+| `@old(:email, user[:email])`     | Fetches `:email` from the params Hash, defaulting to the user's email if it doesn't exist                        |
+| `@method('PATCH')`               | Prints a hidden input setting the HTTP request type to the given value using the Rails MethodOverride middleware |
+| `@DELETE`                        | Shortcut for `@method('DELETE')`                                                                                 |
+| `@PATCH`                         | Shortcut for `@method('PATCH')`                                                                                  |
+| `@PUT`                           | Shortcut for `@method('PUT')`                                                                                    |
+| `@checked( RUBY_EXPRESSION )`    | Prints "checked" if the ruby expression evaluates to true                                                        |
+| `@disabled( RUBY_EXPRESSION )`   | Prints "disabled" if the ruby expression evaluates to true                                                       |
+| `@readonly( RUBY_EXPRESSION )`   | Prints "readonly" if the ruby expression evaluates to true                                                       |
+| `@required( RUBY_EXPRESSION )`   | Prints "required" if the ruby expression evaluates to true                                                       |
+| `@selected( RUBY_EXPRESSION )`   | Prints "selected" if the ruby expression evaluates to true                                                       |
+
+<a name="quick-reference-stacks"></a>
+## Stacks
+
+Stacks are a way of rendering content outside of the usual document order. For example, you could define a "sidebar" stack, then you'd be able to add content to that sidebar from anywhere else in the site.
+
+Note that the stack is printed once the current view or component finishes. 
+
+| Syntax                                                      | Description                                                                                 |
+|:------------------------------------------------------------|:--------------------------------------------------------------------------------------------|
+| `@stack('scripts')`                                         | Start a stack with the name 'scripts'. Stacks can be pushed to elsewhere in the code.       |
+| `@push('scripts') ... @endPush`                             | Add block content to the 'scripts' stack                                                    |
+| `@prepend('scripts') ... @endPrepend`                       | Add block content to the start of the 'scripts' stack                                       |
+| `@pushIf(RUBY_EXPRESSION, 'scripts') ... @endPushIf`        | Add block content to the 'scripts' stack if the expression evaluate to true                 |
+| `@prependIf(RUBY_EXPRESSION, 'scripts') ... @endprependIf`  | Add block content to the start of the 'scripts' stack if the expression evaluate to true    |
+| `@pushOnce('scripts') ... @endPushOnce`                     | Add block content to the 'scripts' stack only once                                          |
+| `@prependOnce('scripts') ... @endPrependOnce`               | Add block content to the start of the 'scripts' stack only once                             |
+| `@pushOnce('scripts', 'unique key') ... @endPushOnce`       | Add block content to the 'scripts' stack the first time "unique key" is pushed              |
+| `@prependOnce('scripts', 'unique key') ... @endPrependOnce` | Add block content to the start of the 'scripts' stack the first time "unique key" is pushed |
+
+## Tips
+
+* Except for `@push`, `@prepend` and their variants, all end directives can simply be replaced with `@end` if preferred:
+    -  `@nil?(...) ... @endnil?`
+    -  `@nil?(...) ... @endnil`
+    -  `@nil?(...) ... @end`
+* Except for `@ruby` and `@verbatim`, directives are case insensitive and can contain underscores. The following are identical:
+    - `@pushonce`
+    - `@pushOnce`
+    - `@PushOnce` 
+    - `@push_once` 
+    - `@PUSHONCE` 

data/examples/README.md

@@ -0,0 +1,3 @@
+# RBlade Examples
+
+This folder is structured like a Rails `app/views` folder and contains some examples of RBlade templates. 

data/examples/application/home.rblade

@@ -0,0 +1,23 @@
+@ruby
+# Typically these values would be set in the controller
+banner_image = 'banner.png'
+alert = nil
+@endruby
+<x-layout::app title="Home page">
+  <x-content.alert :alert/>
+  <x-content.alert alert="This is an alert"/>
+  <x-h1 blue>Welcome to the home page!</x-h1>
+
+  <x-p class="mt-2">
+    Lorem ipsum dolor sit amet, consectetur adipisicing elit. Alias amet architecto, at commodi consectetur ipsa itaque magni minus neque nostrum pariatur possimus recusandae sunt! Est explicabo praesentium quidem vero voluptatum!
+  </x-p>
+
+  @if (banner_image)
+    <x-content.hero class="mt-4">
+      <x-slot::heading class="text-blue-600">
+        Beatae placeat porro quibusdam repudiandae sunt?
+      </x-slot::heading>
+      Adipisci blanditiis, dolor dolorem, ea iste laudantium minima natus nesciunt nostrum odio perferendis praesentium quae, similique.
+    </x-content.hero>
+  @endif
+</x-layout::app>

data/examples/components/content/alert.rblade

@@ -0,0 +1,6 @@
+@props({alert: required})
+@shouldRender(alert.present?)
+<p class="py-2 px-3 bg-amber-100 border border-amber-500">
+  @@alert
+  {{ alert }}
+</p>

data/examples/components/content/hero.rblade

@@ -0,0 +1,14 @@
+@props({heading: nil})
+@pushOnce('scripts')
+<script src="/js/hero.js"></script>
+@endPushOnce
+<div class="bg-blue-50 p-16">
+  <div class="max-w-96">
+    @if (heading)
+      <h2 {{ heading.attributes.merge({class: "text-lg font-bold"}) }}>
+        {{ heading }}
+      </h2>
+    @end
+    <p class="mt-4">{{ slot }}</p>
+  </div>
+</div>

data/examples/components/h1.rblade

@@ -0,0 +1,6 @@
+@props({blue: false})
+<h1 {{ attributes.merge({
+    class: "text-xl font-bold #{blue ? 'text-blue-700' : 'text-black'}"
+}) }}>
+  {{ slot }}
+</h1>

data/examples/components/p.rblade

@@ -0,0 +1,14 @@
+<p {{ attributes.merge({
+    class: "
+      text-base font-normal
+      {{--
+        The tailwindcss-unimportant plugin works well with component design:
+        the "-:" prefix allows the consumer of the component to easily override
+        the component classes and extend the component.
+        See: https://www.npmjs.com/package/tailwindcss-unimportant
+      --}}
+      -:mt-1
+    "
+}) }}>
+  {{ slot }}
+</p>

data/examples/layouts/app.rblade

@@ -0,0 +1,16 @@
+@props({title: required})
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="X-UA-Compatible" content="ie=edge">
+    <title>{{ title }}</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    @stack('scripts')
+  </head>
+  <body>
+    <div {{ attributes.merge({class: "max-w-prose mt-8 mx-auto flex flex-col gap-4"}) }}>
+	  {{ slot }}
+  </body>
+</html>

data/lib/rblade/compiler/compiles_components.rb

@@ -51,11 +51,11 @@ module RBlade
 
       namespace = nil
       name = component[:name]
-      if name.match '::'
+      if name.match? "::"
         namespace, name = component[:name].split("::")
       end
 
-      code = if namespace == 'slot'
+      if namespace == "slot"
         compile_slot_end name, component
       else
         compile_component_end component

data/lib/rblade/compiler/{compiles_echos.rb → compiles_prints.rb}

@@ -1,22 +1,23 @@
 module RBlade
-  class CompilesEchos
+  class CompilesPrints
     def compile!(tokens)
-      compile_regular_echos!(tokens)
-      compile_unsafe_echos!(tokens)
+      compile_unsafe_prints!(tokens)
+      compile_regular_prints!(tokens)
     end
 
     private
 
-    def compile_regular_echos!(tokens)
-      compile_echos! tokens, "{{", "}}", "RBlade.e"
-      compile_echos! tokens, "<%=", "%>", "RBlade.e"
+    def compile_regular_prints!(tokens)
+      compile_prints! tokens, "{{", "}}", "RBlade.e"
+      compile_prints! tokens, "<%=", "%>", "RBlade.e"
     end
 
-    def compile_unsafe_echos!(tokens)
-      compile_echos! tokens, "{!!", "!!}"
+    def compile_unsafe_prints!(tokens)
+      compile_prints! tokens, "{!!", "!!}"
+      compile_prints! tokens, "<%==", "%>"
     end
 
-    def compile_echos!(tokens, start_token, end_token, wrapper_function = nil)
+    def compile_prints!(tokens, start_token, end_token, wrapper_function = nil)
       tokens.map! do |token|
         next(token) if token.type != :unprocessed
 
@@ -41,7 +42,7 @@ module RBlade
             else
               "(" + segments[i] + ").to_s;"
             end
-            segments[i] = Token.new(:echo, segment_value)
+            segments[i] = Token.new(:print, segment_value)
 
             i += 1
           elsif !segments[i].nil? && segments[i] != ""

data/lib/rblade/compiler/compiles_statements.rb

@@ -1,10 +1,10 @@
+require "rblade/compiler/statements/compiles_component_helpers"
 require "rblade/compiler/statements/compiles_conditionals"
 require "rblade/compiler/statements/compiles_form"
 require "rblade/compiler/statements/compiles_html_attributes"
 require "rblade/compiler/statements/compiles_inline_ruby"
 require "rblade/compiler/statements/compiles_loops"
 require "rblade/compiler/statements/compiles_once"
-require "rblade/compiler/statements/compiles_props"
 require "rblade/compiler/statements/compiles_stacks"
 
 module RBlade
@@ -71,7 +71,6 @@ module RBlade
     @@statement_handlers = {
       "blank?" => [CompilesConditionals, :compileBlank],
       "break" => [CompilesLoops, :compileBreak],
-      "breakif" => [CompilesLoops, :compileBreakIf],
       "case" => [CompilesConditionals, :compileCase],
       "checked" => [CompilesConditionals, :compileChecked],
       "class" => [CompilesHtmlAttributes, :compileClass],
@@ -97,7 +96,6 @@ module RBlade
       "if" => [CompilesConditionals, :compileIf],
       "method" => [CompilesForm, :compileMethod],
       "next" => [CompilesLoops, :compileNext],
-      "nextif" => [CompilesLoops, :compileNextIf],
       "nil?" => [CompilesConditionals, :compileNil],
       "old" => [CompilesForm, :compileOld],
       "once" => [CompilesOnce, :compileOnce],
@@ -107,7 +105,7 @@ module RBlade
       "prependonce" => [CompilesOnce, :compilePrependOnce],
       "present?" => [CompilesConditionals, :compilePresent],
       "production" => [CompilesConditionals, :compileProduction],
-      "props" => [CompilesProps, :compileProps],
+      "props" => [CompilesComponentHelpers, :compileProps],
       "push" => [CompilesStacks, :compilePush],
       "pushif" => [CompilesStacks, :compilePushIf],
       "pushonce" => [CompilesOnce, :compilePushOnce],
@@ -116,6 +114,7 @@ module RBlade
       "required" => [CompilesConditionals, :compileRequired],
       "ruby" => [CompilesInlineRuby, :compile],
       "selected" => [CompilesConditionals, :compileSelected],
+      "shouldrender" => [CompilesComponentHelpers, :compileShouldRender],
       "stack" => [CompilesStacks, :compileStack],
       "style" => [CompilesHtmlAttributes, :compileStyle],
       "unless" => [CompilesConditionals, :compileUnless],

data/lib/rblade/compiler/statements/{compiles_props.rb → compiles_component_helpers.rb}

@@ -2,23 +2,37 @@ require "rblade/helpers/tokenizer"
 
 module RBlade
   class CompilesStatements
-    class CompilesProps
-      def compileProps args
-        if args.nil?
-          raise StandardError.new "Props statement: wrong number of arguments (given #{args&.count}, expecting 1)"
+    class CompilesComponentHelpers
+      def compileShouldRender args
+        if args&.count != 1
+          raise StandardError.new "Should render statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+        end
+
+        "unless(#{args[0]});return'';end;"
+      end
+
+      def compileProps args, tokens
+        if args&.count != 1
+          raise StandardError.new "Props statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
         end
 
         props = extractProps args[0]
         props.map do |key, value|
           compiled_code = ""
-          if value == "_required"
-            compiled_code << "if !attributes.has?(:'#{RBlade.escape_quotes(key)}');raise \"Props statement: #{key} is not defined\";end;"
+
+          # `_required` is deprecated. Use `required`. To be removed in 2.0.0
+          compiled_code << if value == "_required" || value == "required"
+            "if !attributes.has?(:'#{RBlade.escape_quotes(key)}');raise \"Props statement: #{key} is not defined\";end;"
+          else
+            "attributes.default(:'#{RBlade.escape_quotes(key)}', #{value});"
           end
+
           if isValidVariableName key
-            compiled_code << "#{key}=attributes[:'#{RBlade.escape_quotes(key)}'].nil? ? #{value} : attributes[:'#{RBlade.escape_quotes(key)}'];"
-            compiled_code << "attributes.delete :'#{RBlade.escape_quotes(key)}';"
-          else
-            compiled_code << "attributes.default(:'#{RBlade.escape_quotes(key)}', #{value});"
+            compiled_code << if variableIsSlot key, tokens
+              "#{key}=RBlade::SlotManager.wrap(attributes.delete :'#{RBlade.escape_quotes(key)}');"
+            else
+              "#{key}=attributes.delete :'#{RBlade.escape_quotes(key)}';"
+            end
           end
 
           compiled_code
@@ -75,6 +89,11 @@ module RBlade
 
         true
       end
+
+      # Automatically detect if a variable is a slot by looking for "<var>.attributes"
+      def variableIsSlot name, tokens
+        tokens.any? { |token| token.value.to_s.match "#{name}.attributes" }
+      end
     end
   end
 end

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

@@ -58,8 +58,8 @@ module RBlade
       end
 
       def compileElse args
-        if !args.nil?
-          raise StandardError.new "Else statement: wrong number of arguments (given #{args&.count || 0}, expecting 0)"
+        unless args.nil?
+          raise StandardError.new "Else statement: wrong number of arguments (given #{args.count}, expecting 0)"
         end
 
         "else;"
@@ -82,8 +82,8 @@ module RBlade
       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)"
+        if args.nil?
+          raise StandardError.new "When statement: wrong number of arguments (given 0, expecting at least 1)"
         end
 
         "when #{args.join ","};"
@@ -141,19 +141,11 @@ module RBlade
 
       def compileProduction args
         unless args.nil?
-          raise StandardError.new "Production statement: wrong number of arguments (given #{args.count}, expecting 1)"
+          raise StandardError.new "Production statement: wrong number of arguments (given #{args.count}, expecting 0)"
         end
 
         "if Rails.env.production?;"
       end
-
-      def compileOnce args
-        if args&.count&.> 1
-          raise StandardError.new "Production statement: wrong number of arguments (given #{args.count}, expecting 0 or 1)"
-        end
-
-        args[0].nil? ? "" : args[0]
-      end
     end
   end
 end

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

@@ -3,40 +3,40 @@ module RBlade
     class CompilesForm
       def compileMethod args
         if args&.count != 1
-          raise StandardError.new "Once statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+          raise StandardError.new "Method statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
         end
-        method = RBlade.h(args[0].tr "\"'", "")
+        method = RBlade.h(args[0].tr("\"'", ""))
 
-        %[_out<<'<input type="hidden" name="_method" value="#{method}">';]
+        %(_out<<'<input type="hidden" name="_method" value="#{method}">';)
       end
 
       def compileDelete args
-        if !args.nil?
-          raise StandardError.new "Once statement: wrong number of arguments (given #{args.count}, expecting 0)"
+        unless args.nil?
+          raise StandardError.new "Delete statement: wrong number of arguments (given #{args.count}, expecting 0)"
         end
 
-        compileMethod(['DELETE'])
+        compileMethod(["DELETE"])
       end
 
       def compilePatch args
-        if !args.nil?
-          raise StandardError.new "Once statement: wrong number of arguments (given #{args.count}, expecting 0)"
+        unless args.nil?
+          raise StandardError.new "Patch statement: wrong number of arguments (given #{args.count}, expecting 0)"
         end
 
-        compileMethod(['PATCH'])
+        compileMethod(["PATCH"])
       end
 
       def compilePut args
-        if !args.nil?
-          raise StandardError.new "Once statement: wrong number of arguments (given #{args.count}, expecting 0)"
+        unless args.nil?
+          raise StandardError.new "Put statement: wrong number of arguments (given #{args.count}, expecting 0)"
         end
 
-        compileMethod(['PUT'])
+        compileMethod(["PUT"])
       end
 
       def compileOld args
         if args.nil? || args.count > 2
-          raise StandardError.new "Once statement: wrong number of arguments (given #{args.count}, expecting 0)"
+          raise StandardError.new "Old statement: wrong number of arguments (given #{args&.count || 0}, expecting 1 or 2)"
         end
 
         default_value = args[1] || "''"

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

@@ -7,7 +7,7 @@ module RBlade
 
       def compileBreak args
         if args&.count&.> 1
-          raise StandardError.new "Break statement: wrong number of arguments (given #{args&.count}, expecting 0 or 1)"
+          raise StandardError.new "Break statement: wrong number of arguments (given #{args.count}, expecting 0 or 1)"
         end
 
         if args.nil?
@@ -31,7 +31,7 @@ module RBlade
 
       def compileEachElse args
         if args.nil? || args.count > 2
-          raise StandardError.new "Each statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
+          raise StandardError.new "Each else statement: wrong number of arguments (given #{args&.count || 0}, expecting 1)"
         end
         # Allow variables to be a key, value pair
         args = args.join ","
@@ -59,7 +59,11 @@ module RBlade
         "_looped_#{@loop_else_counter}=false;for #{args[0]};_looped_#{@loop_else_counter}=true;"
       end
 
-      def compileEmpty
+      def compileEmpty args
+        unless args.nil?
+          raise StandardError.new "Empty statement: wrong number of arguments (given #{args.count}, expecting 0)"
+        end
+
         @loop_else_counter -= 1
 
         "end;if !_looped_#{@loop_else_counter + 1};"
@@ -67,7 +71,7 @@ module RBlade
 
       def compileNext args
         if args&.count&.> 1
-          raise StandardError.new "For statement: wrong number of arguments (given #{args&.count || 0}, expecting 0 or 1)"
+          raise StandardError.new "Next statement: wrong number of arguments (given #{args.count}, expecting 0 or 1)"
         end
 
         if args.nil?

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

@@ -17,7 +17,7 @@ module RBlade
 
       def compilePushOnce args
         if args&.count != 1 && args&.count != 2
-          raise StandardError.new "Push once statement: wrong number of arguments (given #{args.count}, expecting 1 or 2)"
+          raise StandardError.new "Push once statement: wrong number of arguments (given #{args&.count || 0}, expecting 1 or 2)"
         end
         @once_counter += 1
         once_id = args[1].nil? ? ":_#{@once_counter}" : args[1]
@@ -27,8 +27,8 @@ module RBlade
       end
 
       def compileEndPushOnce args
-        if !args.nil?
-          raise StandardError.new "End push once statement: wrong number of arguments (given #{args&.count}, expecting 0)"
+        unless args.nil?
+          raise StandardError.new "End push once statement: wrong number of arguments (given #{args.count}, expecting 0)"
         end
 
         "RBlade::StackManager.push(_p1_#{@once_counter}, _out);_out=_p1_#{@once_counter}_b;end;"
@@ -36,7 +36,7 @@ module RBlade
 
       def compilePrependOnce args
         if args&.count != 1 && args&.count != 2
-          raise StandardError.new "Prepend once statement: wrong number of arguments (given #{args.count}, expecting 1 or 2)"
+          raise StandardError.new "Prepend once statement: wrong number of arguments (given #{args&.count || 0}, expecting 1 or 2)"
         end
         @once_counter += 1
         once_id = args[1].nil? ? ":_#{@once_counter}" : args[1]
@@ -46,8 +46,8 @@ module RBlade
       end
 
       def compileEndPrependOnce args
-        if !args.nil?
-          raise StandardError.new "End prepend once statement: wrong number of arguments (given #{args&.count}, expecting 0)"
+        unless args.nil?
+          raise StandardError.new "End prepend once statement: wrong number of arguments (given #{args.count}, expecting 0)"
         end
 
         "RBlade::StackManager.prepend(_p1_#{@once_counter}, _out);_out=_p1_#{@once_counter}_b;end;"