rux 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74fe5ea5efe72399854ca97874db7ae0f9aa59abcc9201fc31725991881148b5
-  data.tar.gz: 5a07947618af42f689f84784ed6a4ce095ef4693cd6e6187008cd4a5cf774b4c
+  metadata.gz: fba8846934ea39d67f4705ce5a0ec7a477e65eccc5fc5b63a6ff1f6a2233e9ca
+  data.tar.gz: a27256e117f07fe67fe286bc0730b265bccd91e98e18c6944aa968862b8c0e4b
 SHA512:
-  metadata.gz: fe10394671a5d56275289a84013f85ae13bf84c6690febf2906ed63d54005c13aee9417db3285855a75e3fc85484b51b84daa596223cd16844ecd4fbe008d728
-  data.tar.gz: 368880ab3405473e61114d846ec3aa54ced6490a070abd358857fcba21b373b8dcfad5eeb8a4b1100b6429a97c24e642b2c4e60bb33384baa3b9da2194d251ab
+  metadata.gz: 62c36cfb6e05f6379f659e89c6bc3bea79144ff6eae9de80491597686b967daabe6c84b5e55dbf24ef104b9e7267aa186c370c9fae18ba8c1fcf038a3805db20
+  data.tar.gz: 3c7c4a4b5f7ac00a344358df1e02f7bf5850aa76b0974f466b6759973f6b8400700cfc2050e6c9e1debff42ac8ad56eba9e5b018261bfa4e6dfd4b344dbbca70

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# 1.2.0
+* Improve output safety.
+  - HTML tags are now automatically escaped when they come from Ruby code.
+* Add fragment support.
+  - Analogous to JSX fragments, eg. `<>foo</>`.
+* Add keyword argument support in HTML attributes.
+  - Eg. `<div {**kwargs} bar="baz">boo</div>`.
+* Add ViewComponent slot support.
+  - Works via pseudo components that begin with `With`, eg. `<MySlotComponent><WithItem>Item</WithItem></MySlotComponent>`.
+* Allow printing `ruxc` results to STDOUT.
+* Support for unquoted attributes.
+* Drop explicit support for Ruby versions < 3.
+
 # 1.1.2
 * Don't slugify HTML attributes in the tag builder either.
 

data/Gemfile

@@ -3,7 +3,7 @@ source 'https://rubygems.org'
 gemspec
 
 group :development, :test do
-  gem 'pry-byebug'
+  gem 'debug'
   gem 'rake'
   gem 'rspec'
 end

data/README.md

@@ -148,6 +148,94 @@ end
 
 Notice we were able to embed Ruby within rux within Ruby within rux. Within Ruby. The rux parser supports unlimited levels of nesting, although you'll probably not want to go _too_ crazy.
 
+## Slots
+
+Rux fully supports the view_component gem's [slots feature](https://viewcomponent.org/guide/slots.html), which allows a component to expose specific points in the rendered output where the caller can provide their own content. Let's look at a table component that exposes rows and columns via slots:
+
+```ruby
+class TableComponent < ViewComponent::Base
+  renders_many :rows, RowComponent
+
+  def call
+    <table>
+      {rows.each do |row|
+        <>{row}</>
+      end}
+    </table>
+  end
+end
+
+class RowComponent < ViewComponent::Base
+  renders_many :columns, ColumnComponent
+
+  def call
+    <tr>
+      {columns.each do |column|
+        <>{column}</>
+      end}
+    </tr>
+  end
+end
+
+class ColumnComponent < ViewComponent::Base
+  def call
+    <td>{content}</td>
+  end
+end
+```
+
+Notice the use of rux fragments (analogous to JSX fragments) via the `<></>` syntax. This allows emitting a slot by dropping back to ruby via rux.
+
+The `TableComponent` might be rendered in an ERB template like so:
+
+```erb
+<%= render(TableComponent.new) do |table| %>
+  <% table.with_row do |row| %>
+    <% row.with_column { "Row 1, Col 1" } %>
+    <% row.with_column { "Row 1, Col 2" } %>
+  <% end %>
+  <% table.with_row do |row| %>
+    <% row.with_column { "Row 2, Col 1" } %>
+    <% row.with_column { "Row 2, Col 2" } %>
+  <% end %>
+<% end %>
+```
+
+Notice the slots are "filled in" using the `#with_row` and `#with_column` methods. In rux, these methods become components:
+
+```ruby
+<TableComponent>
+  <WithRow>
+    <WithColumn>Row 1, Col 1</WithColumn>
+    <WithColumn>Row 1, Col 2</WithColumn>
+  </WithRow>
+  <WithRow>
+    <WithColumn>Row 2, Col 1</WithColumn>
+    <WithColumn>Row 2, Col 2</WithColumn>
+  </WithRow>
+</TableComponent>
+```
+
+## The `as:` argument
+
+In ViewComponent, component instances are yielded to the block on `#render`, eg:
+
+```erb
+<%= render(MyComponent.new) do |component| %>
+  <%# 'component' is the instance of MyComponent passed to #render above %>
+<% end %>
+```
+
+Most of the time in rux, a reference to the component instance isn't necessary (see the section on slots above). Occasionally however it can be useful to, for example, call methods on the component instance to query its state, etc. Use the `as:` argument to assign the component instance to a local variable that's available inside the tag body:
+
+```ruby
+<TableComponent something={value} as={table}>
+  {if table.something
+    # your code here
+  end}
+</TableComponent>
+```
+
 ## Keyword Arguments Only
 
 Any view component that will be rendered by rux must _only_ accept keyword arguments in its constructor. For example:

