ruby_ui_converter 0.1.0 → 0.2.0

data/lib/ruby_ui_converter/transformer.rb

@@ -31,10 +31,10 @@ module RubyUIConverter
     end
 
     def meaningful(nodes)
-      nodes.reject do |node|
-        (node.is_a?(Nodes::Text) && node.content.strip.empty?) ||
+      nodes.each_with_index.reject do |node, index|
+        (node.is_a?(Nodes::Text) && node.content.strip.empty? && !inline_space?(nodes, index)) ||
           (node.is_a?(Nodes::RawText) && node.content.strip.empty?)
-      end
+      end.map(&:first)
     end
 
     def render_attrs(attributes, except: [])
@@ -156,6 +156,7 @@ module RubyUIConverter
       # Collapse runs of whitespace to a single space but keep meaningful
       # leading/trailing spaces so inline text ("Hello, ") stays readable.
       content = node.content.gsub(/\s+/, " ")
+      return builder.line("whitespace") if content == " " # see #inline_space?
       return if content.strip.empty?
 
       builder.line("plain #{ruby_string(content)}")
@@ -228,14 +229,22 @@ module RubyUIConverter
         case node
         when Nodes::Output, Nodes::Statement then acc << node.code
         when Nodes::Control then node.branches.each { |b| collect_codes(b.children, acc) }
-        when Nodes::Element then collect_codes(node.children, acc)
+        when Nodes::Element, Nodes::Comment then collect_codes(node.children, acc)
         end
       end
       acc
     end
 
     def emit_comment(node, builder)
-      if node.html
+      if node.html && meaningful(node.children).any?
+        builder.line("comment do")
+        builder.indent
+        text = node.text.strip
+        builder.line("plain #{ruby_string(text)}") unless text.empty?
+        emit_children(meaningful(node.children), builder)
+        builder.dedent
+        builder.line("end")
+      elsif node.html
         text = node.text.strip
         builder.line("comment { #{ruby_string(text)} }") unless text.empty?
       else
@@ -276,8 +285,43 @@ module RubyUIConverter
 
     # Expressions with whitespace (`dom_id user`, `a ? b : c`) would parse
     # incorrectly inside the attribute argument list, so wrap them in parens.
+    # Self-delimited expressions (`[a, b]`, `{a: 1}`, `dom_id(user, :x)`) are
+    # safe as-is.
     def bare_expression(code)
-      code =~ /\s/ ? "(#{code})" : code
+      return code unless code =~ /\s/
+
+      self_delimited?(code) ? code : "(#{code})"
+    end
+
+    GROUP_TOKENS = {
+      on_lparen: 1, on_lbracket: 1, on_lbrace: 1,
+      on_rparen: -1, on_rbracket: -1, on_rbrace: -1
+    }.freeze
+    CALL_PREFIX_TOKENS = %i[on_ident on_const on_ivar on_cvar on_gvar on_period].freeze
+
+    # True when the code is a bracketed literal or a parenthesized call
+    # (optionally on a receiver chain written without spaces) whose opening
+    # bracket closes exactly at the end of the code.
+    def self_delimited?(code)
+      tokens = Ripper.lex(code)
+      index = 0
+      while index < tokens.length &&
+            (CALL_PREFIX_TOKENS.include?(tokens[index][1]) ||
+             (tokens[index][1] == :on_op && ["::", "&."].include?(tokens[index][2])))
+        index += 1
+      end
+      return false if index.positive? && !%i[on_ident on_const].include?(tokens[index - 1][1])
+      return false unless tokens[index] && GROUP_TOKENS[tokens[index][1]] == 1
+      return false if index.positive? && tokens[index][1] != :on_lparen
+
+      depth = 0
+      tokens[index..].each_with_index do |token, offset|
+        depth += GROUP_TOKENS.fetch(token[1], 0)
+        return index + offset == tokens.length - 1 if depth.zero?
+      end
+      false
+    rescue StandardError
+      false
     end
 
     def interpolated(parts)
@@ -299,6 +343,15 @@ module RubyUIConverter
       name.to_s.downcase
     end
 
+    # A whitespace-only text node on a single line between two siblings
+    # (`<em>a</em> <%= b %>`) separates inline content and is kept (emitted as
+    # Phlex's `whitespace`); whitespace spanning lines between tags is layout
+    # and is dropped.
+    def inline_space?(nodes, index)
+      content = nodes[index].content
+      !content.empty? && !content.include?("\n") && index.positive? && index < nodes.length - 1
+    end
+
     def inlineable?(node)
       node.is_a?(Nodes::Text) ||
         (node.is_a?(Nodes::Output) && !node.raw && !special_output?(node.code))
@@ -385,16 +438,24 @@ module RubyUIConverter
       "\"#{escape_inner(string)}\""
     end
 
+    STRING_ESCAPES = {
+      "\\" => "\\\\",
+      "\"" => "\\\"",
+      "\n" => "\\n",
+      "\t" => "\\t",
+      "\r" => "\\r",
+      "\#{" => "\\\#{"
+    }.freeze
+
+    # Invisible / easily-confused characters (no-break and other Unicode
+    # spaces, soft hyphen, zero-width characters, BOM) — typically from a
+    # decoded `&nbsp;` — are written as \u escapes so the generated source
+    # stays readable.
+    INVISIBLE_CHARS = /[ ­ -‏
-  -⁤]/
+
     def escape_inner(string)
