ruby_ui_converter 0.1.0

data/lib/ruby_ui_converter/form_builder.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+module RubyUIConverter
+  # Translates Rails form-builder field calls (`form.text_field :name, ...`)
+  # found inside a `form_with` / `form_for` block into RubyUI form components
+  # (`Input`, `Textarea`, `Checkbox`, `FormFieldLabel`, `Button`), following the
+  # convention of building `name`/`id` as `"model[attr]"` and `value` as
+  # `model.attr`.
+  #
+  # Only active when `ruby_ui?` is on and the enclosing form has a determinable
+  # model, so the name/value can be reconstructed; otherwise the calls are left
+  # untouched (and the block keeps its `|form|` builder variable).
+  module FormBuilder
+    module_function
+
+    # form field method -> input type (nil = no explicit type, like text_field)
+    INPUT_TYPES = {
+      "text_field" => nil,
+      "email_field" => "email",
+      "password_field" => "password",
+      "number_field" => "number",
+      "telephone_field" => "tel",
+      "phone_field" => "tel",
+      "url_field" => "url",
+      "search_field" => "search",
+      "color_field" => "color",
+      "range_field" => "range",
+      "date_field" => "date",
+      "datetime_field" => "datetime-local",
+      "datetime_local_field" => "datetime-local",
+      "time_field" => "time",
+      "month_field" => "month",
+      "week_field" => "week",
+      "file_field" => "file"
+    }.freeze
+
+    TEXTAREA_METHODS = %w[text_area textarea].freeze
+    CHECKBOX_METHODS = %w[check_box checkbox].freeze
+
+    # Every builder method this module knows how to translate.
+    def mappable_methods
+      INPUT_TYPES.keys + TEXTAREA_METHODS + CHECKBOX_METHODS + %w[label submit collection_select]
+    end
+
+    # Parse a `form_with`/`form_for` block header into a form scope
+    # ({var:, model:, param:}) or nil when it isn't a model-bound form we can map.
+    def form_scope(header)
+      return nil unless header =~ /\A(form_with|form_for)\b/
+
+      var = header[/\bdo\s*\|\s*(\w+)\s*\|/, 1]
+      return nil unless var
+
+      model = model_expression(header)
+      return nil unless model
+
+      param = model.sub(/\A@/, "")
+      return nil unless param =~ /\A\w+\z/
+
+      { var: var, model: model, param: param }
+    end
+
+    def model_expression(header)
+      if (model = header[/\bmodel:\s*([^,)]+)/, 1])
+        return model.strip
+      end
+
+      return nil unless header =~ /\Aform_for\b/
+
+      rest = RailsHelpers.strip_parens(header.sub(/\Aform_for\b/, "").sub(/\bdo\b.*\z/m, "").strip)
+      RailsHelpers.split_args(rest).first&.strip
+    end
+
+    # True when the children contain a `form.<var>` call this module won't map,
+    # so the block variable must be kept.
+    def needs_block_var?(var, codes)
+      codes.any? do |code|
+        method = code[/\A#{Regexp.escape(var)}\.(\w+)/, 1]
+        method && !mappable_methods.include?(method)
+      end
+    end
+
+    # True when the code is a mappable form field call (so it should not be
+    # inlined as `{ ... }` but emitted through the field translation).
+    def form_field?(code, form)
+      return false unless form
+
+      method = code[/\A#{Regexp.escape(form[:var])}\.(\w+)/, 1]
+      method && mappable_methods.include?(method)
+    end
+
+    # Emit a form field call as a RubyUI component. Returns true when handled.
+    def transform(code, transformer, builder)
+      form = transformer.current_form
+      return false unless form
+
+      method = code[/\A#{Regexp.escape(form[:var])}\.(\w+)/, 1]
+      return false unless method
+
+      rest = code.sub(/\A#{Regexp.escape(form[:var])}\.\w+\s*/, "")
+      args = RailsHelpers.split_args(RailsHelpers.strip_parens(rest))
+
+      # collection_select expands into a NativeSelect with a loop, so it emits
+      # its (indented) block directly rather than returning flat lines.
+      return emit_collection_select(args, form, builder) if method == "collection_select"
+
+      lines = build(method, args, form)
+      return false unless lines
+
+      Array(lines).each { |line| builder.line(line) }
+      true
+    end
+
+    # form.collection_select :category_id, Category.all, :id, :name ->
+    #   NativeSelect(name:, id:) do
+    #     Category.all.each do |option|
+    #       NativeSelectOption(value: option.id, selected: model.category_id == option.id) { option.name }
+    #     end
+    #   end
+    #   FormFieldError { ... }
+    # (extra options/html_options beyond the four positionals are not carried over)
+    def emit_collection_select(args, form, builder)
+      attr = attr_name(args[0])
+      value_method = attr_name(args[2])
+      text_method = attr_name(args[3])
+      return false unless attr && args[1] && value_method && text_method
+
+      collection = args[1].strip
+      builder.line("NativeSelect(#{name_and_id(form, attr)}) do")
+      builder.indent
+      builder.line("#{collection}.each do |option|")
+      builder.indent
+      builder.line(
+        "NativeSelectOption(value: option.#{value_method}, " \
+        "selected: #{form[:model]}.#{attr} == option.#{value_method}) { option.#{text_method} }"
+      )
+      builder.dedent
+      builder.line("end")
+      builder.dedent
+      builder.line("end")
+      builder.line(error_line(form, attr))
+      true
+    end
+
+    # Returns a line (or array of lines) for the field, or nil when unmappable.
+    # Input/textarea/checkbox additionally get a FormFieldError reading the
+    # attribute's backend errors, like the RubyUI form convention.
+    def build(method, args, form)
+      if INPUT_TYPES.key?(method)
+        with_error(input_field(method, args, form), args, form)
+      elsif TEXTAREA_METHODS.include?(method)
+        with_error(textarea_field(args, form), args, form)
+      elsif CHECKBOX_METHODS.include?(method)
+        with_error(checkbox_field(args, form), args, form)
+      elsif method == "label"
+        label_field(args, form)
+      elsif method == "submit"
+        submit_button(args)
+      end
+    end
+
+    def with_error(component, args, form)
+      return nil unless component
+
+      [component, error_line(form, attr_name(args[0]))]
+    end
+
+    # FormFieldError { product.errors[:name].to_sentence.upcase_first }
+    def error_line(form, attr)
+      "FormFieldError { #{form[:model]}.errors[:#{attr}].to_sentence.upcase_first }"
+    end
+
+    def input_field(method, args, form)
+      attr = attr_name(args[0])
+      return nil unless attr
+
+      parts = []
+      if (type = INPUT_TYPES[method])
+        parts << %(type: "#{type}")
+      end
+      parts << name_and_id(form, attr)
+      parts << "value: #{field_value(form, attr)}"
+      parts.concat(args[1..] || [])
+      "Input(#{parts.join(", ")})"
+    end
+
+    def textarea_field(args, form)
+      attr = attr_name(args[0])
+      return nil unless attr
+
+      parts = [name_and_id(form, attr)].concat(args[1..] || [])
+      "Textarea(#{parts.join(", ")}) { #{field_value(form, attr)} }"
+    end
+
+    # HTML attribute values are strings; calling #to_s keeps Phlex happy for
+    # non-string columns (decimal/BigDecimal, integer, date, nil, ...) which it
+    # would otherwise reject as invalid attribute values.
+    def field_value(form, attr)
+      "#{form[:model]}.#{attr}.to_s"
+    end
+
+    def checkbox_field(args, form)
+      attr = attr_name(args[0])
+      return nil unless attr
+
+      parts = [%(value: "1"), name_and_id(form, attr), "checked: #{form[:model]}.#{attr}?"]
+      parts.concat(args[1..] || [])
+      "Checkbox(#{parts.join(", ")})"
+    end
+
+    def label_field(args, form)
+      attr = attr_name(args[0])
+      return nil unless attr
+
+      text = string_arg?(args[1]) ? args[1].strip : %("#{humanize(attr)}")
+      %(FormFieldLabel(for: "#{form[:param]}[#{attr}]") { #{text} })
+    end
+
+    def submit_button(args)
+      if string_arg?(args[0])
+        text = args[0].strip
+        opts = args[1..] || []
+      else
+        text = '"Save"'
+        opts = args
+      end
+
+      call = opts.empty? ? %(Button(type: "submit")) : %(Button(type: "submit", #{opts.join(", ")}))
+      "#{call} { #{text} }"
+    end
+
+    # "product" + "name" -> name: "product[name]", id: "product[name]"
+    def name_and_id(form, attr)
+      key = %("#{form[:param]}[#{attr}]")
+      "name: #{key}, id: #{key}"
+    end
+
+    # ":name" / "\"name\"" -> "name"
+    def attr_name(arg)
+      return nil unless arg
+
+      arg.strip.sub(/\A:/, "").gsub(/\A["']|["']\z/, "")[/\A\w+\z/]
+    end
+
+    def string_arg?(arg)
+      arg && arg.strip.start_with?('"', "'")
+    end
+
+    def humanize(attr)
+      attr.tr("_", " ").capitalize
+    end
+  end
+end

data/lib/ruby_ui_converter/html_tokenizer.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module RubyUIConverter
+  # A small, forgiving HTML tokenizer. It does not validate markup; it emits a
+  # flat stream of tokens that the Parser turns into a tree. ERB placeholders
+  # (from the Lexer) are treated as ordinary text/attribute characters.
+  #
+  # Token shapes:
+  #   [:text, string]
+  #   [:html_comment, inner]
+  #   [:doctype, raw]
+  #   [:open, name, attrs]        attrs => [[name, value_or_nil], ...]
+  #   [:selfclose, name, attrs]
+  #   [:close, name]
+  #   [:raw_element, name, attrs, inner_text]   (script/style)
+  class HtmlTokenizer
+    VOID = %w[area base br col embed hr img input link meta param source track wbr].freeze
+    RAW = %w[script style].freeze
+
+    def initialize(html)
+      @s = StringScanner.new(html.to_s)
+    end
+
+    def tokens
+      out = []
+
+      until @s.eos?
+        if @s.scan(/<!--(.*?)-->/m)
+          out << [:html_comment, @s[1]]
+        elsif @s.scan(/<!\[CDATA\[.*?\]\]>/m)
+          out << [:text, @s.matched]
+        elsif @s.scan(/<![^>]*>/m)
+          out << [:doctype, @s.matched]
+        elsif @s.scan(%r{</\s*([a-zA-Z][\w:-]*)\s*>})
+          out << [:close, @s[1]]
+        elsif @s.scan(/<([a-zA-Z][\w:-]*)/)
+          out << scan_tag(@s[1])
+        else
+          text = @s.scan(/[^<]+/) || @s.getch
+          out << [:text, text]
+        end
+      end
+
+      out
+    end
+
+    private
+
+    def scan_tag(name)
+      attrs, self_close = scan_attrs
+
+      if RAW.include?(name.downcase) && !self_close
+        inner = scan_raw_content(name)
+        [:raw_element, name, attrs, inner]
+      elsif self_close || VOID.include?(name.downcase)
+        [:selfclose, name, attrs]
+      else
+        [:open, name, attrs]
+      end
+    end
+
+    def scan_attrs
+      attrs = []
+
+      loop do
+        @s.skip(/\s+/)
+
+        return [attrs, true] if @s.scan(%r{/\s*>})
+        return [attrs, false] if @s.scan(/>/)
+        return [attrs, false] if @s.eos?
+
+        if @s.scan(%r{([^\s=/>]+)})
+          name = @s[1]
+          value = nil
+
+          if @s.skip(/\s*=\s*/)
+            value =
+              if @s.scan(/"([^"]*)"/)
+                @s[1]
+              elsif @s.scan(/'([^']*)'/)
+                @s[1]
+              elsif @s.scan(/([^\s>]+)/)
+                @s[1]
+              end
+          end
+
+          attrs << [name, value]
+        else
+          @s.getch # defensive: never loop forever
+        end
+      end
+    end
+
+    def scan_raw_content(name)
+      closing = %r{</\s*#{Regexp.escape(name)}\s*>}im
+      captured = @s.scan_until(closing)
+
+      if captured
+        captured.sub(closing, "")
+      else
+        rest = @s.rest
+        @s.terminate
+        rest
+      end
+    end
+  end
+end

data/lib/ruby_ui_converter/lexer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RubyUIConverter
+  # Splits an ERB document into HTML (with placeholders) + a registry of ERB
+  # tokens. Each ERB tag is replaced in the source by a unique placeholder so
+  # the HTML tokenizer can run over a well-formed string even when ERB appears
+  # inside tags/attributes. The placeholder uses only [A-Za-z0-9_] characters,
+  # which the HTML tokenizer treats as inert text/identifiers.
+  class Lexer
+    Token = Struct.new(:type, :value, :raw, keyword_init: true)
+
+    # Matches <% %>, <%= %>, <%== %>, <%# %> with optional trim markers (<%- -%>).
+    PATTERN = /<%(={1,2}|#|-)?(.*?)(-)?%>/m
+
+    PLACEHOLDER_PREFIX = "RUCxERBx"
+    PLACEHOLDER_SUFFIX = "xERBxRUC"
+    PLACEHOLDER_PATTERN = /RUCxERBx(\d+)xERBxRUC/
+
+    def initialize(source)
+      @source = source.to_s
+    end
+
+    # @return [Array(String, Hash{String => Token})]
+    def tokenize_with_placeholders
+      registry = {}
+      index = 0
+
+      html = @source.gsub(PATTERN) do
+        marker = Regexp.last_match(1)
+        code = Regexp.last_match(2)
+        key = self.class.placeholder(index)
+        registry[key] = build_token(marker, code)
+        index += 1
+        key
+      end
+
+      [html, registry]
+    end
+
+    def build_token(marker, code)
+      code = code.to_s
+      case marker
+      when "#"
+        Token.new(type: :comment, value: code.strip, raw: false)
+      when "="
+        Token.new(type: :output, value: code.strip, raw: false)
+      when "=="
+        Token.new(type: :output, value: code.strip, raw: true)
+      else
+        Token.new(type: :eval, value: code.strip, raw: false)
+      end
+    end
+
+    def self.placeholder(index)
+      "#{PLACEHOLDER_PREFIX}#{index}#{PLACEHOLDER_SUFFIX}"
+    end
+  end
+end

data/lib/ruby_ui_converter/locals_detector.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "set"
+
+module RubyUIConverter
+  # Heuristically detects the locals a partial expects, so the generated
+  # component can declare keyword arguments and private readers.
+  #
+  # This is intentionally conservative and best-effort: it favors a few clearly
+  # detectable cases (local_assigns[:x]) plus bare identifiers that look like
+  # locals. Anything it misses can be added by hand to the generated component.
+  class LocalsDetector
+    KEYWORDS = %w[
+      if elsif else end unless case when in while until for do begin rescue
+      ensure return yield self nil true false and or not then break next redo
+      retry def class module super defined lambda proc new raise puts print p
+      require require_relative attr_reader attr_accessor attr_writer
+    ].to_set
+
+    def initialize(tree)
+      @tree = tree
+    end
+
+    def locals
+      codes = []
+      collect(@tree.children, codes)
+
+      found = Set.new
+      assigned = Set.new
+      block_params = Set.new
+
+      codes.each do |code|
+        code.scan(/\|([^|]*)\|/) do
+          Regexp.last_match(1).split(",").each do |param|
+            block_params << param.strip.sub(/\A\*+/, "").sub(/:.*\z/, "").strip
+          end
+        end
+        code.scan(/([a-z_]\w*)\s*=(?!=)/) { assigned << Regexp.last_match(1) }
+        code.scan(/local_assigns\[:(\w+)\]/) { found << Regexp.last_match(1) }
+        code.scan(/local_assigns\.fetch\(:(\w+)/) { found << Regexp.last_match(1) }
+      end
+
+      codes.each do |code|
+        without_strings = code.gsub(/"[^"]*"|'[^']*'/, " ")
+        without_strings.scan(/(?<![.\w:@$])([a-z_]\w*)/) do
+          name = Regexp.last_match(1)
+          after = Regexp.last_match.post_match
+
+          next if after =~ /\A\s*\(/          # method call
+          next if after =~ /\A\s*=(?!=)/      # assignment target
+          next if after =~ /\A:(?!:)/         # keyword/hash key
+          next if KEYWORDS.include?(name)
+          next if RailsHelpers::HTML_HELPERS.include?(name)
+          next if RailsHelpers::KNOWN_HELPERS.include?(name)
+          next if block_params.include?(name)
+          next if assigned.include?(name)
+
+          found << name
+        end
+      end
+
+      found.delete("local_assigns")
+      found.to_a.sort
+    end
+
+    # Instance variables a top-level view reads from its controller (`@products`),
+    # so the generated component can take them as keyword arguments. Excludes any
+    # ivar assigned within the template and class variables (`@@foo`). Strings are
+    # stripped first, like #locals, to avoid `@` inside literals (`"x@y.com"`).
+    def ivars
+      codes = []
+      collect(@tree.children, codes)
+
+      found = Set.new
+      assigned = Set.new
+
+      codes.each do |code|
+        without_strings = code.gsub(/"[^"]*"|'[^']*'/, " ")
+        without_strings.scan(/(?<!@)@([a-zA-Z_]\w*)\s*=(?!=)/) { assigned << Regexp.last_match(1) }
+        without_strings.scan(/(?<!@)@([a-zA-Z_]\w*)/) { found << Regexp.last_match(1) }
+      end
+
+      (found - assigned).to_a.sort
+    end
+
+    private
+
+    def collect(nodes, codes)
+      nodes.each do |node|
+        case node
+        when Nodes::Output, Nodes::Statement
+          codes << node.code
+        when Nodes::Control
+          node.branches.each do |branch|
+            codes << branch.header
+            collect(branch.children, codes)
+          end
+        when Nodes::Element
+          node.attributes.each do |(_, parts)|
+            next unless parts
+
+            parts.each do |kind, value|
+              codes << value.value if kind == :erb
+            end
+          end
+          collect(node.children, codes)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_ui_converter/naming.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyUIConverter
+  # Converts file paths into Ruby constant names following Rails-ish
+  # conventions: app/views/users/index.html.erb -> Views::Users::Index.
+  module Naming
+    module_function
+
+    def camelize(string)
+      string.to_s.split(/[_\-\s]+/).reject(&:empty?).map do |part|
+        part[0].upcase + part[1..].to_s
+      end.join
+    end
+
+    # Class name for a template basename ("index" / "_form" -> Index / Form).
+    def class_name(basename)
+      camelize(basename.sub(/\A_/, ""))
+    end
+
+    # Module segments derived from base namespace + relative directory.
+    # ("users", "Views") -> ["Views", "Users"]
+    def namespace_parts(dir_rel, base_namespace)
+      base_parts = base_namespace.to_s.split("::").reject(&:empty?)
+      dir_parts = dir_rel.to_s.split("/").reject(&:empty?).map { |part| camelize(part) }
+      base_parts + dir_parts
+    end
+
+    # Resolves a render partial path to a fully-qualified constant.
+    #   "shared/header" -> "Views::Shared::Header"
+    #   "form"          -> "<current namespace>::Form"
+    def partial_const(path, base_namespace:, current_namespace_parts: [])
+      segments = path.to_s.split("/")
+      name = segments.pop.to_s.sub(/\A_/, "")
+
+      if path.to_s.include?("/")
+        base_parts = base_namespace.to_s.split("::").reject(&:empty?)
+        dir_parts = segments.map { |segment| camelize(segment) }
+        (base_parts + dir_parts + [camelize(name)]).join("::")
+      else
+        current = current_namespace_parts.empty? ? [base_namespace.to_s].reject(&:empty?) : current_namespace_parts
+        (current + [camelize(name)]).join("::")
+      end
+    end
+  end
+end

data/lib/ruby_ui_converter/nodes.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RubyUIConverter
+  # AST node types produced by the Parser and consumed by the Transformer.
+  #
+  # Attribute values are stored as "parts": an array whose entries are either
+  # `[:text, "literal"]` or `[:erb, <Lexer::Token>]`. This lets the transformer
+  # decide between a plain string, a bare Ruby expression or an interpolated
+  # string when emitting the attribute.
+  module Nodes
+    class Base; end
+
+    class Document < Base
+      attr_reader :children
+
+      def initialize
+        @children = []
+      end
+    end
+
+    class Element < Base
+      attr_reader :name, :attributes, :children
+      attr_accessor :self_closing
+
+      def initialize(name:, attributes: [], self_closing: false)
+        @name = name
+        @attributes = attributes
+        @children = []
+        @self_closing = self_closing
+      end
+
+      # Returns the literal value of an attribute when it has no ERB parts,
+      # otherwise nil. Useful for ComponentMap matchers/emitters.
+      def static_attr(name)
+        attr = attributes.find { |attr_name, _| attr_name == name }
+        return nil unless attr && attr[1]
+        return nil unless attr[1].all? { |kind, _| kind == :text }
+
+        attr[1].map { |_, value| value }.join
+      end
+
+      # Returns the static CSS classes when the `class` attribute has no ERB,
+      # otherwise an empty array. Useful for ComponentMap matchers.
+      def static_classes
+        static_attr("class").to_s.split
+      end
+
+      def attr?(name)
+        attributes.any? { |attr_name, _| attr_name == name }
+      end
+    end
+
+    class Text < Base
+      attr_reader :content
+
+      def initialize(content:)
+        @content = content
+      end
+    end
+
+    # Raw inner content of <script>/<style> elements (kept verbatim).
+    class RawText < Base
+      attr_reader :content
+
+      def initialize(content:)
+        @content = content
+      end
+    end
+
+    # <%= code %> or <%== code %>
+    class Output < Base
+      attr_reader :code, :raw
+
+      def initialize(code:, raw: false)
+        @code = code
+        @raw = raw
+      end
+    end
+
+    # <% code %> that is a plain statement (assignment, method call, etc.)
+    class Statement < Base
+      attr_reader :code
+
+      def initialize(code:)
+        @code = code
+      end
+    end
+
+    class Comment < Base
+      attr_reader :text, :html
+
+      def initialize(text:, html: false)
+        @text = text
+        @html = html
+      end
+    end
+
+    class Doctype < Base
+      attr_reader :value
+
+      def initialize(value:)
+        @value = value
+      end
+    end
+
+    # A single branch of a control structure (if / elsif / else / when / each-do...).
+    class Branch
+      attr_reader :header, :children
+
+      def initialize(header:)
+        @header = header
+        @children = []
+      end
+    end
+
+    # if/unless/case/while statements and `... do |x|` blocks.
+    class Control < Base
+      attr_reader :branches
+      attr_accessor :block, :output
+
+      def initialize(block: false, output: false)
+        @branches = []
+        @block = block
+        @output = output
+      end
+    end
+  end
+end