data/bin/ruxc

@@ -14,8 +14,8 @@ class RuxCLI
     end
 
     options = {
-      recursive: false,
-      pretty: true
+      pretty: true,
+      stdout: false
     }
 
     if argv.first != '-h' && argv.first != '--help'
@@ -33,6 +33,14 @@ class RuxCLI
         end
       end
 
+      oneline(<<~DESC).tap do |desc|
+        Print results to STDOUT instead of writing files to disk.
+      DESC
+        opts.on('-o', '--stdout', desc) do |stdout|
+          options[:stdout] = stdout
+        end
+      end
+
       opts.on('-h', '--help', 'Prints this help info') do
         puts opts
         exit
@@ -79,6 +87,10 @@ class RuxCLI
     @options[:pretty]
   end
 
+  def write_to_stdout?
+    @options[:stdout]
+  end
+
   private
 
   def directory?
@@ -91,6 +103,11 @@ cli.validate
 
 cli.each_file do |in_file, out_file, rbi_file|
   rux_file = Rux::File.new(in_file)
-  rux_file.write(out_file, pretty: cli.pretty?)
-  puts "Wrote #{out_file}"
+
+  if cli.write_to_stdout?
+    puts rux_file.to_ruby(pretty: cli.pretty?)
+  else
+    rux_file.write(out_file, pretty: cli.pretty?)
+    puts "Wrote #{out_file}"
+  end
 end

data/lib/rux/ast/attr_node.rb

@@ -0,0 +1,22 @@
+module Rux
+  module AST
+    class AttrNode
+      attr_reader :name, :value, :name_pos
+      attr_accessor :tag_node
+
+      def initialize(name, value, name_pos)
+        @name = name
+        @value = value
+        @name_pos = name_pos
+      end
+
+      def accept(visitor)
+        visitor.visit_attr(self)
+      end
+
+      def ruby_code?
+        false
+      end
+    end
+  end
+end

data/lib/rux/ast/attrs_node.rb

@@ -0,0 +1,30 @@
+module Rux
+  module AST
+    class AttrsNode
+      include Enumerable
+
+      attr_reader :attrs, :pos
+
+      def initialize(attrs, pos)
+        @attrs = attrs
+        @pos = pos
+      end
+
+      def accept(visitor)
+        visitor.visit_attrs(self)
+      end
+
+      def each(&block)
+        attrs.each(&block)
+      end
+
+      def empty?
+        attrs.empty?
+      end
+
+      def get(name)
+        find { |attr| attr.name == name }
+      end
+    end
+  end
+end

data/lib/rux/ast/fragment_node.rb

@@ -0,0 +1,15 @@
+module Rux
+  module AST
+    class FragmentNode
+      attr_reader :children
+
+      def initialize
+        @children = []
+      end
+
+      def accept(visitor)
+        visitor.visit_fragment(self)
+      end
+    end
+  end
+end

data/lib/rux/ast/root_node.rb

@@ -0,0 +1,19 @@
+module Rux
+  module AST
+    class RootNode
+      attr_reader :list
+
+      def initialize(list)
+        @list = list
+      end
+
+      def accept(visitor)
+        visitor.visit_root(self)
+      end
+
+      def children
+        @children ||= [list]
+      end
+    end
+  end
+end

data/lib/rux/ast/ruby_attr_node.rb

