rux 1.1.2 → 1.2.0

data/lib/rux/parser.rb

@@ -26,6 +26,12 @@ module Rux
     end
 
     def parse
+      AST::RootNode.new(list)
+    end
+
+    private
+
+    def list
       curlies = 1
       children = []
 
@@ -34,9 +40,9 @@ module Rux
         break unless type
 
         case type
-          when :tLCURLY, :tLBRACE, :tRUX_LITERAL_RUBY_CODE_START
+          when :tLCURLY, :tLBRACE, :tRUX_LITERAL_RUBY_CODE_START, :tRUX_ATTRIBUTE_RUBY_CODE_START
             curlies += 1
-          when :tRCURLY, :tRBRACE, :tRUX_LITERAL_RUBY_CODE_END
+          when :tRCURLY, :tRBRACE, :tRUX_LITERAL_RUBY_CODE_END, :tRUX_ATTRIBUTE_RUBY_CODE_END
             curlies -= 1
         end
 
@@ -46,6 +52,8 @@ module Rux
           children << rb
         elsif type_of(current) == :tRUX_TAG_OPEN_START
           children << tag
+        elsif type_of(current) == :tRUX_FRAGMENT_OPEN
+          children << fragment
         else
           raise UnexpectedTokenError,
             'expected ruby code or the start of a rux tag but found '\
@@ -56,8 +64,6 @@ module Rux
       AST::ListNode.new(children)
     end
 
-    private
-
     def ruby
       ruby_start = pos_of(current).begin_pos
 
@@ -79,7 +85,7 @@ module Rux
 
       if pos_of(current).begin_pos != ruby_start
         AST::RubyNode.new(
-          @lexer.source_buffer.source[ruby_start...(pos_of(current).end_pos - 1)]
+          @lexer.source_buffer.source[ruby_start...(pos_of(current).begin_pos)]
         )
       end
     end
@@ -93,7 +99,8 @@ module Rux
       attrs = attributes
       maybe_consume(:tRUX_ATTRIBUTE_SPACES)
       maybe_consume(:tRUX_TAG_OPEN_END)
-      tag_node = AST::TagNode.new(tag_name, attrs)
+      tag_node = AST::TagNode.new(tag_name, attrs, tag_pos)
+      attrs.each { |attr_node| attr_node.tag_node = tag_node }
 
       if is?(:tRUX_TAG_SELF_CLOSING_END)
         consume(:tRUX_TAG_SELF_CLOSING_END)
@@ -103,12 +110,7 @@ module Rux
       @stack.push(tag_name)
 
       until is?(:tRUX_TAG_CLOSE_START)
-        if is?(:tRUX_LITERAL, :tRUX_LITERAL_RUBY_CODE_START)
-          lit = literal
-          tag_node.children << lit if lit
-        else
-          tag_node.children << tag
-        end
+        populate_next_child(tag_node)
       end
 
       consume(:tRUX_TAG_CLOSE_START)
@@ -131,44 +133,106 @@ module Rux
       tag_node
     end
 
+    def populate_next_child(node)
+      if is?(:tRUX_LITERAL, :tRUX_LITERAL_RUBY_CODE_START)
+        lit = literal
+        node.children << lit if lit
+      else
+        node.children << tag
+      end
+    end
+
     def attributes
-      {}.tap do |attrs|
-        while is?(:tRUX_ATTRIBUTE_NAME)
-          key, value = attribute
-          attrs[key] = value
+      pos = pos_of(current)
+
+      attrs = [].tap do |attrs|
+        loop do
+          attr = case type_of(current)
+          when :tRUX_ATTRIBUTE_NAME
+            attribute
+          when :tRUX_ATTRIBUTE_RUBY_CODE_START
+            ruby_attribute
+          end
 
           maybe_consume(:tRUX_ATTRIBUTE_SPACES)
+
+          if attr
+            attrs << attr
+          else
+            break
+          end
         end
       end
+
+      AST::AttrsNode.new(attrs, pos)
     end
 
     def attribute
-      maybe_consume(:tRUX_ATTRIBUTE_SPACES)
       attr_name = text_of(current)
+      attr_pos = pos_of(current)
       consume(:tRUX_ATTRIBUTE_NAME)
       maybe_consume(:tRUX_ATTRIBUTE_EQUALS_SPACES)
 
       attr_value = if maybe_consume(:tRUX_ATTRIBUTE_EQUALS)
         maybe_consume(:tRUX_ATTRIBUTE_VALUE_SPACES)
-        attribute_value
+        attribute_value.tap do
+          maybe_consume(:tRUX_ATTRIBUTE_VALUE_SPACES)
+        end
       else
         # if no equals sign, assume boolean attribute
-        AST::StringNode.new("\"true\"")
+        AST::StringNode.new('true', :none, nil)
       end
 
-      [attr_name, attr_value]
+      AST::AttrNode.new(attr_name, attr_value, attr_pos)
+    end
+
+    def ruby_attribute
+      consume(:tRUX_ATTRIBUTE_RUBY_CODE_START)
+
+      AST::RubyAttrNode.new(ruby).tap do
+        consume(:tRUX_ATTRIBUTE_RUBY_CODE_END)
+      end
     end
 
     def attribute_value
       if is?(:tRUX_ATTRIBUTE_VALUE_RUBY_CODE_START)
         attr_ruby_code
       else
-        AST::StringNode.new(text_of(current)).tap do
-          consume(:tRUX_ATTRIBUTE_VALUE)
+        case type_of(current)
+          when :tRUX_ATTRIBUTE_VALUE_DQ_START
+            attribute_value_dq
+          when :tRUX_ATTRIBUTE_VALUE_SQ_START
+            attribute_value_sq
+          when :tRUX_ATTRIBUTE_UQ_VALUE
+            attribute_value_uq
         end
       end
     end
 
+    def attribute_value_dq
+      consume(:tRUX_ATTRIBUTE_VALUE_DQ_START)
+
+      AST::StringNode.new(text_of(current), :double, pos_of(current)).tap do
+        consume(:tRUX_ATTRIBUTE_DQ_VALUE)
+        consume(:tRUX_ATTRIBUTE_VALUE_DQ_END)
+      end
+    end
+
+    def attribute_value_sq
+      consume(:tRUX_ATTRIBUTE_VALUE_SQ_START)
+
+      AST::StringNode.new(text_of(current), :single, pos_of(current)).tap do
+        consume(:tRUX_ATTRIBUTE_SQ_VALUE)
+        consume(:tRUX_ATTRIBUTE_VALUE_SQ_END)
+      end
+    end
+
+    def attribute_value_uq
+      AST::StringNode.new(text_of(current), :none, pos_of(current)).tap do
+        consume(:tRUX_ATTRIBUTE_UQ_VALUE)
+      end
+    end
+
     def attr_ruby_code
       consume(:tRUX_ATTRIBUTE_VALUE_RUBY_CODE_START)
 
@@ -177,13 +241,27 @@ module Rux
       end
     end
 
+    def fragment
+      consume(:tRUX_FRAGMENT_OPEN)
+
+      AST::FragmentNode.new.tap do |fragment_node|
+        until is?(:tRUX_TAG_CLOSE_START)
+          populate_next_child(fragment_node)
+        end
+
+        consume(:tRUX_TAG_CLOSE_START)
+        consume(:tRUX_FRAGMENT_CLOSE)
+      end
+    end
+
     def literal
       if is?(:tRUX_LITERAL_RUBY_CODE_START)
         literal_ruby_code
       else
         lit = squeeze_lit(text_of(current))
+        pos = pos_of(current)
         consume(:tRUX_LITERAL)
-        AST::TextNode.new(lit) unless lit.empty?
+        AST::TextNode.new(lit, pos) unless lit.empty?
       end
     end
 
@@ -197,7 +275,7 @@ module Rux
     def literal_ruby_code
       consume(:tRUX_LITERAL_RUBY_CODE_START)
 
-      parse.tap do |res|
+      list.tap do
         consume(:tRUX_LITERAL_RUBY_CODE_END)
       end
     end

data/lib/rux/ruby_lexer.rb

@@ -117,6 +117,7 @@ module Rux
 
     def at_lt?
       is?(@rux_token_queue[1], :tLT) && (
+        is?(@rux_token_queue[2], :tGT) ||
         is?(@rux_token_queue[2], :tCONSTANT) ||
         is?(@rux_token_queue[2], :tIDENTIFIER)
       )

data/lib/rux/rux_lexer.rb

@@ -2,6 +2,17 @@ require 'csv'
 
 module Rux
   class RuxLexer
+    RUBY_CODE_STATES = [
+      # ruby code in attributes, eg. <div {**kwargs}>
+      :tRUX_ATTRIBUTE_RUBY_CODE,
+
+      # ruby code in attribute values, eg. <div foo={bar}>
+      :tRUX_ATTRIBUTE_VALUE_RUBY_CODE,
+
+      # ruby code in tag bodies, eg. <div>{foo}</div>
+      :tRUX_LITERAL_RUBY_CODE
+    ].freeze
+
     class << self
       # See: https://docs.google.com/spreadsheets/d/11ikKuySIKoaj-kFIfhlzebUwH31cRt_1flGjWfk7RMg
       def state_table
