rux 1.1.2 → 1.3.0

data/lib/rux/lex/states.csv

@@ -1,39 +1,51 @@
-,[<],[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_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_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,,,,,,,,
-tag_close_spaces*,,,tag_close_end,,,,,,,,,,
-tag_close_end*,,,,,,,,,,,,,
-tag_self_closing*,,,,tag_self_closing_start,,,,,,,,,
-tag_self_closing_start,,,tag_self_closing_end,,,,,,,,,,
-tag_self_closing_end*,,,,,,,,,,,,,
-,,,,,,,,,,,,,
-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_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_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,,,,,
-,,,,,,,,,,,,,
-literal_body,literal[0],,,,,,,,,,literal[0],,literal_body
-literal*,,,,,,,,,,,literal_ruby_code_start,,
-literal_ruby_code_start*,,,,,,,,,,,,,literal_ruby_code[0]
-literal_ruby_code*,,,,,,,,,,,,literal_ruby_code_end,
-literal_ruby_code_end*,,,,,,,,,,,,,
+,[<],[@-@.-.],[a-zA-Z0-9_-_---:-:],[>],[/],(space),[=],"[""]",['],"[^""]",[^'],[{],[}],(default)
+start,tag_open_test,,,,,,,,,,,literal_ruby_code_start,,literal_body
+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,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,,,,,,,,
+tag_close_spaces*,,,,tag_close_end,,,,,,,,,,
+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[0],attribute_spaces_body,,,,,,attribute_spaces[0],,
+attribute_spaces*,,attribute_name_sigil,attribute_name_body,tag_open_end,tag_self_closing_start,,,,,,,attribute_ruby_code_start,,
+attribute_name_sigil,,,,,,,,,,,,,,attribute_name_body
+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_sigil
+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_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,,
+literal_ruby_code_start*,,,,,,,,,,,,,,literal_ruby_code[0]
+literal_ruby_code*,,,,,,,,,,,,,literal_ruby_code_end,
+literal_ruby_code_end*,,,,,,,,,,,,,,

data/lib/rux/lexer.rb

@@ -1,3 +1,5 @@
+require 'parser'
+
 module Rux
   class Lexer
     class EOFError < StandardError; end
@@ -5,6 +7,13 @@ module Rux
 
     attr_reader :source_buffer
 
+    class << self
+      def lex(str)
+        buffer = ::Parser::Source::Buffer.new('(source)', source: str)
+        new(buffer).to_a
+      end
+    end
+
     def initialize(source_buffer)
       @source_buffer = source_buffer
       @stack = [RubyLexer.new(source_buffer, 0)]
@@ -17,6 +26,10 @@ module Rux
       [nil, ['$eof']]
     end
 
+    def to_a
+      @generator.to_a
+    end
+
     private
 
     def each_token

data/lib/rux/parser.rb

@@ -8,14 +8,18 @@ module Rux
     class << self
       def parse_file(path)
         buffer = ::Parser::Source::Buffer.new(path).read
-        lexer = ::Rux::Lexer.new(buffer)
-        new(lexer).parse
+        new(make_lexer(buffer)).parse
       end
 
       def parse(str)
         buffer = ::Parser::Source::Buffer.new('(source)', source: str)
-        lexer = ::Rux::Lexer.new(buffer)
-        new(lexer).parse
+        new(make_lexer(buffer)).parse
+      end
+
+      private
+
+      def make_lexer(buffer)
+        ::Rux::Lexer.new(buffer)
       end
     end
 
@@ -26,6 +30,12 @@ module Rux
     end
 
     def parse
+      AST::RootNode.new(list)
+    end
+
+    private
+
+    def list
       curlies = 1
       children = []
 
@@ -34,9 +44,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 +56,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 +68,6 @@ module Rux
       AST::ListNode.new(children)
     end
 
-    private
-
     def ruby
       ruby_start = pos_of(current).begin_pos
 
@@ -79,7 +89,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 +103,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 +114,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 +137,108 @@ 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
+      elsif is?(:tRUX_FRAGMENT_OPEN)
+        node.children << fragment
+      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 +247,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 +281,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

@@ -1,4 +1,18 @@
 module Rux
+  class TokenArrayProxy < Array
+    def initialize(rux_token_queue)
+      @rux_token_queue = rux_token_queue
+    end
+
+    def push(token)
+      if token[0] == :tCOMMENT
+        @rux_token_queue.push(token)
+      end
+
+      super
+    end
+  end
+
   class RubyLexer < ::Parser::Lexer
     # These are populated when ::Parser::Lexer loads and are therefore
     # not inherited. We have to copy them over manually.
@@ -15,6 +29,8 @@ module Rux
       @generator = to_enum(:each_token)
       @rux_token_queue = []
       @p = init_pos
+
+      self.tokens = TokenArrayProxy.new(@rux_token_queue)
     end
 
     alias_method :advance_orig, :advance
@@ -27,6 +43,7 @@ module Rux
       @ts = @te = @p = pos
       @eof = false
       @rux_token_queue.clear
+      clear_queue
       populate_queue
     end
 
@@ -44,13 +61,7 @@ module Rux
     end
 
     def each_token(&block)
-      # We detect whether or not we're at the beginning of a rux tag by looking
-      # ahead by 1 token; that's why the first element in @rux_token_queue is
-      # yielded immediately. If the lexer _starts_ at a rux tag however,
-      # lookahead is a lot more difficult. To mitigate, we insert a dummy skip
-      # token here. That way, at_rux? checks the right tokens in the queue and
-      # correctly identifies the start of a rux tag.
-      @rux_token_queue << [:tSKIP, ['$skip', make_range(@p, @p)]]
+      clear_queue
 
       @eof = false
       curlies = 1
@@ -74,7 +85,7 @@ module Rux
         type, (_, pos) = token
 
         case type
-          when :tLCURLY, :tLBRACE
+          when :tLCURLY, :tLBRACE, :tLAMBEG
             curlies += 1
           when :tRCURLY, :tRBRACE
             curlies -= 1
@@ -111,12 +122,25 @@ module Rux
       end
     end
 
+    def clear_queue
+      @rux_token_queue.clear
+
+      # We detect whether or not we're at the beginning of a rux tag by looking
+      # ahead by 1 token; that's why the first element in @rux_token_queue is
+      # yielded immediately. If the lexer _starts_ at a rux tag however,
+      # lookahead is a lot more difficult. To mitigate, we insert a dummy skip
+      # token here. That way, at_rux? checks the right tokens in the queue and
+      # correctly identifies the start of a rux tag.
+      @rux_token_queue << [:tSKIP, ['$skip', make_range(@p, @p)]]
+    end
+
     def at_rux?
       at_lt? && !at_inheritance?
     end
 
     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
@@ -110,7 +123,7 @@ module Rux
 
         unless cur_trans
           raise Rux::Lexer::TransitionError,
-            "no transition found from #{cur_state} at position #{@p} while "\
+            "no transition found from #{cur_state} for #{chr.inspect} at position #{@p} while "\
             'lexing rux code'
         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.3.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/lib/rux.rb

@@ -38,9 +38,8 @@ module Rux
       ruby_code = visitor.visit(Parser.parse(str))
       return ruby_code unless pretty
 
-      ::Unparser.unparse(
-        ::Parser::CurrentRuby.parse(ruby_code)
-      )
+      ast, comments = *::Parser::CurrentRuby.parse_with_comments(ruby_code)
+      ::Unparser.unparse(ast, comments: comments)
     end
 
     def default_visitor

data/rux.gemspec

@@ -10,11 +10,13 @@ Gem::Specification.new do |s|
   s.description = s.summary = 'A jsx-inspired way to write view components.'
   s.platform = Gem::Platform::RUBY
 
+  s.add_dependency 'onload', '~> 1.1'
   s.add_dependency 'parser', '~> 3.0'
-  s.add_dependency 'unparser', '~> 0.6'
+  s.add_dependency 'unparser', '~> 0.8'
 
   s.require_path = 'lib'
   s.executables << 'ruxc'
+  s.executables << 'ruxlex'
 
   s.files = Dir['{lib,spec}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'rux.gemspec']
 end