phlexing 0.2.0 → 0.4.0

data/lib/phlexing/template_generator.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Phlexing
+  class TemplateGenerator
+    using Refinements::StringRefinements
+
+    include Helpers
+
+    attr_accessor :converter, :out, :options
+
+    def self.call(converter, source)
+      new(converter).call(source)
+    end
+
+    def initialize(converter)
+      @converter = converter
+      @options = @converter.options
+      @out = StringIO.new
+    end
+
+    def call(source)
+      document = Parser.call(source)
+      handle_node(document)
+
+      Formatter.call(out.string.strip)
+    rescue StandardError
+      out.string.strip
+    end
+
+    def handle_text_output(text)
+      output("text", text)
+    end
+
+    def handle_html_comment_output(text)
+      output("comment", braces(quote(text)))
+    end
+
+    def handle_erb_comment_output(text)
+      output("#", text)
+    end
+
+    def handle_erb_unsafe_output(text)
+      output("unsafe_raw", text)
+    end
+
+    def handle_output(text)
+      output("", unescape(text).strip)
+    end
+
+    def handle_attributes(node)
+      return "" if node.attributes.keys.none?
+
+      attributes = []
+
+      node.attributes.each_value do |attribute|
+        attributes << handle_attribute(attribute)
+      end
+
+      parens(attributes.join(", "))
+    end
+
+    def handle_attribute(attribute)
+      if attribute.name.start_with?(/data-erb-(\d+)+/)
+        handle_erb_interpolation_in_tag(attribute)
+      elsif attribute.name.start_with?("data-erb-")
+        handle_erb_attribute_output(attribute)
+      else
+        handle_html_attribute_output(attribute)
+      end
+    end
+
+    def handle_html_attribute_output(attribute)
+      String.new.tap { |s|
+        s << arg(attribute.name.underscore)
+        s << quote(attribute.value)
+      }
+    end
+
+    def handle_erb_attribute_output(attribute)
+      String.new.tap { |s|
+        s << arg(attribute.name.delete_prefix("data-erb-").underscore)
+
+        s << if attribute.value.start_with?("<%=") && attribute.value.scan("<%").one? && attribute.value.end_with?("%>")
+          value = unwrap_erb(attribute.value)
+          value.include?(" ") ? parens(value) : value
+        else
+          transformed = Parser.call(attribute.value)
+          attribute = StringIO.new
+
+          transformed.children.each do |node|
+            case node
+            when Nokogiri::XML::Text
+              attribute << node.text
+            when Nokogiri::XML::Node
+              if node.attributes["loud"]
+                attribute << interpolate(node.text.strip)
+              else
+                attribute << interpolate("#{node.text.strip} && nil")
+              end
+            end
+          end
+
+          quote(attribute.string)
+        end
+      }
+    end
+
+    def handle_erb_interpolation_in_tag(attribute)
+      "**#{parens("#{unwrap_erb(unescape(attribute.value))}: true")}"
+    end
+
+    def handle_erb_safe_node(node)
+      if siblings?(node) && string_output?(node)
+        handle_text_output(node.text.strip)
+      else
+        handle_output(node.text.strip)
+      end
+    end
+
+    def handle_text_node(node)
+      text = node.text
+
+      if text.squish.empty? && text.length.positive?
+        out << whitespace
+
+        text.strip!
+      end
+
+      return if text.length.zero?
+
+      if siblings?(node)
+        handle_text_output(quote(node.text))
+      else
+        handle_output(quote(text))
+      end
+    end
+
+    def handle_html_element_node(node, level)
+      out << tag_name(node)
+      out << handle_attributes(node)
+
+      if node.children.any?
+        block { handle_children(node, level) }
+      end
+
+      out << newline
+    end
+
+    def handle_loud_erb_node(node)
+      if node.text.start_with?("=")
+        handle_erb_unsafe_output(node.text.from(1).strip)
+      else
+        handle_erb_safe_node(node)
+      end
+    end
+
+    def handle_silent_erb_node(node)
+      if node.text.start_with?("#")
+        handle_erb_comment_output(node.text.from(1).strip)
+      elsif node.text.start_with?("-")
+        handle_output(node.text.from(1).to(-2).strip)
+      else
+        handle_output(node.text.strip)
+      end
+    end
+
+    def handle_html_comment_node(node)
+      handle_html_comment_output(node.text.strip)
+    end
+
+    def handle_element_node(node, level)
+      case node
+      in name: "erb", attributes: [{ name: "loud", value: "" }]
+        handle_loud_erb_node(node)
+      in name: "erb", attributes: [{ name: "silent", value: "" }]
+        handle_silent_erb_node(node)
+      else
+        handle_html_element_node(node, level)
+      end
+
+      out << newline if level == 1
+    end
+
+    def handle_document_node(node, level)
+      handle_children(node, level)
+    end
+
+    def handle_children(node, level)
+      node.children.each do |child|
+        handle_node(child, level + 1)
+      end
+    end
+
+    def handle_node(node, level = 0)
+      case node
+      in Nokogiri::XML::Text
+        handle_text_node(node)
+      in Nokogiri::XML::Element
+        handle_element_node(node, level)
+      in Nokogiri::HTML4::Document | Nokogiri::HTML4::DocumentFragment | Nokogiri::XML::DTD
+        handle_document_node(node, level)
+      in Nokogiri::XML::Comment
+        handle_html_comment_node(node)
+      end
+    end
+  end
+end

