rux 1.1.1 → 1.2.0

data/lib/rux/lex/states.csv

@@ -1,11 +1,11 @@
 ,[<],[a-zA-Z0-9_-_---:-:],[>],[/],(space),[=],"[""]",['],"[^""]",[^'],[{],[}],(default)
 start,tag_open_test,,,,,,,,,,literal_ruby_code_start,,literal_body
-tag_open_test,,tag_open_start[0],,tag_close_start,,,,,,,,,
+tag_open_test,,tag_open_start[0],fragment_open,tag_close_start,,,,,,,,,
 tag_open_start*,,tag_open_body,,,,,,,,,,,
 tag_open_body,,tag_open_body,tag_open[0],tag_self_closing[0],tag_open[0],,,,,,,,
 tag_open*,,,tag_open_end,,attribute_spaces_body,,,,,,,,
 tag_open_end*,,,,,,,,,,,,,
-tag_close_start*,,tag_close_body,,,,,,,,,,,
+tag_close_start*,,tag_close_body,fragment_close,,,,,,,,,,
 tag_close_body,,tag_close_body,tag_close[0],,tag_close[0],,,,,,,,
 tag_close*,,,tag_close_end,tag_self_closing[0],tag_close_spaces_body,,,,,,,,
 tag_close_spaces_body,,,tag_close_spaces[0],,tag_close_spaces_body,,,,,,,,
@@ -14,23 +14,34 @@ tag_close_end*,,,,,,,,,,,,,
 tag_self_closing*,,,,tag_self_closing_start,,,,,,,,,
 tag_self_closing_start,,,tag_self_closing_end,,,,,,,,,,
 tag_self_closing_end*,,,,,,,,,,,,,
+fragment_open*,,,,,,,,,,,,,
+fragment_close*,,,,,,,,,,,,,
 ,,,,,,,,,,,,,
-attribute_spaces_body,,attribute_spaces[0],attribute_spaces[0],attribute_spaces[0],attribute_spaces_body,,,,,,,,
-attribute_spaces*,,attribute_name_body,tag_close_start,tag_self_closing_start,,,,,,,,,
+attribute_spaces_body,,attribute_spaces[0],attribute_spaces[0],attribute_spaces[0],attribute_spaces_body,,,,,,attribute_spaces[0],,
+attribute_spaces*,,attribute_name_body,tag_close_start,tag_self_closing_start,,,,,,,attribute_ruby_code_start,,
 attribute_name_body,,attribute_name_body,attribute_name[0],attribute_name[0],attribute_name[0],attribute_name[0],,,,,,,
 attribute_name*,,,tag_open_end,tag_self_closing_start,attribute_equals_spaces_body,attribute_equals,,,,,,,
 attribute_equals_spaces_body,,,attribute_equals_spaces[0],,attribute_equals_spaces_body,attribute_equals_spaces[0],,,,,,,attribute_equals_spaces[0]
 attribute_equals_spaces*,,,tag_open_end,tag_self_closing_start,,attribute_equals,,,,,,,attribute_name_body
-attribute_equals*,,attribute_uq_body,,,attribute_value_spaces_body[0],,attribute_dq_body,attribute_sq_body,,,attribute_value_ruby_code_start,,
-attribute_value_spaces_body,,attribute_value_spaces[0],,,attribute_value_spaces_body,,attribute_value_spaces[0],attribute_value_spaces[0],,,attribute_value_spaces[0],,
-attribute_value_spaces*,,attribute_uq_body,,,,,attribute_dq_body,attribute_sq_body,,,attribute_value_ruby_code_start,,
-attribute_dq_body,,,,,,,attribute_value,,attribute_dq_body,,,,
-attribute_sq_body,,,,,,,,attribute_value,,attribute_sq_body,,,
-attribute_uq_body,,attribute_uq_body,,,attribute_value,,,,,,,,
+attribute_equals*,,attribute_value_uq_body,,,attribute_value_spaces_body[0],,attribute_value_dq_start,attribute_value_sq_start,,,attribute_value_ruby_code_start,,
+attribute_value_spaces_body,,attribute_value_spaces[0],attribute_value_spaces[0],attribute_value_spaces[0],attribute_value_spaces_body,,attribute_value_spaces[0],attribute_value_spaces[0],,,attribute_value_spaces[0],,
+attribute_value_spaces*,,attribute_value_uq_body,tag_open_end,tag_self_closing_start,,,attribute_value_dq_start,attribute_value_sq_start,,,attribute_value_ruby_code_start,,
+attribute_value_dq_start*,,,,,,,,,attribute_value_dq_body,,,,
+attribute_value_sq_start*,,,,,,,,,,attribute_value_sq_body,,,
+attribute_value_dq_body,,,,,,,attribute_dq_value[0],,attribute_value_dq_body,,,,
+attribute_value_sq_body,,,,,,,,attribute_sq_value[0],,attribute_value_sq_body,,,
+attribute_value_uq_body,,attribute_value_uq_body,attribute_uq_value[0],attrIbute_uq_value[0],attribute_uq_value[0],,,,,,,,
+attribute_value_dq_end*,,attribute_name,tag_open_end,tag_self_closing_start,attribute_spaces_body,,,,,,,,
+attribute_value_sq_end*,,attribute_name,tag_open_end,tag_self_closing_start,attribute_spaces_body,,,,,,,,
 attribute_value_ruby_code_start*,,,,,,,,,,,,,attribute_value_ruby_code
 attribute_value_ruby_code*,,,,,,,,,,,,attribute_value_ruby_code_end,
 attribute_value_ruby_code_end*,,attribute_name,tag_open_end,tag_self_closing_start,attribute_spaces_body,,,,,,,,
-attribute_value*,,attribute_name,tag_open_end,tag_self_closing_start,attribute_spaces_body,,attribute_value_ending,attribute_value_ending,,,,,
+attribute_dq_value*,,,,,,,attribute_value_dq_end,,,,,,
+attribute_sq_value*,,,,,,,,attribute_value_sq_end,,,,,
+attribute_uq_value*,,attribute_name,tag_open_end,tag_self_closing_start,attribute_spaces_body,,,,,,,,
+attribute_ruby_code_start*,,,,,,,,,,,,,attribute_ruby_code[0]
+attribute_ruby_code*,,,,,,,,,,,,attribute_ruby_code_end,
+attribute_ruby_code_end*,,attribute_name,tag_open_end,tag_self_closing_start,attribute_spaces_body,,,,,,,,
 ,,,,,,,,,,,,,
 literal_body,literal[0],,,,,,,,,,literal[0],,literal_body
 literal*,,,,,,,,,,,literal_ruby_code_start,,

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.1'
+  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