@@ -87,11 +98,13 @@ module Rux
         case state
           when :tRUX_TAG_OPEN, :tRUX_TAG_SELF_CLOSING
             tag_stack.push(text)
+          when :tRUX_FRAGMENT_OPEN
+            tag_stack.push(:__fragment)
           when :tRUX_TAG_CLOSE
             tag_stack.pop
           when :tRUX_TAG_CLOSE_END
             break if tag_stack.empty?
-          when :tRUX_TAG_SELF_CLOSING_END
+          when :tRUX_TAG_SELF_CLOSING_END, :tRUX_FRAGMENT_CLOSE
             tag_stack.pop
             break if tag_stack.empty?
         end
@@ -150,8 +163,7 @@ module Rux
     # bodies. Eventually I'd like to also allow passing a Ruby hash to
     # dynamically specify attributes, but we're not there yet.
     def ruby_code?(state)
-      state == :tRUX_ATTRIBUTE_VALUE_RUBY_CODE ||
-        state == :tRUX_LITERAL_RUBY_CODE
+      RUBY_CODE_STATES.include?(state)
     end
   end
 end

data/lib/rux/version.rb

@@ -1,3 +1,3 @@
 module Rux
-  VERSION = '1.1.2'
+  VERSION = '1.2.0'
 end

data/lib/rux/visitor.rb

@@ -4,6 +4,10 @@ module Rux
       node.accept(self)
     end
 
+    def visit_root(node)
+      visit_children(node)
+    end
+
     def visit_list(node)
       visit_children(node)
     end
@@ -20,6 +24,18 @@ module Rux
       visit_children(node)
     end
 
+    def visit_attrs(node)
+      visit_children(node)
+    end
+
+    def visit_attr(node)
+      visit_children(node)
+    end
+
+    def visit_fragment(node)
+      visit_children(node)
+    end
+
     def visit_text(node)
       visit_children(node)
     end

data/spec/parser/attributes_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe 'attributes', type: :parser do
+  it 'handles single-quoted rux attributes' do
+    expect(compile("<Hello foo='bar' />")).to eq(
+      'render(Hello.new(foo: "bar"))'
+    )
+
+    expect(compile("<Hello foo='bar'></Hello>")).to eq(
+      'render(Hello.new(foo: "bar"))'
+    )
+  end
+
+  it 'handles double-quoted rux attributes' do
+    expect(compile('<Hello foo="bar" />')).to eq(
+      'render(Hello.new(foo: "bar"))'
+    )
+
+    expect(compile('<Hello foo="bar"></Hello>')).to eq(
+      'render(Hello.new(foo: "bar"))'
+    )
+  end
+
+  it 'handles unquoted rux attributes' do
+    expect(compile('<Hello foo=bar />')).to eq(
+      'render(Hello.new(foo: "bar"))'
+    )
+
+    expect(compile('<Hello foo=bar></Hello>')).to eq(
+      'render(Hello.new(foo: "bar"))'
+    )
+  end
+
+  it 'handles non-uniform spacing between attributes' do
+    expect(compile('<Hello  foo="bar"    baz= "boo" bix  ="bit" />')).to eq(
+      'render(Hello.new(foo: "bar", baz: "boo", bix: "bit"))'
+    )
+  end
+
+  it 'handles boolean attributes' do
+    expect(compile('<Hello disabled />')).to eq(
+      'render(Hello.new(disabled: "true"))'
+    )
+
+    expect(compile('<Hello disabled/>')).to eq(
+      'render(Hello.new(disabled: "true"))'
+    )
+
+    expect(compile('<Hello disabled></Hello>')).to eq(
+      'render(Hello.new(disabled: "true"))'
+    )
+  end
+
+  it 'converts dashes to underscores in attribute keys' do
+    expect(compile('<Hello foo-bar="baz" />')).to eq(
+      'render(Hello.new(foo_bar: "baz"))'
+    )
+  end
+
+  it 'handles simple ruby statements in attributes' do
+    expect(compile('<Hello foo={true} />')).to eq(
+      'render(Hello.new(foo: true))'
+    )
+  end
+
+  it 'handles ruby hashes in attributes' do
+    expect(compile('<Hello foo={{ foo: "bar", baz: "boo" }} />')).to eq(
+      'render(Hello.new(foo: { foo: "bar", baz: "boo" }))'
+    )
+  end
+
+  it 'handles ruby code with curly braces in attributes' do
+    expect(compile('<Hello foo={[1, 2, 3].map { |n| n * 2 }} />')).to eq(<<~RUBY.strip)
+      render(Hello.new(foo: [1, 2, 3].map { |n|
+        n * 2
+      }))
+    RUBY
+  end
+
+  it 'slugifies ruby arguments' do
+    code = <<~RUX
+      <Hello data-foo="bar" />
+    RUX
+    expect(compile(code)).to eq(<<~RUBY.strip)
+      render(Hello.new(data_foo: "bar"))
+    RUBY
+  end
+
+  it 'does not slugify HTML attributes' do
+    code = <<~RUX
+      <div data-foo="bar" />
+    RUX
+    expect(compile(code)).to eq(<<~RUBY.strip)
+      Rux.tag("div", { :"data-foo" => "bar" })
+    RUBY
+  end
+end

