rerb 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c5447c563b19fb93588b116db35b0135642fcb6e91143dee1a91ad3cbe89967c
+  data.tar.gz: b4897e456dd1f51669f3ded89ec2d1482adea5f4385667b32db638adc43fb8f7
+SHA512:
+  metadata.gz: 512e6903850669d93e0e820ae21132026863cfac1e7230d84c38fd1f5512cd0631d01f8ce755f7b64a62dccdb78c63d55f71e60db5a54f3b8d150449cbc1b1de
+  data.tar.gz: e8f81f838b1990df6fbcd27769075a8d09b50a6ae8d7519758d452801fd76696f20caa17ea4f6c8ac725a047c99237456500c432bb926a58771d490fb6a75991

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,14 @@
+require: rubocop-rspec
+
+inherit_gem:
+  rubocop-shopify: rubocop.yml
+
+AllCops:
+  TargetRubyVersion: 3.2
+  NewCops: enable
+
+Gemspec/RequireMFA:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+3.2.2

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-09-14
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at castlehoneyjung@gmail.com. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Forthoney
+
+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,57 @@
+# RERB: WebAssembly Embedded Ruby
+
+Use ERB/rhtml to build DOMs in [ruby.wasm](https://github.com/ruby/ruby.wasm).
+
+RERB is an unopinionated tool for compiling ERB/rhtml into ruby.wasm DOM operations for building the DOM tree described in the source file. Specifically, it generates code which, when run on a Ruby VM on WASM, generate the desired DOM. 
+RERB is experimental and very young, so there are some usage caveats which you can read about [here](docs/capabilities.md).
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add RERB
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install RERB
+
+## Usage
+### For Developers
+The CLI is the recommended way to use RERB in development. The simplest way to call rerb would be to just do
+```bash
+rerb your-file.erb
+```
+RERB will compile this erb file into a HTML file which internally uses ruby.wasm DOM operations to generate the DOM in the erb file. If you want to save this output to a file, you can simply use the shell `>` operator to write the output into a file.
+```bash
+rerb your-file.erb > your-file.html
+```
+`your-file.html` is a fully valid HTML file, and is ready to be rendered on the browser, assuming the erb code itself contains all the necessary logic.
+
+There are other flags which help you customize some aesthetics of the generated code. For example,
+```bash
+rerb --template nil your-file.erb
+```
+will generate just the DOM operations without the HTML boilerplate. This would be useful if you already have a HTML file and are simply looking to extend.
+
+### For Browsers
+Running the code generated by RERB in a browser does not require RERB. It only needs `ruby.wasm` with the JS interop extension. This is easily available via CDN as shown [here](https://github.com/ruby/ruby.wasm/tree/main/packages/npm-packages/ruby-head-wasm-wasi).
+Alternatively, you can use one of the templates which have all of this automatically set up.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Reading the [capabilities (and limitations)](docs/capabilities.md) is highly recommended. The current limitations of RERB listed in the document would be a great place to start looking for places to possibly contribute.
+Bug reports and pull requests are welcome on GitHub at https://github.com/forthoney/rerb. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/forthoney/rerb/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the rerb project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/forthoney/rerb/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new do |task|
+  task.requires << "rubocop-rspec"
+end
+
+task default: [:spec, :rubocop]

data/Steepfile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+D = Steep::Diagnostic
+
+target :lib do
+  signature "sig"
+
+  check "lib" # Directory name
+  # library "better_html" # better_html does not have RBS yet
+
+  configure_code_diagnostics(D::Ruby.default) # `default` diagnostics setting (applies by default)
+end
+
+# target :test do
+#   signature "sig", "sig-private"
+#
+#   check "test"
+#
+#   # library "pathname"              # Standard libraries
+# end

data/docs/capabilities.md

@@ -0,0 +1,42 @@
+# What does RERB want to be?
+In short, RERB roughly mirrors how [React deals with JSX](https://facebook.github.io/jsx/). 
+Firstly, it borrows the principle that JSX is merely syntactic sugar over JS, and thus is not valid ECMAScript. JSX is instead precompiled by Babel into valid JS.
+Secondly, JSX is only one part of React, and a part that is unrelated to how components are updated. JSX is just an easy way to describe a DOM in code.
+
+The long answer is the following:
+## RERB is a _developer_'s tool, not a client-side package
+RERB is meant to be used by the developer to help them write code. It is not meant to be shipped to the client as an npm package.
+There are a couple of reasons behind this.
+1. Implementation Difficulty
+
+It is currently very difficult to ship Gems with Ruby on WASM. This problem holds for almost all popular interpreted languages that have some WASM implementation at the moment (e.g. pip and python). 
+It may be possible in a year or two to include Gems written in pure Ruby with a RubyVM running on WASM. 
+Unfortunately, RERB uses [better-html](https://github.com/Shopify/better-html), a Gem with C extensions, and these Gems will likely take longer to be shippable.
+
+2. Practical Considerations
+
+Even if a means to ship RERB to the client is developed, we should stop and ask - _should we?_ 
+Sending RERB over to the client would mean a larger download size for the client. 
+This may not seem like a huge issue, but considering the base Ruby Interpreter is already fairly large, it's good to save space where possible.
+There have been precedents of adding libraries increasing the WASM download size significantly, namely in Blazor WebAssembly.
+
+## RERB is an ERB Compiler, not a full UI Library/Framework
+At this current stage, RERB is not concerned with efficient re-rendering algorithms, components, or other features that libraries like React have.
+It is concerned with transforming easy-to-write ERB files into tedious DOM transformations.
+Once RERB finishes compilation, how exactly the rendering works is in the developer's hands.
+If you choose to rerender the entire page on every update, that is up to you. 
+If you choose a more fine grained, element-wise rerendering, that is also up to you.
+If you choose to build a library that extends upon rerb's output and applies a generalizable rerendering technique, that is also entirely up to you.
+This philosophy may change in the future, but RERB's current priority is in describing a DOM with erb, not DOM update algorithms.
+
+# Where is RERB currently?
+## Features
+RERB supports the vast majority of HTML deemed valid by the better-html Gem. There are some small pieces which are unsupported, none of which are significant
+- [ ] Strip from beginning or end of String via `<%-` and `-%>` (currently ignored entirely)
+- [ ] Attribute values without quotation marks (currently undefined behavior)
+
+## Rigidity
+RERB is quite brittle at the moment, and there are ongoing efforts to help make it more "error tolerant".
+- [ ] Attempting to commpile invalid HTML-ERB results in undefined behavior. It may error, or it may finish running and produce the wrong graph.
+- [ ] Improve better-html's Parser's output type.
+- [ ] More tests, particularly for the CLI.

data/exe/rerb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rerb/cli"
+RERB::CLI.parse(ARGV.dup)

data/lib/rerb/cli.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+require "rerb"
+require "rerb/templater"
+
+module RERB
+  # Command Line Interface for invoking RERB
+  module CLI
+    def parse(args)
+      parser = OptionParser.new do |o|
+        o.banner = "Usage: werb [options...] FILE"
+        o.on(
+          "--template TYPE",
+          ["umd", "iife", "nil"],
+          "Specify which html template to use to wrap the generated code. " \
+            "Valid options are umd, iife, and nil.",
+          "nil will use no template and just output raw ruby.wasm code. " \
+            "Defaults to umd",
+        )
+        o.on(
+          "--root NAME",
+          "The html id of the root element to add all other DOM nodes to. " \
+            'Defaults to "root"',
+        )
+        o.on("-v", "--version", "Output version information and exit.")
+      end
+      opts = {
+        template: "umd",
+        document: "document",
+        root: "root",
+        el_prefix: "el",
+      }
+      parser.parse!(args, into: opts)
+
+      filename = args.shift
+      return puts parser.help if filename.nil?
+
+      input = File.read(filename)
+      case opts[:template]
+      when "umd"
+        res = UMDTemplater.new(filename, opts[:root])
+          .generate(input)
+      when "iife"
+        res = IIFETemplater.new(filename, opts[:root])
+          .generate(input)
+      when "nil"
+        res = Templater.new(filename, opts[:root])
+          .generate(input)
+      else
+        raise "Invalid template option. Choose between umd, iife, nil."
+      end
+      puts res
+    end
+
+    module_function :parse
+  end
+end

data/lib/rerb/compiler.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "better_html"
+require "better_html/parser"
+require "better_html/tree/tag"
+
+require "rerb"
+require "rerb/ir"
+
+module RERB
+  # Compile ERB into ruby.wasm compatible code
+  class Compiler
+    SELF_CLOSING_TAGS = [
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "param",
+      "source",
+      "track",
+      "wbr",
+    ].freeze
+
+    Frame = Data.define(:name, :elems) do
+      # Frame is initialized with an empty array for its elems
+      def initialize(name:, elems: [])
+        super(name:, elems:)
+      end
+    end
+
+    def initialize(source, viewmodel_name, root_elem_name = "root")
+      @counter = 0
+      @parser = create_parser(source)
+      @viewmodel_name = viewmodel_name
+      @name_hash = Hash.new { |h, k| h[k] = 0 }
+      @root_elem_name = root_elem_name
+      @frames = [Frame[root_elem_name]]
+    end
+
+    def compile
+      <<~RESULT.chomp
+        class #{@viewmodel_name}
+          def initialize
+            setup_dom
+          end
+
+          private
+
+          def setup_dom
+        #{compile_body.gsub(/^/, "  " * 2)}
+          end
+
+          def document
+            JS.global[:document]
+          end
+
+          def root
+            document.getElementById("#{@root_elem_name}")
+          end
+        end
+
+        #{@viewmodel_name}.new
+      RESULT
+    end
+
+    def compile_body
+      dom_to_str(compile_ast(@parser.ast)).strip
+    end
+
+    private
+
+    def create_parser(source)
+      buffer = Parser::Source::Buffer.new("(buffer)", source:)
+      BetterHtml::Parser.new(buffer)
+    end
+
+    # Unfortunately, this very ugly pattern matching is the only way to
+    # pattern match the AST::Nodes from better-html
+    def compile_ast(node)
+      case node
+      in nil | [:quote, *]
+        IR::Ignore[]
+
+      in String
+        node.strip.empty? ? IR::Ignore[] : IR::Content[node.strip]
+
+      in [:erb, nil, start_trim, code, end_trim] # ERB statement
+        IR::RubyStatement[dom_to_str(compile_ast(code)).strip.to_s]
+
+      in [:erb, _ind, start_trim, code, end_trim] # ERB expression
+        IR::RubyExpr[dom_to_str(compile_ast(code)).strip.to_s]
+
+      in [:tag, nil, tag_name, tag_attr, _end_solidus] # Opening tag
+        tag_type = dom_to_str(compile_ast(tag_name))
+        el_name = generate_el_name(tag_type)
+        @frames << Frame[el_name]
+        attrs = dom_to_str(compile_ast(tag_attr))
+
+        create = IR::Create[el_name, "#{el_name} = document.createElement('#{tag_type}')\n#{attrs}"]
+        return create unless SELF_CLOSING_TAGS.include?(tag_type)
+
+        current_frame.elems << create
+        IR::Content[collect_frame(@frames.pop)]
+
+      in [:tag, _start_solidus, _tag_name, _tag_attr, _end_solidus] # Closing tag
+        IR::Content[collect_frame(@frames.pop)]
+
+      in [:attribute, attr_name, _eql_token, attr_value] # Attribute
+        name = dom_to_str(compile_ast(attr_name))
+        if name[0...2] == "on" # Event
+          value = dom_to_str(compile_ast(attr_value), interpolate: false)
+          IR::Content[%(#{current_frame.name}.addEventListener("#{name[2...]}", #{value})\n)]
+        elsif attr_value.nil? # Boolean attribute
+          IR::Content[%(#{current_frame.name}.setAttribute("#{name}", true)\n)]
+        else
+          value = dom_to_str(compile_ast(attr_value), interpolate: true)
+          IR::Content[%(#{current_frame.name}.setAttribute("#{name}", "#{value}")\n)]
+        end
+
+      in [:attribute_value, _start_quote, value, _end_quote]
+        compile_ast(value)
+
+      in [:code, code]
+        IR::Content["#{code.strip}\n"]
+
+      in [:text, *children]
+        IR::Content[join_text_children(children)]
+
+      in [:document, *] | [:tag_attributes, *]
+        IR::Content[collect_children(node.children, interpolate: false)]
+
+      in [:attribute_name, *] | [:tag_name, *]
+        IR::Content[collect_children(node.children, interpolate: true)]
+      end
+    end
+
+    def join_text_children(children)
+      f_name = current_frame.name
+      children.compact.map do |c|
+        case compile_ast(c)
+        in IR::RubyStatement(content)
+          "#{content}\n"
+        in IR::Ignore
+          ""
+        in IR::Content(content)
+          %(#{f_name}.appendChild(document.createTextNode("#{content}"))\n)
+        in IR::RubyExpr(content)
+          %(#{f_name}.appendChild(document.createTextNode("\#{#{content}}"))\n)
+        end
+      end.join
+    end
+
+    def dom_to_str(elem, interpolate: false)
+      case elem
+      in IR::Create(el_name, content)
+        content.to_s + "#{current_frame.name}.appendChild(#{el_name})\n"
+      in IR::Content(content)
+        content.to_s
+      in IR::RubyStatement(content)
+        content.to_s
+      in IR::RubyExpr(content)
+        interpolate ? "\#{#{content}}" : content.to_s
+      in IR::Ignore
+        ""
+      end
+    end
+
+    def collect_frame(frame, interpolate: false)
+      frame.elems.map { |e| dom_to_str(e, interpolate:) }.join
+    end
+
+    def collect_children(children, interpolate: false)
+      @frames << Frame[current_frame.name]
+
+      children.compact.each do |n|
+        # compile_ast must be evaluated BEFORE current_frame because current_frame
+        # must be reflective of the current frame after whatever mutations compile_ast did
+        compiled = compile_ast(n)
+        current_frame.elems << compiled
+      end
+
+      collect_frame(@frames.pop, interpolate:)
+    end
+
+    def current_frame
+      @frames.last or raise EmptyFrameError
+    end
+
+    def generate_el_name(tag_type)
+      @name_hash[tag_type] += 1
+      "@#{tag_type}_#{@name_hash[tag_type]}"
+    end
+  end
+end

data/lib/rerb/ir.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RERB
+  # Intermediate Representation Nodes
+  module IR
+    # Generic HTML Content
+    Content = Data.define(:content)
+    # Ruby expression. Analogous to <%= %>
+    RubyExpr = Data.define(:content)
+    # Ruby statement.  Analogous to <% %>
+    RubyStatement = Data.define(:content)
+    # Create DOM Node
+    Create = Data.define(:el_name, :content)
+    Ignore = Data.define
+  end
+end

data/lib/rerb/templater.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "erb"
+
+require "rerb"
+require "rerb/compiler"
+
+module RERB
+  class Templater
+    TEMPLATE = "<%= content %>"
+
+    def initialize(filename, root_name)
+      @viewmodel_name = File.basename(filename, ".*").split("_").map(&:capitalize).join
+      @root_name = root_name
+    end
+
+    def generate(input)
+      content = Compiler.new(input, @viewmodel_name, @root_name)
+        .compile
+      rhtml = ERB.new(self.class::TEMPLATE)
+      rhtml.result(binding)
+    end
+  end
+
+  class IIFETemplater < Templater
+    TEMPLATE = <<~TMPL.chomp
+      <html>
+        <head>
+          <script src="https://cdn.jsdelivr.net/npm/ruby-head-wasm-wasi@2.1.0/dist/browser.script.iife.js"></script>
+          <script type="text/ruby">
+            require 'js'
+
+      <%= content.gsub(/^(?!$)/, '  ' * 3) %>
+          </script>
+        </head>
+        <body>
+          <div id="<%= @root_name %>"></div>
+        </body>
+      </html>
+    TMPL
+  end
+
+  class UMDTemplater < Templater
+    TEMPLATE = <<~TMPL.chomp
+      <html>
+        <script src="https://cdn.jsdelivr.net/npm/@ruby/wasm-wasi@latest/dist/browser.umd.js"></script>
+        <script>
+          const { DefaultRubyVM } = window["ruby-wasm-wasi"];
+          const main = async () => {
+            // Fetch and instantiate WebAssembly binary
+            const response = await fetch(
+              //      Tips: Replace the binary with debug info if you want symbolicated stack trace.
+              //      (only nightly release for now)
+              //      "https://cdn.jsdelivr.net/npm/ruby-3_2-wasm-wasi@next/dist/ruby.debug+stdlib.wasm"
+              "https://cdn.jsdelivr.net/npm/ruby-3_2-wasm-wasi@latest/dist/ruby+stdlib.wasm"
+            );
+            const buffer = await response.arrayBuffer();
+            const module = await WebAssembly.compile(buffer);
+            const { vm } = await DefaultRubyVM(module);
+
+            vm.printVersion();
+            vm.eval(`
+              require 'js'
+
+      <%= content.gsub(/^(?!$)/, '  ' * 4) %>
+            `);
+          };
+
+          main();
+        </script>
+        <body>
+          <div id="<%= @root_name %>"></div>
+        </body>
+      </html>
+    TMPL
+  end
+end

data/lib/rerb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RERB
+  VERSION = "0.1.1"
+end

data/lib/rerb.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "rerb/version"
+require "rerb/compiler"
+require "rerb/templater"
+require "rerb/cli"
+require "rerb/ir"
+
+module RERB
+  class Error < StandardError; end
+
+  class EmptyFrameError < Error
+    def initialize(message = "Frames list is empty")
+      super
+      @message = message
+    end
+  end
+end

data/sig/rerb/cli.rbs

@@ -0,0 +1,5 @@
+module RERB
+  module CLI
+    def parse: (Array[String] args) -> void
+  end
+end

data/sig/rerb/compiler.rbs

@@ -0,0 +1,64 @@
+# Classes
+module BetterHtml
+  class Parser
+    def initialize: (untyped buffer) -> void
+    def ast: -> AST::Node
+  end
+
+  module AST
+    class Node
+      attr_reader children: Array[Node | String]
+      attr_reader type: Symbol
+    end
+  end
+end
+
+module RERB
+  # Compile ERB into ruby.wasm compatible code
+  class Compiler
+    class Frame < Data
+      attr_reader name: String
+      attr_reader elems: Array[IR::node]
+
+      def initialize: (String, ?Array[IR::node]) -> void
+    end
+
+    @counter: Integer
+
+    @parser: BetterHtml::Parser
+
+    @viewmodel_name: String
+
+    @name_hash: Hash[String, Integer]
+
+    @root_elem_name: String
+
+    @frames: Array[Frame]
+
+    def initialize: (String source,
+                     String viewmodel_name,
+                     ?String root_elem_name) -> void
+
+    def compile: () -> String
+
+    def compile_body: () -> String
+
+    private
+
+    def create_parser: (String source) -> BetterHtml::Parser
+
+    def compile_ast: (BetterHtml::AST::Node | String node) -> IR::node
+
+    def join_text_children: (Array[IR::node | nil] children) -> String
+
+    def dom_to_str: (IR::node elem, ?interpolate: bool) -> String
+
+    def collect_frame: (Frame frame, ?interpolate: bool) -> untyped
+
+    def collect_children: (Array[BetterHtml::AST::Node] children, ?interpolate: bool) -> untyped
+
+    def current_frame: () -> Frame
+
+    def generate_el_name: (String) -> String
+  end
+end

data/sig/rerb/ir.rbs

@@ -0,0 +1,12 @@
+module RERB
+  # Intermediate Representation Nodes
+  module IR
+    class Content < Data end
+    class RubyExpr < Data end
+    class RubyStatement < Data end
+    class Create < Data end
+    class Ignore < Data end
+
+    type node = Content | RubyExpr | RubyStatement | Create | Ignore
+  end
+end

data/sig/rerb/templater.rbs

@@ -0,0 +1,23 @@
+module RERB
+  class Templater
+    @viewmodel_name: String
+
+    @root_name: String
+
+    @el_name_prefix: String
+
+    TEMPLATE: String
+
+    def initialize: (String filename, String root_name) -> void
+
+    def generate: (String input) -> String
+  end
+
+  class IIFETemplater < Templater
+    TEMPLATE: String
+  end
+
+  class UMDTemplater < Templater
+    TEMPLATE: String
+  end
+end

data/sig/rerb.rbs

@@ -0,0 +1,15 @@
+module WERB
+  VERSION: String
+
+  class Error < StandardError
+  end
+
+  class PatternMatchError < Error
+  end
+
+  class EmptyFrameError < Error
+    @message: String
+
+    def initialize: (?::String message) -> void
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: rerb
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Forthoney
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-11-15 00:00:00.000000000 Z
+dependencies: []
+description: RERB is an unopinionated tool for compiling ERB/rhtml into ruby.wasm
+  DOM operations. It generates code which, when run on a Ruby VM on WASM, generate
+  the desired DOM.
+email:
+- castlehoneyjung@gmail.com
+executables:
+- rerb
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- Steepfile
+- docs/capabilities.md
+- exe/rerb
+- lib/rerb.rb
+- lib/rerb/cli.rb
+- lib/rerb/compiler.rb
+- lib/rerb/ir.rb
+- lib/rerb/templater.rb
+- lib/rerb/version.rb
+- sig/rerb.rbs
+- sig/rerb/cli.rbs
+- sig/rerb/compiler.rbs
+- sig/rerb/ir.rbs
+- sig/rerb/templater.rbs
+homepage: https://github.com/forthoney/werb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/forthoney/werb
+  source_code_uri: https://github.com/forthoney/rerb
+  changelog_uri: https://github.com/Forthoney/rerb/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.21
+signing_key: 
+specification_version: 4
+summary: Build a DOM for ruby.wasm with ERB
+test_files: []