ruby_ui_converter 0.1.0

data/lib/ruby_ui_converter/parser.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module RubyUIConverter
+  # Builds a unified HTML + ERB tree from a source template.
+  #
+  # The tricky part is that HTML nesting (tags) and Ruby nesting (if/each/do
+  # ... end) interleave. We track both on a single stack and pop tolerantly so
+  # that well-formed templates produce a correct tree and slightly malformed
+  # ones degrade gracefully instead of raising.
+  class Parser
+    def initialize(source)
+      @html, @registry = Lexer.new(source).tokenize_with_placeholders
+    end
+
+    def parse
+      root = Nodes::Document.new
+      stack = [root]
+
+      HtmlTokenizer.new(@html).tokens.each do |token|
+        dispatch(token, stack)
+      end
+
+      root
+    end
+
+    private
+
+    def dispatch(token, stack)
+      case token[0]
+      when :text
+        emit_text(token[1], stack)
+      when :html_comment
+        append(stack, Nodes::Comment.new(text: strip_placeholders(token[1]), html: true))
+      when :doctype
+        append(stack, Nodes::Doctype.new(value: token[1]))
+      when :open
+        element = Nodes::Element.new(name: token[1], attributes: build_attrs(token[2]))
+        append(stack, element)
+        stack.push(element)
+      when :selfclose
+        append(stack, Nodes::Element.new(name: token[1], attributes: build_attrs(token[2]), self_closing: true))
+      when :raw_element
+        element = Nodes::Element.new(name: token[1], attributes: build_attrs(token[2]))
+        element.children << Nodes::RawText.new(content: token[3]) unless token[3].to_s.strip.empty?
+        append(stack, element)
+      when :close
+        close_element(stack, token[1])
+      end
+    end
+
+    # --- tree helpers ------------------------------------------------------
+
+    def append(stack, node)
+      container(stack.last) << node
+    end
+
+    def container(node)
+      case node
+      when Nodes::Control
+        node.branches.last.children
+      else
+        node.children
+      end
+    end
+
+    def close_element(stack, name)
+      target = name.to_s.downcase
+      index = stack.rindex { |node| node.is_a?(Nodes::Element) && node.name.to_s.downcase == target }
+      stack.slice!(index..) if index && index.positive?
+    end
+
+    def close_control(stack)
+      while stack.size > 1
+        node = stack.pop
+        break if node.is_a?(Nodes::Control)
+      end
+    end
+
+    # --- text + ERB --------------------------------------------------------
+
+    def emit_text(text, stack)
+      split_parts(text).each do |kind, value|
+        if kind == :text
+          append(stack, Nodes::Text.new(content: value)) unless value.empty?
+        else
+          emit_erb(value, stack)
+        end
+      end
+    end
+
+    def emit_erb(token, stack)
+      case token.type
+      when :output
+        if block_opener?(token.value)
+          control = Nodes::Control.new(block: true, output: true)
+          control.branches << Nodes::Branch.new(header: token.value)
+          append(stack, control)
+          stack.push(control)
+        else
+          append(stack, Nodes::Output.new(code: token.value, raw: token.raw))
+        end
+      when :comment
+        append(stack, Nodes::Comment.new(text: token.value, html: false))
+      when :eval
+        handle_eval(token.value, stack)
+      end
+    end
+
+    def handle_eval(code, stack)
+      case classify(code)
+      when :opener
+        control = Nodes::Control.new(block: block_opener?(code))
+        control.branches << Nodes::Branch.new(header: code)
+        append(stack, control)
+        stack.push(control)
+      when :mid
+        control = stack.reverse.find { |node| node.is_a?(Nodes::Control) }
+        if control
+          control.branches << Nodes::Branch.new(header: code)
+          stack.pop until stack.last.equal?(control) || stack.size <= 1
+        else
+          append(stack, Nodes::Statement.new(code: code))
+        end
+      when :close
+        close_control(stack)
+      else
+        append(stack, Nodes::Statement.new(code: code))
+      end
+    end
+
+    def classify(code)
+      stripped = code.strip
+      return :close if stripped == "end"
+      return :mid if stripped =~ /\A(else|elsif|when|in|rescue|ensure)\b/
+      return :opener if stripped =~ /\A(if|unless|case|while|until|for|begin)\b/
+      return :opener if block_opener?(stripped)
+
+      :statement
+    end
+
+    def block_opener?(code)
+      code =~ /\bdo\s*(\|[^|]*\|)?\s*\z/ ? true : false
+    end
+
+    # --- attributes + placeholders ----------------------------------------
+
+    def build_attrs(raw_attrs)
+      raw_attrs.map do |name, value|
+        if name.include?("RUCxERBx") && value.nil?
+          [:__splat__, split_parts(name)]
+        else
+          [name, value.nil? ? nil : split_parts(value)]
+        end
+      end
+    end
+
+    def split_parts(string)
+      parts = []
+      pos = 0
+      str = string.to_s
+
+      str.scan(Lexer::PLACEHOLDER_PATTERN) do
+        match = Regexp.last_match
+        parts << [:text, str[pos...match.begin(0)]] if match.begin(0) > pos
+        parts << [:erb, @registry.fetch(Lexer.placeholder(match[1]))]
+        pos = match.end(0)
+      end
+
+      parts << [:text, str[pos..]] if pos < str.length
+      parts
+    end
+
+    def strip_placeholders(string)
+      split_parts(string).map do |kind, value|
+        kind == :text ? value : value.value.to_s
+      end.join
+    end
+  end
+end