@@ -0,0 +1,28 @@
+module Rux
+  module AST
+    class RubyAttrNode
+      attr_reader :ruby_node
+      attr_accessor :tag_node
+
+      def initialize(ruby_node)
+        @ruby_node = ruby_node
+      end
+
+      def code
+        ruby_node.code
+      end
+
+      def accept(visitor)
+        visitor.visit_attr(self)
+      end
+
+      def ruby_code?
+        true
+      end
+
+      def name
+        nil
+      end
+    end
+  end
+end

data/lib/rux/ast/string_node.rb

@@ -1,10 +1,12 @@
 module Rux
   module AST
     class StringNode
-      attr_reader :str
+      attr_reader :str, :quote_type, :pos
 
-      def initialize(str)
+      def initialize(str, quote_type, pos)
         @str = str
+        @quote_type = quote_type
+        @pos = pos
       end
 
       def accept(visitor)

data/lib/rux/ast/tag_node.rb

@@ -3,9 +3,10 @@ module Rux
     class TagNode
       attr_reader :name, :attrs, :children
 
-      def initialize(name, attrs)
+      def initialize(name, attrs, pos)
         @name = name
         @attrs = attrs
+        @pos = pos
         @children = []
       end
 
@@ -16,6 +17,14 @@ module Rux
       def component?
         name.start_with?(/[A-Z]/)
       end
+
+      def slot_component?
+        name.start_with?("With")
+      end
+
+      def slot_method
+        @slot_method ||= name.gsub(/(?<!^)([A-Z])/) { |x| "_#{x}" }.downcase
+      end
     end
   end
 end

data/lib/rux/ast/text_node.rb

@@ -5,8 +5,9 @@ module Rux
     class TextNode
       attr_reader :text
 
-      def initialize(text)
+      def initialize(text, pos)
         @text = text
+        @pos = pos
       end
 
       def accept(visitor)

data/lib/rux/ast.rb

@@ -1,9 +1,14 @@
 module Rux
   module AST
-    autoload :ListNode,   'rux/ast/list_node'
-    autoload :RubyNode,   'rux/ast/ruby_node'
-    autoload :StringNode, 'rux/ast/string_node'
-    autoload :TagNode,    'rux/ast/tag_node'
-    autoload :TextNode,   'rux/ast/text_node'
+    autoload :AttrNode,     'rux/ast/attr_node'
+    autoload :AttrsNode,    'rux/ast/attrs_node'
+    autoload :FragmentNode, 'rux/ast/fragment_node'
+    autoload :ListNode,     'rux/ast/list_node'
+    autoload :RootNode,     'rux/ast/root_node'
+    autoload :RubyAttrNode, 'rux/ast/ruby_attr_node'
+    autoload :RubyNode,     'rux/ast/ruby_node'
+    autoload :StringNode,   'rux/ast/string_node'
+    autoload :TagNode,      'rux/ast/tag_node'
+    autoload :TextNode,     'rux/ast/text_node'
   end
 end

data/lib/rux/buffer.rb

@@ -1,15 +1,33 @@
 module Rux
+  class SafeString < String
+    def html_safe?
+      true
+    end
+  end
+
   class Buffer
     def initialize(init_str = '')
       @string = init_str.dup
     end
 
-    def <<(*obj)
-      @string << obj.join
+    def append(obj)
+      Array(obj).each do |o|
+        @string << if o.respond_to?(:html_safe?) && o.html_safe?
+          o.to_s
+        else
+          CGI.escapeHTML(o.to_s)
+        end
+      end
+    end
+
+    def safe_append(obj)
+      Array(obj).each { |o| @string << o.to_s }
     end
 
     def to_s
-      @string
+      SafeString.new(@string)
     end
+
+    alias html_safe to_s
   end
 end

data/lib/rux/default_tag_builder.rb

@@ -1,19 +1,28 @@
 module Rux
   class DefaultTagBuilder
-    def call(tag_name, attributes = {})
-      attr_str = attributes.empty? ? '' : " #{serialize_attrs(attributes)}"
-      "<#{tag_name}#{attr_str}>" <<
-        (block_given? ? Array(yield) : []).join <<
-        "</#{tag_name}>"
+    def call(tag_name, attributes = {}, &block)
+      SafeString.new(build(tag_name, attributes, &block))
     end
 
     private
 
+    def build(tag_name, attributes = {})
+      attr_str = attributes.empty? ? '' : " #{serialize_attrs(attributes)}"
+
+      "<#{tag_name}#{attr_str}>".tap do |result|
+        if block_given?
+          Array(yield).each { |body| result << body }
+        end
+
+        result << "</#{tag_name}>"
+      end
+    end
+
     def serialize_attrs(attributes)
       ''.tap do |result|
         attributes.each_pair.with_index do |(k, v), idx|
           result << ' ' unless idx == 0
