erb2rux 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a3f63bab9bef707b611464f3d952d7f505e22d0593976105cfc803eff905685
+  data.tar.gz: c45fa2a5e37eedac6c0d095fe3441e840e8e2b3c640076cbd74440226e7d5db5
+SHA512:
+  metadata.gz: 06e32ead01821495acab5335a36a407ab9bc36e32a331b9775e35e92c49b0dd8b9f3ea3438f9ad24219e7a2fb4565f9e93629794414f2ad02a950732a04c7de5
+  data.tar.gz: 87372c28d66eb2e8c971d18537999359b14731293e8d9a3dfec57a95ce0d050eaa8acfbdd7bd07cb51e3b60eddb13a664d947ad77e3cf0f28c11f1b04328cc39

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'pry-byebug'
+  gem 'rake'
+  gem 'rspec'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Cameron Dutro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,45 @@
+## erb2rux
+
+![Unit Tests](https://github.com/camertron/erb2rux/actions/workflows/unit_tests.yml/badge.svg?branch=main)
+
+erb2rux is an ERB to [Rux](https://github.com/camertron/rux) converter. It's used to translate Rails view files, usually written in ERB (embedded Ruby) syntax, into Rux syntax. Rux allows you to write HTML in your Ruby code, much like JSX allows you to write HTML in your JavaScript. It's great for rendering [view components](https://viewcomponent.org/).
+
+## Installation
+
+Simply run `gem install erb2rux`.
+
+## Usage
+
+The project ships with a single executable called `erb2rux`. It takes any number of files as arguments, or a single "-" character to read from [standard input](https://en.wikipedia.org/wiki/Standard_streams). In the case of standard input, `erb2rux` will print the resulting Rux code to standard output (i.e. your terminal screen). Otherwise, the list of files will be transpiled and written to the same location as the original file, with either the default extension (.html.ruxt) or one you specify.
+
+Here's an example showing how to transpile a single file:
+
+```bash
+erb2rux app/views/products/index.html.erb
+```
+
+This will create app/views/products/index.html.ruxt containing Rux code equivalent to the given ERB file.
+
+To use a different extension, pass the -x option:
+
+```bash
+erb2rux -x .html.rux app/views/products/index.html.erb
+```
+
+Finally, here's the equivalent command using standard in/out:
+
+```bash
+cat app/views/products/index.html.erb | erb2rux -
+```
+
+## Running Tests
+
+`bundle exec rspec` should do the trick.
+
+## License
+
+Licensed under the MIT license. See LICENSE for details.
+
+## Authors
+
+* Cameron C. Dutro: http://github.com/camertron

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rubygems/package_task'
+
+require 'erb2rux'
+
+Bundler::GemHelper.install_tasks
+
+task default: :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end

data/bin/erb2rux

@@ -0,0 +1,77 @@
+#! /usr/bin/env ruby
+
+$:.push(File.expand_path('./lib'))
+
+require 'optparse'
+require 'erb2rux'
+
+class Erb2RuxCLI
+  def self.parse(argv)
+    if argv.empty?
+      puts 'Please pass a list of files to transpile, or - to read from STDIN'
+      exit 1
+    end
+
+    options = {
+      extension: '.html.ruxt'
+    }
+
+    parser = OptionParser.new do |opts|
+      opts.banner = "Usage: erb2rux [options] paths"
+
+      oneline(<<~DESC).tap do |desc|
+        The file extension to use for output files. Ignored if reading from STDIN
+        (default: #{options[:extension]}).
+      DESC
+        opts.on('-xEXT', '--extension=EXT', desc) do |ext|
+          options[:extension] = ext
+        end
+      end
+
+      opts.on('-h', '--help', 'Prints this help info') do
+        puts opts
+        exit
+      end
+    end
+
+    parser.parse!(argv)
+    new({ **options, files: argv })
+  end
+
+  def self.oneline(str)
+    str.split("\n").join(' ')
+  end
+
+  def initialize(options)
+    @options = options
+  end
+
+  def stdin?
+    @options[:files].first == '-'
+  end
+
+  def each_file(&block)
+    @options[:files].each do |in_file|
+      ext_idx = in_file.index('.')
+      out_file = "#{in_file[0...ext_idx]}#{extension}"
+      yield in_file, out_file
+    end
+  end
+
+  def extension
+    @options[:extension]
+  end
+end
+
+cli = Erb2RuxCLI.parse(ARGV)
+
+if cli.stdin?
+  puts Erb2Rux::Transformer.transform(STDIN.read)
+  exit 0
+end
+
+cli.each_file do |in_file, out_file|
+  result = Erb2Rux::Transformer.transform(File.read(in_file))
+  File.write(out_file, result)
+  puts "Wrote #{out_file}"
+end

data/erb2rux.gemspec

@@ -0,0 +1,22 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'erb2rux/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'erb2rux'
+  s.version  = ::Erb2Rux::VERSION
+  s.authors  = ['Cameron Dutro']
+  s.email    = ['camertron@gmail.com']
+  s.homepage = 'http://github.com/camertron/erb2rux'
+  s.description = s.summary = 'Automatically convert .html.erb files into .rux files.'
+  s.platform = Gem::Platform::RUBY
+
+  s.add_dependency 'actionview', '~> 6.1'
+  s.add_dependency 'parser', '~> 3.0'
+  s.add_dependency 'unparser', '~> 0.6'
+
+  s.require_path = 'lib'
+
+  s.executables << 'erb2rux'
+
+  s.files = Dir['{lib,spec}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'erb2rux.gemspec']
+end

data/lib/erb2rux/component_render.rb

@@ -0,0 +1,49 @@
+module Erb2Rux
+  class ComponentRender
+    attr_reader :component_name, :component_kwargs
+    attr_reader :send_range, :block_end_range, :block_body_range, :block_arg
+
+    def initialize(component_name:, component_kwargs:, send_range:, block_end_range:, block_body_range:, block_arg:)
+      @component_name = component_name
+      @component_kwargs = component_kwargs
+      @send_range = send_range
+      @block_end_range = block_end_range
+      @block_body_range = block_body_range
+      @block_arg = block_arg
+    end
+
+    def close_tag
+      @close_tag ||= "</#{component_name}>"
+    end
+
+    def open_tag
+      @open_tag ||= ''.tap do |result|
+        result << "<#{component_name}"
+        result << ' ' unless kwargs.empty?
+        result << kwargs
+        result << '>'
+      end
+    end
+
+    def self_closing_tag
+      @self_closing_tag ||= ''.tap do |result|
+        result << "<#{component_name}"
+        result << ' ' unless kwargs.empty?
+        result << kwargs
+        result << ' />'
+      end
+    end
+
+    private
+
+    def kwargs
+      @kwargs = begin
+        kwargs = component_kwargs.map do |key, value|
+          "#{key}={#{value}}"
+        end
+        kwargs << "as={\"#{block_arg}\"}" if block_arg
+        kwargs.join(' ')
+      end
+    end
+  end
+end

data/lib/erb2rux/transformer.rb

@@ -0,0 +1,405 @@
+require 'action_view'
+require 'parser'
+require 'unparser'
+
+module Erb2Rux
+  NodeMeta = Struct.new(:node, :stype, :replacement, :in_code)
+
+  class Transformer
+    class << self
+      def transform(source)
+        # Remove any extra spaces between the ERB tag and the content, eg.
+        # "<%= foo %>" becomes "<%=foo%>". ActionView's Erubi parser
+        # treats this extra whitespace as part of the output, which results
+        # in funky indentation issues.
+        source.gsub!(/(<%=?) */, '\1')
+        source.gsub!(/ *(%>)/, '\1')
+
+        # This is how Rails translates ERB to Ruby code, so it's probably the
+        # way we should do it too. It takes blocks into account, which, TIL, is
+        # something regular ERB doesn't do. The resulting ruby code works by
+        # appending to an @output_buffer instance variable. Different methods
+        # are used for chunks of code vs HTML strings, which allows the
+        # transformer to distinguish between them. See #send_type_for for
+        # details.
+        ruby_code = ActionView::Template::Handlers::ERB::Erubi.new(source).src
+
+        # ActionView adds this final line at the end of all compiled templates,
+        # so we need to remmove it.
+        ruby_code = ruby_code.chomp('@output_buffer.to_s')
+        ast = ::Parser::CurrentRuby.parse(ruby_code)
+        rewrite(ast)
+      end
+
+      private
+
+      # Determines whether or not the given node is itself a node (i.e. an
+      # instance of Parser::AST::Node) that identifies a visible chunk of
+      # code in the source buffer. (In addition to being Node instances,
+      # children can be strings, symbols, or nil, and sometimes only hold
+      # metadata, i.e. don't reference a visible portion of the source).
+      def is_node?(obj)
+        obj.respond_to?(:children) && obj.location.expression
+      end
+
+      def rewrite(node)
+        return unless is_node?(node)
+
+        # The "send type" refers to the way this node is being appended to the
+        # output buffer. <%= %> tags result in a call to append=, which has a
+        # send type of :code. <% %> tags result in no append calls and have a
+        # send type of nil. Finally, regular 'ol strings (i.e. HTML) result in
+        # a call to safe_append= and have a send type of :string.
+        case send_type_for(node)
+          when :code
+            rewrite_code(node)
+          when :string
+            rewrite_string(node)
+          else
+            # Code in <% %> tags should be left as-is. Instead of rewriting it
+            # we recurse and process all the children.
+            rewrite_children(node)
+        end
+      end
+
+      def rewrite_code(node)
+        # Any node that is passed to this method will be a s(:send) node that
+        # identifies a chunk of Ruby code that should be surrounded by Rux
+        # braces. The arg below is the argument to the @output_buffer.append=
+        # call.
+        _, _, arg, * = *node
+
+        # Does this node render a view component?
+        if (component_render = identify_component_render(arg))
+          _, _, block_body, = *arg
+
+          return arg.location.expression.source.dup.tap do |code|
+            # If the render call has a block...
+            if block_body
+              # ...replace the end statement with the closing tag, recursively
+              # rewrite the block's body, and replace the render call with the
+              # opening tag. Do these things in reverse order so all the ranges
+              # are valid.
+              code[component_render.block_end_range] = component_render.close_tag
+              leading_ws, body, trailing_ws = ws_split(rewrite(block_body))
+
+              code[component_render.block_body_range] = if body.empty?
+                "#{leading_ws}#{trailing_ws}"
+              else
+                "#{leading_ws}{#{body}}#{trailing_ws}"
+              end
+
+              code[component_render.send_range] = component_render.open_tag
+            else
+              # ...otherwise only replace the render call and self-close the tag.
+              code[component_render.send_range] = component_render.self_closing_tag
+            end
+          end
+        end
+
+        # ActionView wraps code in parens (eg. @output_buffer.append= ( foo ))
+        # which results in an extra s(:begin) node wrapped around the code node.
+        # Strip it off.
+        arg_body = arg.type == :begin ? arg.children[0] : arg
+        rewrite(arg_body)
+      end
+
+      def rewrite_string(node)
+        # Any node that is passed to this method will be a s(:send) node that
+        # identifies a chunk of HTML. The arg below is the argument to the
+        # @output_buffer.safe_append= call.
+        _, _, arg, * = *node
+
+        # Strip off quotes.
+        str = arg.children[0].location.expression.source[1..-2]
+
+        # Rux leaves HTML as-is, i.e. doesn't quote it.
+        unless tag_start?(str)
+          # ActionView appends every literal string it finds in the ERB source,
+          # which includes newlines and other incidental whitespace that we
+          # programmers frequently use to indent our code and otherwise make it
+          # look readable to other humans. This extra whitespace isn't part of
+          # the string itself, but because there's nothing in ERB to indicate
+          # where whitespace should stop and the string should start,
+          # ActionView just sort of smushes it all together. The whitespace is
+          # important for the aforementioned formatting reasons, so it
+          # shouldn't just be thrown away. Instead, the following lines extract
+          # the important string part along with the leading and trailing
+          # whitespace, then quote the string and stick all the parts back
+          # together. Seems to work ok.
+          leading_ws, str, trailing_ws = ws_split(str)
+          str = "#{leading_ws}#{rb_quote(str)}#{trailing_ws}"
+        end
+
+        str
+      end
+
+      def tag_start?(str)
+        str.strip.start_with?('<')
+      end
+
+      def ws_split(str)
+        leading_ws = str.match(/\A(\s*)/)
+        # Pass the second arg here to avoid considering the same whitespace
+        # as both leading _and_ trailing, as in the case where the string is
+        # entirely whitespace, etc.
+        trailing_ws = str.match(/(\s*)\z/, leading_ws.end(0))
+        middle = str[leading_ws.end(0)...(trailing_ws.begin(0))]
+        [leading_ws.captures[0], middle, trailing_ws.captures[0]]
+      end
+
+      # Because we have to perform replacements in reverse order to avoid
+      # invalidating the ranges that come later in the source, it's impossible
+      # to know whether a particular node is already wrapped in Rux curly
+      # braces or not. In other words, whether or not the current node exists
+      # inside a code block is entirely determined by the nodes that come
+      # before it, which cannot be considered when iterating in reverse order.
+      # To mitigate this problem, we first iterate in a forward manner and
+      # accrue metadata for each node. The NodeMeta struct holds a reference
+      # to the node, meaning that the replacement algorithm can simply iterate
+      # backwards through a list of them.
+      def calc_node_meta(nodes)
+        # Start out assuming we're in code. This is also what the Rux parser
+        # does.
+        in_code = true
+
+        nodes.each_with_object([]) do |child_node, memo|
+          next unless is_node?(child_node)
+
+          stype = send_type_for(child_node)
+          replacement = rewrite(child_node)
+
+          memo << NodeMeta.new(child_node, stype, replacement, in_code)
+
+          case stype
+            when :string
+              if tag_start?(replacement)
+                # If we're inside an HTML tag, that must mean we're not in a
+                # code block anymore.
+                in_code = false
+              end
+            when :code
+              in_code = true
+          end
+        end
+      end
+
+      def rewrite_children(node)
+        node_loc = node.location.expression
+        child_meta = calc_node_meta(node.children)
+
+        node_loc.source.dup.tap do |result|
+          # The replacement algorithm needs to be able to consider the previous
+          # node's metadata, so we use a sliding window of 2.
+          reverse_each_cons(2, child_meta) do |prev, cur|
+            next unless cur
+
+            child_loc = cur.node.location.expression
+
+            # A code node inside HTML who's replacement isn't HTML. Needs to be
+            # wrapped in Rux curlies.
+            if (cur.stype == :code || cur.stype == nil) && !cur.in_code && !tag_start?(cur.replacement)
+              cur.replacement = "{#{cur.replacement}}"
+            end
+
+            # ERB nodes that occur right next to each other should be concatenated.
+            # Eg: foo <%= bar %> should result in "foo" + bar.
+            # This check makes sure that:
+            # 1. Both the previous and current nodes are ERB code (i.e. are
+            #    :code or :string).
+            # 2. Both the previous and current nodes are in a code block. If
+            #    they're not, it doesn't make much sense to concatenate them
+            #    using Ruby's `+' operator.
+            # 3. Both the previous and current nodes aren't 100% whitespace,
+            #    which would indicate they're for formatting purposes and don't
+            #    contain actual code.
+            should_concat =
+              prev &&
+              cur.stype &&
+              prev.stype &&
+              cur.in_code &&
+              prev.in_code &&
+              !cur.replacement.strip.empty? &&
+              !prev.replacement.strip.empty?
+
+            if should_concat
+              cur.replacement = " + #{cur.replacement}"
+            end
+
+            begin_pos = child_loc.begin_pos - node_loc.begin_pos
+            end_pos = child_loc.end_pos - node_loc.begin_pos
+            # Trim off those pesky trailing semicolons ActionView adds.
+            end_pos += 1 if result[end_pos] == ';'
+            result[begin_pos...end_pos] = cur.replacement
+          end
+        end
+      end
+
+      # Iterates backwards over the `items` enumerable and yields a sliding
+      # window of `size` elements.
+      #
+      # For example, reverse_each_cons(3, %w(a b c d)) yields the following:
+      #
+      # ["d", nil, nil]
+      # ["c", "d", nil]
+      # ["b", "c", "d"]
+      # ["a", "b", "c"]
+      # [nil, "a", "b"]
+      # [nil, nil, "a"]
+      def reverse_each_cons(size, items)
+        slots = Array.new(size)
+        enum = items.reverse_each
+        stops = nil
+
+        loop do
+          item = begin
+            stops += 1 if stops
+            stops ? nil : enum.next
+          rescue StopIteration
+            stops = 1
+            nil
+          end
+
+          slots.unshift(item)
+          slots.pop
+
+          yield slots
+
+          # It's not useful to anybody to yield an array of all nils.
+          break if stops == size - 1
+        end
+      end
+
+      def identify_component_render(node)
+        send_node, *block_args_node = *node
+        block_arg_nodes = block_args_node[0]&.children || []
+        # Doesn't make sense for a component render to have more than one
+        # block argument.
+        return if block_arg_nodes.size > 1
+
+        block_arg_node, = *block_arg_nodes
+        return if block_arg_node && block_arg_node.type != :arg
+
+        block_arg_name, = *block_arg_node
+
+        receiver_node, method_name, *render_args = *send_node
+        # There must be no receiver (i.e. no dot), the method name must be
+        # "render," and it must take exactly one argument.
+        return if receiver_node || method_name != :render
+        return if !render_args || render_args.size != 1
+
+        render_arg, = *render_args
+        # The argument passed to render must be a s(:send) node, which
+        # indicates the presence of .new being called on a component class.
+        # This seems fine for now, but might need to change if we find there
+        # are other common ways to pass component instances to render.
+        return if render_arg.type != :send
+
+        component_name_node, _, *component_args = *render_arg
+        # The Parser gem treats keyword args as a single arg, and since Rux
+        # doesn't allow positional arguments, it's best to leave non-conforming
+        # renders alone and bail out here.
+        return if component_args.size > 1
+
+        component_kwargs, = *component_args
+
+        kwargs = if component_kwargs
+          # Whatever this first argument is, it'd better be a hash. This is how
+          # the Parser gem parses keyword arguments, even though kwargs are no
+          # longer treated as hashes in modern Rubies.
+          return unless component_kwargs.type == :hash
+
+          # Build up an array of 2-element [key, value] arrays
+          component_kwargs.children.map do |component_kwarg|
+            key, value = *component_kwarg
+            return unless [:sym, :str].include?(key.type)
+
+            [key.children[0], Unparser.unparse(value)]
+          end
+        else
+          # It's perfectly ok for components not to accept any args
+          []
+        end
+
+        source = node.location.expression.source
+
+        # This is the base position all other positions should start from.
+        # The Parser gem's position information is all absolute, i.e.
+        # measured from the beginning of the original source buffer. We want to
+        # consider only this one node, meaning all positions must be adjusted
+        # so they are relative to it.
+        start = node.location.expression.begin_pos
+        send_stop = if block_arg_node
+          # Annoyingly, the Parser gem doesn't include the trailing block
+          # terminator pipe in location.end. We have to find it manually with
+          # this #index call instead. What a pain.
+          block_arg_start = block_arg_node.location.expression.begin_pos - start
+          source.index('|', block_arg_start) + 1
+        else
+          # If we get to this point and there is no block passed to render,
+          # that means we're looking at the surrounding block Erubi adds
+          # around Ruby code (effectively surrounding it with parens). In such
+          # a case, the "begin" location points to the opening left paren. If
+          # instead there _is_ a block passed to render, the "begin" location
+          # points to the "do" statement. Truly confusing, but here we are.
+          if node.location.begin.source == 'do'
+            node.location.begin.end_pos - start
+          else
+            node.location.expression.end_pos - start
+          end
+        end
+
+        block_end_range = nil
+        block_body_range = nil
+
+        if node.type == :block
+          # Use index here to find the first non-whitespace character after the
+          # render call, as well as the first non-whitespace character before
+          # the end of the "end" statement.
+          block_body_start = source.index(/\S/, send_stop)
+          block_body_end = source.rindex(/\S/, node.location.end.begin_pos - start - 1) + 1
+
+          block_end = node.location.end
+          block_end_range = (block_end.begin_pos - start)...(block_end.end_pos - start)
+          block_body_range = block_body_start...block_body_end
+        end
+
+        return ComponentRender.new(
+          component_name: Unparser.unparse(component_name_node),
+          component_kwargs: kwargs,
+          send_range: 0...send_stop,
+          block_end_range: block_end_range,
+          block_body_range: block_body_range,
+          block_arg: block_arg_name
+        )
+      end
+
+      # Escapes double quotes, then double quotes the result.
+      def rb_quote(str)
+        return '' if !str || str.empty?
+        "\"#{str.gsub("\"", "\\\"")}\""
+      end
+
+      def send_type_for(node)
+        return unless is_node?(node)
+
+        receiver_node, method_name, = *node
+        return unless is_node?(receiver_node)
+
+        # Does this node indicate a method called on the @output_buffer
+        # instance variable?
+        is_buffer_append = receiver_node.type == :ivar &&
+          receiver_node.children[0] == :@output_buffer
+
+        return unless is_buffer_append
+
+        case method_name
+          when :safe_append=
+            :string
+          when :append=
+            :code
+        end
+      end
+    end
+  end
+end

data/lib/erb2rux/version.rb

@@ -0,0 +1,3 @@
+module Erb2Rux
+  VERSION = '0.1.0'
+end

data/lib/erb2rux.rb

@@ -0,0 +1,4 @@
+module Erb2Rux
+  autoload :ComponentRender, 'erb2rux/component_render'
+  autoload :Transformer,     'erb2rux/transformer'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$:.push(__dir__)
+
+require 'rspec'
+require 'erb2rux'
+require 'pry-byebug'
+
+Dir.chdir(__dir__) do
+  Dir['support/*.rb'].each { |f| require f }
+end
+
+module SpecHelpers
+end
+
+RSpec.configure do |config|
+  config.include SpecHelpers
+end

data/spec/transformer_spec.rb

@@ -0,0 +1,257 @@
+require 'spec_helper'
+
+describe Erb2Rux::Transformer do
+  def transform(str)
+    described_class.transform(str)
+  end
+
+  it 'handles a literal string' do
+    expect(transform('foo')).to eq('"foo"')
+  end
+
+  it 'handles a single variable' do
+    expect(transform('<%= foo %>')).to eq('foo')
+  end
+
+  it 'concatenates strings and code' do
+    expect(transform('foo <%= bar %>')).to eq('"foo"  + bar')
+  end
+
+  it 'handles a simple if statement' do
+    result = transform(<<~ERB).strip
+      <% if foo %>
+        bar
+      <% else %>
+        <%= baz %>
+      <% end %>
+    ERB
+
+    expect(result).to eq(<<~RUX.strip)
+      if foo
+        "bar"
+      else
+        baz
+      end
+    RUX
+  end
+
+  it 'wraps code in curlies' do
+    expect(transform('<a><%= foo %></a>')).to eq('<a>{foo}</a>')
+  end
+
+  it 'wraps control structures in curlies' do
+    result = transform(<<~ERB).strip
+      <a>
+        <% if foo %>
+          bar
+        <% else %>
+          <%= baz %>
+        <% end %>
+      </a>
+    ERB
+
+    expect(result).to eq(<<~RUX.strip)
+      <a>
+        {if foo
+          "bar"
+        else
+          baz
+        end}
+      </a>
+    RUX
+  end
+
+  it 'handles component renders' do
+    result = transform(<<~ERB).strip
+      <%= render(FooComponent.new) %>
+    ERB
+
+    expect(result).to eq('<FooComponent />')
+  end
+
+  it 'handles component renders with arguments' do
+    result = transform(<<~ERB).strip
+      <%= render(FooComponent.new(bar: 'baz')) %>
+    ERB
+
+    expect(result).to eq('<FooComponent bar={"baz"} />')
+  end
+
+  it 'handles component renders with empty blocks' do
+    result = transform(<<~ERB).strip
+      <%= render(FooComponent.new(bar: 'baz')) do %>
+      <% end %>
+    ERB
+
+    expect(result).to eq(<<~RUX.strip)
+      <FooComponent bar={"baz"}>
+      </FooComponent>
+    RUX
+  end
+
+  it 'handles component renders with blocks that contain strings' do
+    result = transform(<<~ERB).strip
+      <%= render(FooComponent.new(bar: 'baz')) do %>
+        foobar
+      <% end %>
+    ERB
+
+    expect(result).to eq(<<~RUX.strip)
+      <FooComponent bar={"baz"}>
+        {"foobar"}
+      </FooComponent>
+    RUX
+  end
+
+  it 'handles component renders with blocks that contain code' do
+    result = transform(<<~ERB).strip
+      <%= render(FooComponent.new(bar: 'baz')) do %>
+        <%= foobar %>
+      <% end %>
+    ERB
+
+    expect(result).to eq(<<~RUX.strip)
+      <FooComponent bar={"baz"}>
+        {foobar}
+      </FooComponent>
+    RUX
+  end
+
+  it 'handles component renders with blocks that contain strings and code' do
+    result = transform(<<~ERB).strip
+      <%= render(FooComponent.new(bar: 'baz')) do %>
+        <%= foobar %> foobaz
+      <% end %>
+    ERB
+
+    expect(result).to eq(<<~RUX.strip)
+      <FooComponent bar={"baz"}>
+        {foobar +  "foobaz"}
+      </FooComponent>
+    RUX
+  end
+
+  it 'handles component renders with blocks that have a block arg' do
+    result = transform(<<~ERB).strip
+      <%= render(FooComponent.new(bar: 'baz')) do |component| %>
+      <% end %>
+    ERB
+
+    expect(result).to eq(<<~RUX.strip)
+      <FooComponent bar={"baz"} as={"component"}>
+      </FooComponent>
+    RUX
+  end
+
+  it 'handles component renders with blocks that have a block arg and code' do
+    result = transform(<<~ERB).strip
+      <%= render(FooComponent.new(bar: 'baz')) do |component| %>
+        <% component.sidebar do %>
+        <% end %>
+      <% end %>
+    ERB
+
+    expect(result).to eq(<<~RUX.strip)
+      <FooComponent bar={"baz"} as={"component"}>
+        {component.sidebar do
+        end}
+      </FooComponent>
+    RUX
+  end
+
+  it 'handles component renders with blocks that have a block arg and multiple expressions' do
+    result = transform(<<~ERB).strip
+      <%= render(FooComponent.new(bar: 'baz')) do |component| %>
+        <% component.sidebar do %>
+        <% end %>
+        <% component.main do %>
+        <% end %>
+      <% end %>
+    ERB
+
+    expect(result).to eq(<<~RUX.strip)
+      <FooComponent bar={"baz"} as={"component"}>
+        {component.sidebar do
+        end
+        component.main do
+        end}
+      </FooComponent>
+    RUX
+  end
+
+  it 'handles nesting other components inside blocks' do
+    result = transform(<<~ERB).strip
+      <%= render(FooComponent.new(bar: 'baz')) do |component| %>
+        <% component.sidebar do %>
+          <%= render(SidebarComponent.new) %>
+        <% end %>
+        <% component.main do %>
+          <%= render(MainComponent.new) %>
+        <% end %>
+      <% end %>
+    ERB
+
+    expect(result).to eq(<<~RUX.strip)
+      <FooComponent bar={"baz"} as={"component"}>
+        {component.sidebar do
+          <SidebarComponent />
+        end
+        component.main do
+          <MainComponent />
+        end}
+      </FooComponent>
+    RUX
+  end
+
+  it 'handles nesting other components with arguments inside blocks' do
+    result = transform(<<~ERB).strip
+      <%= render(FooComponent.new(bar: 'baz')) do |component| %>
+        <% component.sidebar do %>
+          <%= render(SidebarComponent.new(bar: 'baz')) %>
+        <% end %>
+        <% component.main do %>
+          <%= render(MainComponent.new(bar: 'baz')) %>
+        <% end %>
+      <% end %>
+    ERB
+
+    expect(result).to eq(<<~RUX.strip)
+      <FooComponent bar={"baz"} as={"component"}>
+        {component.sidebar do
+          <SidebarComponent bar={"baz"} />
+        end
+        component.main do
+          <MainComponent bar={"baz"} />
+        end}
+      </FooComponent>
+    RUX
+  end
+
+  it 'handles nesting other components with blocks' do
+    result = transform(<<~ERB).strip
+      <%= render(FooComponent.new(bar: 'baz')) do |component| %>
+        <% component.sidebar do %>
+          <%= render(SidebarComponent.new(bar: 'baz')) do %>
+          <% end %>
+        <% end %>
+        <% component.main do %>
+          <%= render(MainComponent.new(bar: 'baz')) do %>
+          <% end %>
+        <% end %>
+      <% end %>
+    ERB
+
+    expect(result).to eq(<<~RUX.strip)
+      <FooComponent bar={"baz"} as={"component"}>
+        {component.sidebar do
+          <SidebarComponent bar={"baz"}>
+          </SidebarComponent>
+        end
+        component.main do
+          <MainComponent bar={"baz"}>
+          </MainComponent>
+        end}
+      </FooComponent>
+    RUX
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: erb2rux
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Cameron Dutro
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: unparser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: Automatically convert .html.erb files into .rux files.
+email:
+- camertron@gmail.com
+executables:
+- erb2rux
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/erb2rux
+- erb2rux.gemspec
+- lib/erb2rux.rb
+- lib/erb2rux/component_render.rb
+- lib/erb2rux/transformer.rb
+- lib/erb2rux/version.rb
+- spec/spec_helper.rb
+- spec/transformer_spec.rb
+homepage: http://github.com/camertron/erb2rux
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: Automatically convert .html.erb files into .rux files.
+test_files: []