data/lib/ruby_ui_converter/rails_helpers.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module RubyUIConverter
+  # Best-effort translation of common Rails view helpers found inside <%= %>
+  # into Phlex/RubyUI equivalents. Anything not understood is emitted as a bare
+  # call (phlex-rails registers these as output helpers that write to the buffer
+  # themselves) or, for the few that return a string, through a raw call.
+  module RailsHelpers
+    module_function
+
+    # Rails helpers that produce HTML. Under phlex-rails these are output
+    # helpers (they write to the buffer and return nil), so an unmapped one is
+    # emitted as a bare call — except STRING_HELPERS below, which return a value.
+    HTML_HELPERS = %w[
+      link_to button_to image_tag video_tag audio_tag content_tag tag
+      form_with form_for fields_for label_tag text_field_tag mail_to
+      link_to_unless link_to_if sanitize simple_format raw safe_join
+      time_tag favicon_link_tag stylesheet_link_tag javascript_include_tag
+    ].freeze
+
+    # The subset of HTML_HELPERS that RETURN a string instead of writing to the
+    # Phlex buffer, so they must be wrapped in a raw call to appear in the output.
+    STRING_HELPERS = %w[sanitize safe_join raw strip_tags].freeze
+
+    # Helpers that return plain (already-escaped or scalar) values.
+    KNOWN_HELPERS = %w[
+      t l translate localize number_to_currency number_with_delimiter
+      number_to_percentage pluralize truncate current_user current_page?
+      params session flash request cookies asset_path image_path url_for
+      polymorphic_path time_ago_in_words distance_of_time_in_words
+      dom_id dom_class notice alert content_for cycle render
+    ].freeze
+
+    # Attempts to emit a transformed helper. Returns true when it wrote
+    # something to the builder, false otherwise.
+    def transform(code, node, transformer, builder)
+      stripped = code.strip
+
+      if stripped == "yield" || stripped =~ /\Ayield\b/
+        builder.line(stripped)
+        return true
+      end
+
+      if stripped.start_with?("render")
+        rendered = safe { render_call(stripped, transformer) }
+        # phlex-rails' #render handles model objects / relations and writes to
+        # the buffer itself, so the object/collection fallback is a bare call.
+        builder.line(rendered || stripped)
+        return true
+      end
+
+      if stripped.start_with?("link_to")
+        rendered = safe { link_to_call(stripped, ruby_ui: transformer.config.ruby_ui?) }
+        return builder.line(rendered) && true if rendered
+      end
+
+      if stripped.start_with?("image_tag")
+        rendered = safe { image_tag_call(stripped) }
+        return builder.line(rendered) && true if rendered
+      end
+
+      if stripped.start_with?("content_tag")
+        rendered = safe { content_tag_call(stripped) }
+        return builder.line(rendered) && true if rendered
+      end
+
+      if html_helper?(stripped)
+        # Output helpers write to the buffer (bare call); string-returning ones
+        # need a raw call to be emitted.
+        builder.line(string_helper?(stripped) ? transformer.config.raw_call(stripped) : stripped)
+        return true
+      end
+
+      false
+    end
+
+    def html_helper?(code)
+      matches_helper?(code, HTML_HELPERS)
+    end
+
+    def string_helper?(code)
+      matches_helper?(code, STRING_HELPERS)
+    end
+
+    def matches_helper?(code, helpers)
+      helpers.any? do |helper|
+        code == helper || code.start_with?("#{helper}(") || code.start_with?("#{helper} ")
+      end
+    end
+
+    # render "shared/header" / render partial: "x", locals: {..} / render "form", a: 1
+    def render_call(code, transformer)
+      rest = strip_parens(code.sub(/\Arender\b/, "").strip)
+      args = split_args(rest)
+      return nil if args.empty?
+
+      first = args[0]
+      first = Regexp.last_match(1).strip if first =~ /\Apartial:\s*(.+)\z/m
+
+      match = first.match(/\A["']([^"']+)["']\z/)
+      return nil unless match
+
+      const = Naming.partial_const(
+        match[1],
+        base_namespace: transformer.base_namespace,
+        current_namespace_parts: transformer.current_namespace_parts
+      )
+      locals = build_locals(args[1..])
+      locals ? "render #{const}.new(#{locals})" : "render #{const}.new"
+    end
+
+    def build_locals(arg_list)
+      return nil if arg_list.nil? || arg_list.empty?
+
+      pairs = arg_list.map do |arg|
+        if arg =~ /\Alocals:\s*\{(.*)\}\z/m
+          Regexp.last_match(1).strip
+        else
+          arg
+        end
+      end
+
+      result = pairs.reject(&:empty?).join(", ")
+      result.empty? ? nil : result
+    end
+
+    # link_to "Text", path, class: "x" -> a(href: path, class: "x") { "Text" }
+    # With ruby_ui enabled               -> Link(href: path, class: "x") { "Text" }
+    def link_to_call(code, ruby_ui: false)
+      return nil if code =~ /\bdo\b/ # block form handled elsewhere
+
+      rest = strip_parens(code.sub(/\Alink_to\b/, "").strip)
+      args = split_args(rest)
+      return nil if args.length < 2
+
+      text, path, *options = args
+      attrs = ["href: #{link_target(path)}"] + options
+      call = ruby_ui ? "Link" : "a"
+      "#{call}(#{attrs.join(", ")}) { #{text} }"
+    end
+
+    # Targets that are not strings or route helper calls (e.g. a record:
+    # `link_to "Show", user`) need url_for to resolve to a path.
+    def link_target(path)
+      return path if path.start_with?('"', "'") # literal string
+      return path if path =~ /\A(\w+_)?(path|url)\b/ # route helper call
+
+      "url_for(#{path})"
+    end
+
+    # image_tag "logo.png", alt: "Logo" -> img(src: "logo.png", alt: "Logo")
+    def image_tag_call(code)
+      rest = strip_parens(code.sub(/\Aimage_tag\b/, "").strip)
+      args = split_args(rest)
+      return nil if args.empty?
+
+      src, *options = args
+      attrs = ["src: #{src}"] + options
+      "img(#{attrs.join(", ")})"
+    end
+
+    # content_tag(:div, "hi", class: "x") -> div(class: "x") { "hi" }
+    def content_tag_call(code)
+      rest = strip_parens(code.sub(/\Acontent_tag\b/, "").strip)
+      args = split_args(rest)
+      return nil if args.length < 2
+
+      name = args[0].sub(/\A:/, "").gsub(/['"]/, "")
+      content = args[1]
+      options = args[2..] || []
+      call = options.empty? ? name : "#{name}(#{options.join(", ")})"
+      "#{call} { #{content} }"
+    end
+
+    # Splits a top-level argument list, respecting strings and nested brackets.
+    def split_args(string)
+      args = []
+      depth = 0
+      current = +""
+      quote = nil
+
+      string.each_char do |char|
+        if quote
+          current << char
+          quote = nil if char == quote
+          next
+        end
+
+        case char
+        when '"', "'"
+          quote = char
+          current << char
+        when "(", "[", "{"
+          depth += 1
+          current << char
+        when ")", "]", "}"
+          depth -= 1
+          current << char
+        when ","
+          if depth.zero?
+            args << current.strip
+            current = +""
+          else
+            current << char
+          end
+        else
+          current << char
+        end
+      end
+
+      args << current.strip unless current.strip.empty?
+      args
+    end
+
+    def strip_parens(string)
+      stripped = string.strip
+      if stripped.start_with?("(") && stripped.end_with?(")")
+        stripped[1..-2].strip
+      else
+        stripped
+      end
+    end
+
+    def safe
+      yield
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/ruby_ui_converter/template.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module RubyUIConverter
+  # Represents a single .erb file and knows how to render its .rb equivalent.
+  class Template
+    attr_reader :path, :root, :config
+
+    def initialize(path:, root:, config:)
+      @path = path
+      @root = root.to_s
+      @config = config
+    end
+
+    def source
+      @source ||= File.read(path)
+    end
+
+    def filename
+      File.basename(path)
+    end
+
+    # "index.html.erb" -> "index"; "_form.html.erb" -> "_form"
+    def basename
+      filename.split(".").first
+    end
+
+    def partial?
+      filename.start_with?("_")
+    end
+
+    def rel_path
+      expanded = File.expand_path(path)
+      base = File.expand_path(root)
+      expanded.delete_prefix(base).sub(%r{\A/}, "")
+    end
+
+    def dir_rel
+      dir = File.dirname(rel_path)
+      dir == "." ? "" : dir
+    end
+
+    def class_name
+      Naming.class_name(basename)
+    end
+
+    def namespace_parts
+      Naming.namespace_parts(dir_rel, config.base_namespace)
+    end
+
+    def full_const
+      (namespace_parts + [class_name]).join("::")
+    end
+
+    def output_filename
+      "#{basename.sub(/\A_/, "")}.rb"
+    end
+
+    def output_path
+      target_dir =
+        if config.output_root
+          File.join(config.output_root, dir_rel)
+        else
+          File.dirname(File.expand_path(path))
+        end
+
+      File.join(target_dir, output_filename)
+    end
+
+    def tree
+      @tree ||= Parser.new(source).parse
+    end
+
+    def locals
+      @locals ||= partial? ? LocalsDetector.new(tree).locals : []
+    end
+
+    # Top-level views read controller instance variables (`@products`); partials
+    # take their data as bare locals instead.
+    def ivars
+      @ivars ||= partial? ? [] : LocalsDetector.new(tree).ivars
+    end
+
+    # Keyword arguments the generated initializer/props expose: bare locals for
+    # partials (referenced through attr_readers), controller ivars for top-level
+    # views (referenced directly as @ivars).
+    def init_args
+      partial? ? locals : ivars
+    end
+
+    def render
+      builder = CodeBuilder.new(indent: config.indent)
+      builder.line("# frozen_string_literal: true")
+      builder.line
+      builder.line("# Auto-generated by ruby_ui_converter")
+      builder.line("# Source: #{rel_path}")
+      builder.line
+
+      namespace_parts.each do |segment|
+        builder.line("module #{segment}")
+        builder.indent
+      end
+
+      builder.line("class #{class_name} < #{config.base_class}")
+      builder.indent
+
+      emit_initializer(builder)
+
+      builder.line("def #{config.template_method}")
+      builder.indent
+      Transformer.new(config: config, template: self).emit(tree, builder)
+      builder.dedent
+      builder.line("end")
+
+      emit_readers(builder)
+
+      builder.dedent
+      builder.line("end")
+
+      namespace_parts.each do
+        builder.dedent
+        builder.line("end")
+      end
+
+      builder.to_s
+    end
+
+    private
+
+    def emit_initializer(builder)
+      return emit_props(builder) if config.literal?
+      return if init_args.empty?
+
+      args = init_args.map { |name| "#{name}: nil" }.join(", ")
+      builder.line("def initialize(#{args})")
+      builder.indent
+      init_args.each { |name| builder.line("@#{name} = #{name}") }
+      builder.dedent
+      builder.line("end")
+      builder.line
+    end
+
+    # Literal::Properties props instead of initialize/attr_reader. The local
+    # matching the partial's name gets an inferred model type; the rest stay
+    # permissive (_Any? accepts anything, including nil).
+    def emit_props(builder)
+      return if init_args.empty?
+
+      init_args.each { |name| builder.line("prop :#{name}, #{prop_type(name)}") }
+      builder.line
+    end
+
+    def prop_type(local)
+      if local == basename.sub(/\A_/, "")
+        "_Nilable(#{Naming.camelize(local)})"
+      else
+        "_Any?"
+      end
+    end
+
+    def emit_readers(builder)
+      return unless partial? && locals.any?
+      return if config.literal? # props set ivars; the body uses @locals
+
+      builder.line
+      builder.line("private")
+      builder.line
+      builder.line("attr_reader #{locals.map { |local| ":#{local}" }.join(", ")}")
+    end
+  end
+end