data/spec/parser/fragment_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe 'fragments', type: :parser do
+  it 'allows fragments' do
+    code = <<~RUX
+      <>
+        <div>Foo 1</div>
+        <div>Foo 2</div>
+      </>
+    RUX
+    expect(compile(code)).to eq(<<~RUBY.strip)
+      Rux.create_buffer.tap { |_rux_buf_|
+        _rux_buf_.append(Rux.tag("div") {
+          Rux.create_buffer.tap { |_rux_buf_|
+            _rux_buf_.safe_append("Foo 1")
+          }.to_s
+        })
+        _rux_buf_.append(Rux.tag("div") {
+          Rux.create_buffer.tap { |_rux_buf_|
+            _rux_buf_.safe_append("Foo 2")
+          }.to_s
+        })
+      }.to_s
+    RUBY
+  end
+
+  it 'allows fragments nested inside ruby code' do
+    code = <<~RUX
+      <table>
+        {rows.map do |row|
+          <>{row}</>
+        end}
+      </table>
+    RUX
+    expect(compile(code)).to eq(<<~RUBY.strip)
+      Rux.tag("table") {
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.append(rows.map { |row|
+            Rux.create_buffer.tap { |_rux_buf_|
+              _rux_buf_.append(row)
+            }.to_s
+          })
+        }.to_s
+      }
+    RUBY
+  end
+end

data/spec/parser/html_safety_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'html safety', type: :parser do
+  it 'escapes HTML entities in strings' do
+    expect(compile('<Hello>"foo"</Hello>')).to eq(<<~RUBY.strip)
+      render(Hello.new) { |rux_block_arg0|
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.safe_append("&quot;foo&quot;")
+        }.to_s
+      }
+    RUBY
+  end
+end

data/spec/parser/slot_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe 'slots', type: :parser do
+  it 'correctly transforms slot components into slot methods' do
+    code = <<~RUX
+      <TableComponent>
+        <WithRow>
+          <WithColumn>Foo 1</WithColumn>
+        </WithRow>
+        <WithRow>
+          <WithColumn>Foo 2</WithColumn>
+        </WithRow>
+      </TableComponent>
+    RUX
+    expect(compile(code)).to eq(<<~RUBY.strip)
+      render(TableComponent.new) { |rux_block_arg0|
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.append((rux_block_arg0.with_row { |rux_block_arg1|
+            Rux.create_buffer.tap { |_rux_buf_|
+              _rux_buf_.append((rux_block_arg1.with_column { |rux_block_arg2|
+                Rux.create_buffer.tap { |_rux_buf_|
+                  _rux_buf_.safe_append("Foo 1")
+                }.to_s
+              }; nil))
+            }.to_s
+          }; nil))
+          _rux_buf_.append((rux_block_arg0.with_row { |rux_block_arg1|
+            Rux.create_buffer.tap { |_rux_buf_|
+              _rux_buf_.append((rux_block_arg1.with_column { |rux_block_arg2|
+                Rux.create_buffer.tap { |_rux_buf_|
+                  _rux_buf_.safe_append("Foo 2")
+                }.to_s
+              }; nil))
+            }.to_s
+          }; nil))
+        }.to_s
+      }
+    RUBY
+  end
+end