-          result << "#{k}=\"#{CGI.escape_html(v.to_s)}\""
+          result << "#{k}=\"#{v.to_s.gsub('"', "&quot;")}\""
         end
       end
     end

data/lib/rux/default_visitor.rb

@@ -2,8 +2,18 @@ require 'cgi'
 
 module Rux
   class DefaultVisitor < Visitor
+    def initialize
+      @render_stack = []
+    end
+
+    def visit_root(node)
+      visit_list(node.list)
+    end
+
     def visit_list(node)
-      node.children.map { |child| visit(child) }.join
+      ''.tap do |result|
+        node.children.each { |child| result << visit(child) }
+      end
     end
 
     def visit_ruby(node)
@@ -11,57 +21,121 @@ module Rux
     end
 
     def visit_string(node)
-      node.str
+      case node.quote_type
+        when :single
+          "'#{node.str}'"
+        else
+          "\"#{node.str}\""
+      end
     end
 
     def visit_tag(node)
       ''.tap do |result|
-        block_arg = if (as = node.attrs['as'])
+        block_arg = if (as = node.attrs.get('as'))
           visit(as)
         end
 
-        at = node.attrs.each_with_object([]) do |(k, v), ret|
-          next if k == 'as'
-          ret << Utils.attr_to_hash_elem(k, visit(v), slugify: node.component?)
-        end
+        block_arg ||= "rux_block_arg#{@render_stack.size}"
+
+        if node.slot_component?
+          result << "(#{parent_render[:block_arg]}.#{node.slot_method}"
 
-        if node.component?
+          unless node.attrs.empty?
+            result << "(#{visit(node.attrs)})"
+          end
+        elsif node.component?
           result << "render(#{node.name}.new"
 
           unless node.attrs.empty?
-            result << "(#{at.join(', ')})"
+            result << "(#{visit(node.attrs)})"
           end
+
+          result << ')'
         else
           result << "Rux.tag('#{node.name}'"
 
           unless node.attrs.empty?
-            result << ", { #{at.join(', ')} }"
+            result << ", { #{visit(node.attrs)} }"
           end
+
+          result << ')'
         end
 
-        result << ')'
+        @render_stack.push({
+          component_name: node.name,
+          block_arg: block_arg
+        })
 
-        if node.children.size > 1
+        if node.children.size > 0
           result << " { "
-          result << "|#{block_arg}| " if block_arg
+          result << "|#{block_arg}| " if block_arg && node.component?
           result << "Rux.create_buffer.tap { |_rux_buf_| "
 
           node.children.each do |child|
-            result << "_rux_buf_ << #{visit(child).strip};"
+            result << append_statement_for(child)
           end
 
           result << " }.to_s }"
-        elsif node.children.size == 1
-          result << ' { '
-          result << "|#{block_arg}| " if block_arg
-          result << visit(node.children.first).strip
-          result << ' }'
         end
+
+        # don't pass instances of ViewComponent::Slot to _rux_buf_#<< by wrapping
+        # the slot setter return value in (retval; nil)
+        if node.slot_component?
+          result << "; nil)"
+        end
+
+        @render_stack.pop
+      end
+    end
+
+    def append_statement_for(node)
+      if node.is_a?(AST::TextNode)
+        "_rux_buf_.safe_append(#{visit(node).strip});"
+      else
+        "_rux_buf_.append(#{visit(node).strip});"
+      end
+    end
+
+    def visit_attrs(node)
+      visited_attrs = node.attrs.each_with_object([]) do |attr, memo|
+        memo << visit(attr) unless attr.name == "as"
+      end
+
+      visited_attrs.join(", ")
+    end
+
+    def visit_attr(node)
+      if node.ruby_code?
+        node.code
+      else
+        Utils.attr_to_hash_elem(
+          node.name,
+          visit(node.value),
+          slugify: node.tag_node.component?
+        )
+      end
+    end
+
+    def visit_fragment(node)
+      ''.tap do |result|
+        result << "Rux.create_buffer.tap { |_rux_buf_| "
+
+        node.children.each do |child|
+          result << append_statement_for(child)
+        end
+
+        result << " }.to_s;"
       end
     end
 
     def visit_text(node)
       "\"#{CGI.escape_html(node.text)}\""
     end
+
+    private
+
+    def parent_render
+      @render_stack.last
+    end
   end
 end

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,,