rux 1.1.1 → 1.2.0

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

data/spec/parser_spec.rb

@@ -2,214 +2,7 @@ require 'spec_helper'
 require 'parser'
 require 'unparser'
 
-describe Rux::Parser do
-  def compile(rux_code)
-    Rux.to_ruby(rux_code)
-  end
-
-  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) {
-        "foo"
-      }
-    RUBY
-  end
-
-  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 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 'handles simple ruby statements in tag bodies' do
-    expect(compile('<Hello>{"foo"}</Hello>')).to eq(<<~RUBY.strip)
-      render(Hello.new) {
-        "foo"
-      }
-    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) {
-        [1, 2, 3].map { |n|
-          n * 2
-        }.join(", ")
-      }
-    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.create_buffer.tap { |_rux_buf_|
-          _rux_buf_ << "abc "
-          _rux_buf_ << foo
-          _rux_buf_ << " def "
-          _rux_buf_ << bar
-          _rux_buf_ << " 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) {
-        5.times.map {
-          render(Inner.new) {
-            Rux.create_buffer.tap { |_rux_buf_|
-              _rux_buf_ << "What a "
-              _rux_buf_ << @thing
-            }.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") {
-        5.times.map {
-          Rux.tag("p") {
-            Rux.create_buffer.tap { |_rux_buf_|
-              _rux_buf_ << "What a "
-              _rux_buf_ << @thing
-            }.to_s
-          }
-        }
-      }
-    RUBY
-  end
-
-  it 'handles regular HTML tags' do
-    expect(compile('<div>foo</div>')).to eq(<<~RUBY.strip)
-      Rux.tag("div") {
-        "foo"
-      }
-    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) {
-        5.times.map {
-          Rux.tag("div") {
-            Rux.create_buffer.tap { |_rux_buf_|
-              _rux_buf_ << "So "
-              _rux_buf_ << @cool
-            }.to_s
-          }
-        }
-      }
-    RUBY
-  end
-
-  it 'escapes HTML entities in strings' do
-    expect(compile('<Hello>"foo"</Hello>')).to eq(<<~RUBY.strip)
-      render(Hello.new) {
-        "&quot;foo&quot;"
-      }
-    RUBY
-  end
-
+describe 'parsing', type: :parser do
   it 'raises an error on premature end of input' do
     expect { compile('<Hello') }.to raise_error(Rux::Lexer::EOFError)
   end
@@ -230,13 +23,13 @@ describe Rux::Parser do
     )
   end
 
-  it 'emits handles spaces between adjacent ruby code snippets' do
+  it 'emits spaces between adjacent ruby code snippets' do
     expect(compile("<Hello>{first} {second}</Hello>")).to eq(<<~RUBY.strip)