data/spec/parser/tag_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe 'tags', type: :parser do
+  it 'handles a single self-closing tag' do
+    expect(compile("<Hello/>")).to eq("render(Hello.new)")
+  end
+
+  it 'handles a self-closing tag with spaces preceding the closing punctuation' do
+    expect(compile("<Hello />")).to eq("render(Hello.new)")
+  end
+
+  it 'handles a single opening and closing tag' do
+    expect(compile("<Hello></Hello>")).to eq('render(Hello.new)')
+  end
+
+  it 'handles a single tag with a text body' do
+    expect(compile("<Hello>foo</Hello>")).to eq(<<~RUBY.strip)
+      render(Hello.new) { |rux_block_arg0|
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.safe_append("foo")
+        }.to_s
+      }
+    RUBY
+  end
+
+  it 'handles simple ruby statements in tag bodies' do
+    expect(compile('<Hello>{"foo"}</Hello>')).to eq(<<~RUBY.strip)
+      render(Hello.new) { |rux_block_arg0|
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.append("foo")
+        }.to_s
+      }
+    RUBY
+  end
+
+  it 'handles tag bodies containing ruby code with curly braces' do
+    expect(compile('<Hello>{[1, 2, 3].map { |n| n * 2 }.join(", ")}</Hello>')).to eq(<<~RUBY.strip)
+      render(Hello.new) { |rux_block_arg0|
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.append([1, 2, 3].map { |n|
+            n * 2
+          }.join(", "))
+        }.to_s
+      }
+    RUBY
+  end
+
+  it 'handles tag bodies with intermixed text and ruby code' do
+    expect(compile('<Hello>abc {foo} def {bar} baz</Hello>')).to eq(<<~RUBY.strip)
+      render(Hello.new) { |rux_block_arg0|
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.safe_append("abc ")
+          _rux_buf_.append(foo)
+          _rux_buf_.safe_append(" def ")
+          _rux_buf_.append(bar)
+          _rux_buf_.safe_append(" baz")
+        }.to_s
+      }
+    RUBY
+  end
+
+  it 'handles rux tags inside ruby code' do
+    rux_code = <<~RUX
+      <Outer>
+        {5.times.map do
+          <Inner>What a {@thing}</Inner>
+        end}
+      </Outer>
+    RUX
+
+    expect(compile(rux_code)).to eq(<<~RUBY.strip)
+      render(Outer.new) { |rux_block_arg0|
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.append(5.times.map {
+            render(Inner.new) { |rux_block_arg1|
+              Rux.create_buffer.tap { |_rux_buf_|
+                _rux_buf_.safe_append("What a ")
+                _rux_buf_.append(@thing)
+              }.to_s
+            }
+          })
+        }.to_s
+      }
+    RUBY
+  end
+
+  it 'handles HTML tags inside ruby code' do
+    rux_code = <<~RUX
+      <div>
+        {5.times.map do
+          <p>What a {@thing}</p>
+        end}
+      </div>
+    RUX
+
+    expect(compile(rux_code)).to eq(<<~RUBY.strip)
+      Rux.tag("div") {
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.append(5.times.map {
+            Rux.tag("p") {
+              Rux.create_buffer.tap { |_rux_buf_|
+                _rux_buf_.safe_append("What a ")
+                _rux_buf_.append(@thing)
+              }.to_s
+            }
+          })
+        }.to_s
+      }
+    RUBY
+  end
+
+  it 'handles regular HTML tags' do
+    expect(compile('<div>foo</div>')).to eq(<<~RUBY.strip)
+      Rux.tag("div") {
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.safe_append("foo")
+        }.to_s
+      }
+    RUBY
+  end
+
+  it 'handles regular HTML tags inside ruby code' do
+    rux_code = <<~RUX
+      <Outer>
+        {5.times.map do
+          <div>So {@cool}</div>
+        end}
+      </Outer>
+    RUX
+
+    expect(compile(rux_code)).to eq(<<~RUBY.strip)
+      render(Outer.new) { |rux_block_arg0|
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.append(5.times.map {
+            Rux.tag("div") {
+              Rux.create_buffer.tap { |_rux_buf_|
+                _rux_buf_.safe_append("So ")
+                _rux_buf_.append(@cool)
+              }.to_s
+            }
+          })
+        }.to_s
+      }
+    RUBY
+  end
+
+  it 'demonstrates that tags support keyword splats' do
+    code = <<~RUX
+      <div {**args}>foo</div>
+    RUX
+
+    expect(compile(code)).to eq(<<~RUBY.strip)
+      Rux.tag("div", { **args }) {
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.safe_append("foo")
+        }.to_s
+      }
+    RUBY
+  end
+
+  it 'demonstrates that tags support keyword arguments mixed with splats' do
+    code = <<~RUX
+      <div foo="bar" {**args} baz={"boo"}>foo</div>
+    RUX
+
+    expect(compile(code)).to eq(<<~RUBY.strip)
+      Rux.tag("div", { foo: "bar", **args, baz: "boo" }) {
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.safe_append("foo")
+        }.to_s
+      }
+    RUBY
+  end
+end