-      string.to_s.gsub(/[\\"\n\t\r]|\#\{/) do |match|
-        {
-          "\\" => "\\\\",
-          "\"" => "\\\"",
-          "\n" => "\\n",
-          "\t" => "\\t",
-          "\r" => "\\r",
-          "\#{" => "\\\#{"
-        }[match]
+      string.to_s.gsub(/[\\"\n\t\r]|\#\{|#{INVISIBLE_CHARS}/o) do |match|
+        STRING_ESCAPES.fetch(match) { format("\\u%04X", match.ord) }
       end
     end
   end

data/lib/ruby_ui_converter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyUIConverter
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/ruby_ui_converter.rb

@@ -5,9 +5,13 @@ require "strscan"
 
 require_relative "ruby_ui_converter/version"
 require_relative "ruby_ui_converter/nodes"
+require_relative "ruby_ui_converter/html_entities"
 require_relative "ruby_ui_converter/lexer"
 require_relative "ruby_ui_converter/html_tokenizer"
 require_relative "ruby_ui_converter/parser"
+require_relative "ruby_ui_converter/ruby_literal"
+require_relative "ruby_ui_converter/haml_attributes"
+require_relative "ruby_ui_converter/haml_parser"
 require_relative "ruby_ui_converter/code_builder"
 require_relative "ruby_ui_converter/naming"
 require_relative "ruby_ui_converter/rails_helpers"
@@ -24,13 +28,35 @@ require_relative "ruby_ui_converter/doctor"
 module RubyUIConverter
   class Error < StandardError; end
 
-  # Convert a single .erb string into Ruby/Phlex source (no file IO).
+  # Template file extension -> source format (front-end parser).
+  FORMATS = { ".erb" => :erb, ".haml" => :haml }.freeze
+
+  # The source format of a template path ("index.html.haml" -> :haml), or
+  # nil when it isn't a supported template.
+  def self.format_for(path)
+    FORMATS[File.extname(path.to_s)]
+  end
+
+  # Parse template source into the shared AST (Nodes::Document). This is the
+  # single dispatch point between the front-ends: ERB (Lexer + HtmlTokenizer
+  # + Parser) and HAML (HamlParser, backed by the optional haml gem).
+  def self.parse(source, format: :erb)
+    case format.to_sym
+    when :erb then Parser.new(source).parse
+    when :haml then HamlParser.new(source).parse
+    else raise Error, "unsupported template format: #{format.inspect}"
+    end
+  end
+
+  # Convert a single .erb (or, with format: :haml, .haml) string into
+  # Ruby/Phlex source (no file IO).
   #
   #   RubyUIConverter.convert_string("<h1><%= @title %></h1>")
+  #   RubyUIConverter.convert_string("%h1= @title", format: :haml)
   def self.convert_string(source, class_name: "Component", base_namespace: "",
-                          base_class: "Phlex::HTML", **opts)
+                          base_class: "Phlex::HTML", format: :erb, **opts)
     config = Configuration.new(base_namespace: base_namespace, base_class: base_class, **opts)
-    document = Parser.new(source).parse
+    document = parse(source, format: format)
     builder = CodeBuilder.new(indent: config.indent)
     builder.line("class #{class_name} < #{config.base_class}")
     builder.indent

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_ui_converter
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jackson Pires
@@ -51,11 +51,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
 description: |
   ruby_ui_converter walks a Rails views directory recursively and converts each
-  .erb template into an equivalent .rb file written with Phlex (and RubyUI when
-  configured). Traditional Rails partials (_partial.html.erb) are converted into
-  their own Phlex component classes.
+  .erb or .haml template into an equivalent .rb file written with Phlex (and
+  RubyUI when configured). Traditional Rails partials (_partial.html.erb) are
+  converted into their own Phlex component classes. HAML conversion uses the
+  haml gem when it is available (optional dependency).
 email:
 - jackson@linkana.com
 executables:
@@ -76,6 +91,9 @@ files:
 - lib/ruby_ui_converter/doctor.rb
 - lib/ruby_ui_converter/file_walker.rb
 - lib/ruby_ui_converter/form_builder.rb
+- lib/ruby_ui_converter/haml_attributes.rb
+- lib/ruby_ui_converter/haml_parser.rb
+- lib/ruby_ui_converter/html_entities.rb
 - lib/ruby_ui_converter/html_tokenizer.rb
 - lib/ruby_ui_converter/lexer.rb
 - lib/ruby_ui_converter/locals_detector.rb
@@ -83,6 +101,7 @@ files:
 - lib/ruby_ui_converter/nodes.rb
 - lib/ruby_ui_converter/parser.rb
 - lib/ruby_ui_converter/rails_helpers.rb
+- lib/ruby_ui_converter/ruby_literal.rb
 - lib/ruby_ui_converter/template.rb
 - lib/ruby_ui_converter/transformer.rb
 - lib/ruby_ui_converter/version.rb
@@ -108,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.3
 specification_version: 4
-summary: Convert Rails .erb views and partials into RubyUI/Phlex Ruby components.
+summary: Convert Rails .erb and .haml views and partials into RubyUI/Phlex Ruby components.
 test_files: []