-      render(Hello.new) {
+      render(Hello.new) { |rux_block_arg0|
         Rux.create_buffer.tap { |_rux_buf_|
-          _rux_buf_ << first
-          _rux_buf_ << " "
-          _rux_buf_ << second
+          _rux_buf_.append(first)
+          _rux_buf_.safe_append(" ")
+          _rux_buf_.append(second)
         }.to_s
       }
     RUBY
@@ -250,42 +43,24 @@ describe Rux::Parser do
       </Hello>
     RUX
     expect(compile(code)).to eq(<<~RUBY.strip)
-      render(Hello.new) {
+      render(Hello.new) { |rux_block_arg0|
         Rux.create_buffer.tap { |_rux_buf_|
-          _rux_buf_ << render(Hola.new) {
+          _rux_buf_.append(render(Hola.new) { |rux_block_arg1|
             Rux.create_buffer.tap { |_rux_buf_|
-              _rux_buf_ << first
-              _rux_buf_ << " "
-              _rux_buf_ << second
+              _rux_buf_.append(first)
+              _rux_buf_.safe_append(" ")
+              _rux_buf_.append(second)
             }.to_s
-          }
-          _rux_buf_ << render(Hola.new) {
+          })
+          _rux_buf_.append(render(Hola.new) { |rux_block_arg1|
             Rux.create_buffer.tap { |_rux_buf_|
-              _rux_buf_ << first
-              _rux_buf_ << " "
-              _rux_buf_ << second
+              _rux_buf_.append(first)
+              _rux_buf_.safe_append(" ")
+              _rux_buf_.append(second)
             }.to_s
-          }
+          })
         }.to_s
       }
     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/render_spec.rb

@@ -1,11 +1,6 @@
 require 'spec_helper'
 
-describe Rux do
-  def render(rux_code)
-    ruby_code = Rux.to_ruby(rux_code)
-    ViewComponent::Base.new.instance_eval(ruby_code)
-  end
-
+describe 'rendering', type: :render do
   it 'handles a HTML tags inside ruby code' do
     result = render(<<~RUBY)
       <div>
@@ -63,4 +58,92 @@ describe Rux do
       "<div><p>Hello World</p><p>Hello World</p><p>Hello World</p><p>Hello World</p></div>"
     )
   end
+
+  it 'slugifies ruby arguments' do
+    result = render(<<~RUBY)
+      <DataComponent data-foo="foo" />
+    RUBY
+
+    expect(result).to eq(
+      "<div data-foo=\"foo\"></div>"
+    )
+  end
+
+  it 'does not slugify HTML attributes' do
+    result = render(<<~RUBY)
+      <div data-foo="bar"></div>
+    RUBY
+
+    expect(result).to eq(
+      "<div data-foo=\"bar\"></div>"
+    )
+  end
+
+  it 'renders slots correctly' do
+    result = render(<<~RUBY)
+      <TableComponent>
+        <WithRow>
+          <WithColumn>Foo 1</WithColumn>
+        </WithRow>
+        <WithRow>
+          <WithColumn>Foo 2</WithColumn>
+        </WithRow>
+      </TableComponent>
+    RUBY
+
+    expect(result).to eq(
+      "<table><tr><td>Foo 1</td></tr><tr><td>Foo 2</td></tr></table>"
+    )
+  end
+
+  it 'calls .to_s on anything appended to a buffer' do
+    result = render(<<~RUBY)
+      <div>
+        {[["foo", "bar"], ["baz", "boo"]].map do |row|
+          <>{row}</>
+        end}
+      </div>
+    RUBY
+    expect(result).to eq(
+      '<div>foobarbazboo</div>'
+    )
+  end
+
+  it 'escapes arbitrary ruby expressions' do
+    result = render(<<~RUBY, value: "<p>Foo</p>")
+      <div>{kwargs[:value]}</div>
+    RUBY
+    expect(result).to eq(
+      "<div>&lt;p&gt;Foo&lt;/p&gt;</div>"
+    )
+  end
+
+  it 'escapes double quotes in HTML attributes' do
+    result = render(<<~RUBY)
+      <div class={'"foo"'}>foo</div>
+    RUBY
+    expect(result).to eq(
+      "<div class=\"&quot;foo&quot;\">foo</div>"
+    )
+  end
+
+  it 'handles keyword splats' do
+    kwargs = { a: "foo", b: "bar" }
+    result = render(<<~RUBY, **kwargs)
+      <ArgsComponent {**kwargs} />
+    RUBY
+    expect(result).to eq(
+      "<p>foo and bar</p>"
+    )
+  end
+
+  it 'handles keyword splats mixed with keyword args' do
+    kwargs = { a: "foo", b: "bar" }
+    result = render(<<~RUBY, **kwargs)
+      <ArgsComponent {**(kwargs.except(:b))} b={kwargs[:b]} />
+    RUBY
+    expect(result).to eq(
+      "<p>foo and bar</p>"
+    )
+  end
 end

data/spec/spec_helper.rb

@@ -1,37 +1,34 @@
 require 'rspec'
 require 'rux'
-require 'pry-byebug'
 
-# a very basic implementation of the view_component lib
-module ViewComponent
-  class Base
-    attr_accessor :content
+$:.push(File.join(__dir__, 'support'))
 
-    def render(component, &block)
-      component.content = block.call if block
-      component.call
-    end
-  end
-end
+require 'view_component/base'
 
-class TestComponent < ViewComponent::Base
-  def call
-    content
+Dir.chdir(File.join(__dir__, 'support')) do
+  Dir.glob('components/*.rb').each do |component_file|
+    require component_file
   end
 end
 
-class ArgsComponent < ViewComponent::Base
-  attr_reader :a, :b
-
-  def initialize(a:, b:)
-    @a = a
-    @b = b
+module Rux
+  module ParserTestHelpers
+    def compile(rux_code)
+      Rux.to_ruby(rux_code)
+    end
   end
 
-  def call
-    "<p>#{a} and #{b}</p>"
+  module RenderTestHelpers
+    def render(rux_code, **kwargs)
+      ruby_code = Rux.to_ruby(rux_code)
+      ViewComponent::Base.new.instance_exec(ruby_code, **kwargs) do |ruby_code, **kwargs|
+        eval(ruby_code)
+      end
+    end
   end
 end
 
 RSpec.configure do |config|
+  config.include(Rux::ParserTestHelpers, type: :parser)
+  config.include(Rux::RenderTestHelpers, type: :render)
 end

data/spec/support/components/args_component.rb

@@ -0,0 +1,14 @@
+require 'view_component/base'
+
+class ArgsComponent < ViewComponent::Base
+  attr_reader :a, :b
+
+  def initialize(a:, b:)
+    @a = a
+    @b = b
+  end
+
+  def call
+    "<p>#{a} and #{b}</p>"
+  end
+end

data/spec/support/components/data_component.rb

@@ -0,0 +1,11 @@
+require 'view_component/base'
+
+class DataComponent < ViewComponent::Base
+  def initialize(data_foo:)
+    @data_foo = data_foo
+  end
+
+  def call
+    "<div data-foo=\"#{@data_foo}\"></div>"
+  end
+end

data/spec/support/components/table_component.rb

@@ -0,0 +1,23 @@
+require 'view_component/base'
+
+class ColumnComponent < ViewComponent::Base
+  def call
+    "<td>#{content}</td>"
+  end
+end
+
+class RowComponent < ViewComponent::Base
+  renders_many :columns, ColumnComponent
+
+  def call
+    "<tr>#{columns.map(&:to_s).join}</tr>"
+  end
+end
+
+class TableComponent < ViewComponent::Base
+  renders_many :rows, RowComponent
+
+  def call
+    "<table>#{rows.map(&:to_s).join}</table>"
+  end
+end

data/spec/support/components/test_component.rb

@@ -0,0 +1,7 @@
+require 'view_component/base'
+
+class TestComponent < ViewComponent::Base
+  def call
+    content
+  end
+end