data/lib/phlexing/version.rb

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

data/lib/phlexing/visitor.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "syntax_tree"
+
+module Phlexing
+  class Visitor < SyntaxTree::Visitor
+    using Refinements::StringRefinements
+    include Helpers
+
+    def initialize(analyzer)
+      @analyzer = analyzer
+    end
+
+    def visit_ivar(node)
+      @analyzer.ivars << node.value.from(1)
+    end
+
+    def visit_const(node)
+      @analyzer.consts << node.value
+    end
+
+    def visit_command(node)
+      unless rails_helper?(node.message.value)
+        @analyzer.instance_methods << node.message.value
+      end
+      super
+    end
+
+    def visit_call(node)
+      if node.receiver
+        case node.receiver
+        when SyntaxTree::VarRef
+          value = node.receiver.value.value
+
+          case node.receiver.value
+          when SyntaxTree::IVar
+            @analyzer.ivars << value.from(1)
+          when SyntaxTree::Ident
+            @analyzer.idents << value
+          end
+
+          @analyzer.calls << value
+
+        when SyntaxTree::VCall
+          case node.receiver.value
+          when SyntaxTree::Ident
+            @analyzer.calls << node.receiver.value.value
+          end
+
+        when SyntaxTree::Ident
+          value = node.receiver.value.value.value
+
+          @analyzer.idents << value unless value.ends_with?("?")
+          @analyzer.calls << value
+
+        when SyntaxTree::Const
+          @analyzer.calls << node.receiver.value
+        end
+
+      elsif node.receiver.nil? && node.operator.nil?
+        case node.message
+        when SyntaxTree::Ident
+          if node.message.value.end_with?("?") || node.child_nodes[3].is_a?(SyntaxTree::ArgParen)
+            unless rails_helper?(node.message.value)
+              @analyzer.instance_methods << node.message.value
+            end
+            @analyzer.calls << node.message.value
+          else
+            @analyzer.idents << node.message.value
+          end
+        end
+      end
+
+      super
+    end
+
+    def visit_vcall(node)
+      unless rails_helper?(node.value.value)
+        @analyzer.locals << node.value.value
+      end
+    end
+
+    def visit_ident(node)
+      unless rails_helper?(node.value)
+        @analyzer.idents << node.value
+      end
+    end
+
+    private
+
+    def rails_helper?(name)
+      if known_rails_helpers.keys.include?(name)
+        @analyzer.includes << known_rails_helpers[name]
+        return true
+      end
+
+      if routes_helpers.map { |regex| name.scan(regex).any? }.reduce(:|)
+        @analyzer.includes << "Phlex::Rails::Helpers::Routes"
+        return true
+      end
+
+      false
+    end
+  end
+end

data/lib/phlexing.rb

@@ -1,8 +1,21 @@
 # frozen_string_literal: true
 
 require_relative "phlexing/version"
-require_relative "phlexing/helpers"
 require_relative "phlexing/refinements/string_refinements"
+require_relative "phlexing/patches/html_press"
+
+require_relative "phlexing/erb_transformer"
+require_relative "phlexing/formatter"
+require_relative "phlexing/helpers"
+require_relative "phlexing/minifier"
+require_relative "phlexing/options"
+require_relative "phlexing/parser"
+require_relative "phlexing/ruby_analyzer"
+require_relative "phlexing/visitor"
+
+require_relative "phlexing/name_suggestor"
+require_relative "phlexing/component_generator"
+require_relative "phlexing/template_generator"
 require_relative "phlexing/converter"
 
 module Phlexing

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: phlexing
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Marco Roth
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-11 00:00:00.000000000 Z
+date: 2023-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: erb_parser
+  name: deface
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.2
+        version: '1.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.2
+        version: '1.9'
 - !ruby/object:Gem::Dependency
   name: html_press
   requirement: !ruby/object:Gem::Requirement
@@ -53,19 +53,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: rufo
+  name: phlex
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: phlex-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: syntax_tree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
 description: Simple ERB to Phlex converter
 email:
 - marco.roth@hey.com
@@ -81,10 +109,21 @@ files:
 - README.md
 - Rakefile
 - lib/phlexing.rb
+- lib/phlexing/component_generator.rb
 - lib/phlexing/converter.rb
+- lib/phlexing/erb_transformer.rb
+- lib/phlexing/formatter.rb
 - lib/phlexing/helpers.rb
+- lib/phlexing/minifier.rb
+- lib/phlexing/name_suggestor.rb
+- lib/phlexing/options.rb
+- lib/phlexing/parser.rb
+- lib/phlexing/patches/html_press.rb
 - lib/phlexing/refinements/string_refinements.rb
+- lib/phlexing/ruby_analyzer.rb
+- lib/phlexing/template_generator.rb
 - lib/phlexing/version.rb
+- lib/phlexing/visitor.rb
 - sig/phlexing.rbs
 homepage: https://github.com/marcoroth/phlexing
 licenses: