rux 1.1.2 → 1.3.0

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
@@ -217,7 +10,7 @@ describe Rux::Parser do
   it 'raises an error when no state transition can be found' do
     expect { compile('<Hello <foo>') }.to(
       raise_error(Rux::Lexer::TransitionError,
-        'no transition found from tRUX_ATTRIBUTE_SPACES_BODY at position 7 '\
+        'no transition found from tRUX_ATTRIBUTE_SPACES_BODY for "<" at position 7 '\
           'while lexing rux code')
     )
   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,73 @@ 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
+  it 'preserves comments' do
     code = <<~RUX
-      <Hello data-foo="bar" />
+      # frozen_string_literal: true
+
+      class Foo
+        def call
+          <p>Hello</p>
+        end
+      end
     RUX
-    expect(compile(code)).to eq(<<~RUBY.strip)
-      render(Hello.new(data_foo: "bar"))
+    expect(compile(code)).to eq(<<~RUBY)
+      # frozen_string_literal: true
+      class Foo
+        def call
+          Rux.tag("p") {
+            Rux.create_buffer.tap { |_rux_buf_|
+              _rux_buf_.safe_append("Hello")
+            }.to_s
+          }
+        end
+      end
     RUBY
   end
 
-  it 'does not slugify HTML attributes' do
+  it 'allows a tag after ruby code in a branch situation' do
     code = <<~RUX
-      <div data-foo="bar" />
+      <div>
+        {if foo
+          <>foo</>
+        else
+          <div></div>
+        end}
+      </div>
     RUX
     expect(compile(code)).to eq(<<~RUBY.strip)
-      Rux.tag("div", { :"data-foo" => "bar" })
+      Rux.tag("div") {
+        Rux.create_buffer.tap { |_rux_buf_|
+          _rux_buf_.append(if foo
+            Rux.create_buffer.tap { |_rux_buf_|
+              _rux_buf_.safe_append("foo")
+            }.to_s
+          else
+            Rux.tag("div")
+          end)
+        }.to_s
+      }
     RUBY
   end
 end

data/spec/render_spec.rb

@@ -1,12 +1,7 @@
 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
-
-  it 'handles a HTML tags inside ruby code' do
+describe 'rendering', type: :render do
+  it 'handles HTML tags inside ruby code' do
     result = render(<<~RUBY)
       <div>
         {3.times.map do
@@ -83,4 +78,72 @@ describe Rux do
       "<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,47 +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
-  end
-
-  def call
-    "<p>#{a} and #{b}</p>"
-  end
-end
-
-class DataComponent < ViewComponent::Base
-  def initialize(data_foo:)
-    @data_foo = data_foo
+module Rux
+  module ParserTestHelpers
+    def compile(rux_code)
+      Rux.to_ruby(rux_code)
+    end
   end
 
-  def call
-    "<div data-foo=\"#{@data_foo}\"></div>"
+  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

data/spec/support/view_component/base.rb

@@ -0,0 +1,59 @@
+# a very basic implementation of the view_component lib
+module ViewComponent
+  class Slot
+    def initialize(component_instance, content_block)
+      @component_instance = component_instance
+      @content_block = content_block
+    end
+
+    def to_s
+      @component_instance.content = @content_block.call(@component_instance) if @content_block
+      @component_instance.call
+    end
+  end
+
+  class Base
+    class << self
+      def renders_many(name, component)
+        singular_name = name.to_s.chomp("s")
+
+        registered_slots[name] = {
+          renderable: component,
+          collection: true
+        }
+
+        define_method(:"with_#{singular_name}") do |*args, **kwargs, &block|
+          slots[name] ||= []
+          slots[name] << Slot.new(component.new(*args, **kwargs), block)
+          nil
+        end
+
+        define_method(name) do
+          slots[name] || []
+        end
+      end
+
+      private
+
+      def registered_slots
+        @registered_slots ||= {}
+      end
+    end
+
+    attr_accessor :content
+
+    def render(component, &block)
+      if block
+        component.content = block.call(component)
+      end
+
+      component.call
+    end
+
+    private
+
+    def slots
+      @slots ||= {}
+    end
+  end
+end