phlexing 0.3.0 → 0.4.0

data/lib/phlexing/formatter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "syntax_tree"
+
+module Phlexing
+  class Formatter
+    def self.call(...)
+      new(...).call
+    end
+
+    def initialize(source, max: 80)
+      @source = source.to_s.dup
+      @max = max
+    end
+
+    def call
+      SyntaxTree.format(@source, @max).strip
+    rescue SyntaxTree::Parser::ParseError, NoMethodError
+      @source
+    end
+  end
+end

data/lib/phlexing/helpers.rb

@@ -1,80 +1,124 @@
 # frozen_string_literal: true
 
 require "phlex"
+require "phlex-rails"
 
 module Phlexing
   module Helpers
-    KNOWN_ELEMENTS = Phlex::HTML::VOID_ELEMENTS.values + Phlex::HTML::STANDARD_ELEMENTS.values
+    KNOWN_ELEMENTS =
+      Phlex::HTML::VoidElements.registered_elements.values +
+      Phlex::HTML::StandardElements.registered_elements.values
 
-    def indent(level)
-      return "" if level == 1
-
-      "  " * level
+    def whitespace
+      options.whitespace? ? "whitespace\n" : ""
     end
 
-    def whitespace(options)
-      options.fetch(:whitespace, true) ? "whitespace\n" : ""
+    def newline
+      "\n"
     end
 
-    def double_quote(string)
-      "\"#{string}\""
+    def symbol(string)
+      ":#{string}"
     end
 
-    def single_quote(string)
-      "'#{string}'"
+    def arg(string)
+      "#{string}: "
     end
 
-    def percent_literal_string(string)
+    def quote(string)
       "%(#{string})"
     end
 
-    def quote(string)
-      return double_quote(string) unless string.include?('"')
-      return single_quote(string) unless string.include?("'")
+    def parens(string)
+      "(#{string})"
+    end
+
+    def braces(string)
+      "{ #{string} }"
+    end
 
-      percent_literal_string(string)
+    def interpolate(string)
+      "\#\{#{string}\}"
     end
 
-    def node_name(node)
-      return "template_tag" if node.name == "template"
+    def unescape(source)
+      CGI.unescapeHTML(source)
+    end
+
+    def unwrap_erb(source)
+      source
+        .delete_prefix("<%==")
+        .delete_prefix("<%=")
+        .delete_prefix("<%-")
+        .delete_prefix("<%#")
+        .delete_prefix("<% #")
+        .delete_prefix("<%")
+        .delete_suffix("-%>")
+        .delete_suffix("%>")
+        .strip
+    end
 
-      name = node.name.gsub("-", "_")
+    def tag_name(node)
+      return "template_tag" if node.name == "template-tag"
 
-      @custom_elements << name unless KNOWN_ELEMENTS.include?(name)
+      name = node.name.tr("-", "_")
+
+      @converter.custom_elements << name unless KNOWN_ELEMENTS.include?(name)
 
       name
     end
 
-    def do_block_start
-      " do\n"
+    def block
+      out << " {"
+      yield
+      out << " }"
     end
 
-    def do_block_end(level = 0)
-      "#{indent(level)}end\n"
+    def output(name, string)
+      out << name
+      out << " "
+      out << string.strip
+      out << newline
     end
 
-    def multi_line_block(level)
-      @buffer << " do\n"
-      yield
-      @buffer << ("#{indent(level)}end\n")
+    def blocklist
+      [
+        "render"
+      ]
     end
 
-    def single_line_block
-      @buffer << " { "
-      yield
-      @buffer << " }\n"
+    def routes_helpers
+      [
+        /\w+_url/,
+        /\w+_path/
+      ]
     end
 
-    def erb_node?(node)
-      node.is_a?(Nokogiri::XML::Element) && node.name == "erb"
+    def known_rails_helpers
+      Phlex::Rails::Helpers
+        .constants
+        .reject { |m| m == :Routes }
+        .map { |m| Module.const_get("::Phlex::Rails::Helpers::#{m}") }
+        .each_with_object({}) { |m, sum|
+          (m.instance_methods - Module.instance_methods).each do |method|
+            sum[method.to_s] = m.name
+          end
+        }
     end
 
-    def element_node?(node)
-      node.is_a?(Nokogiri::XML::Element)
+    def string_output?(node)
+      word = node.text.strip.scan(/^\w+/)[0]
+
+      return true if word.nil?
+
+      blocklist_matched = known_rails_helpers.keys.include?(word) || blocklist.include?(word)
+      route_matched = routes_helpers.map { |regex| word.scan(regex).any? }.reduce(:|)
+
+      !(blocklist_matched || route_matched)
     end
 
-    def text_node?(node)
-      node.is_a?(Nokogiri::XML::Text)
+    def children?(node)
+      node.children.length >= 1
     end
 
     def multiple_children?(node)
@@ -84,23 +128,5 @@ module Phlexing
     def siblings?(node)
       multiple_children?(node.parent)
     end
-
-    def erb_interpolation?(node)
-      first = node.children.first
-
-      erb_node?(node) &&
-        node.children.one? &&
-        first.children.none? &&
-        text_node?(first) &&
-        node.attributes["interpolated"]
-    end
-
-    def erb_safe_output?(node)
-      erb_interpolation?(node) && node.text.start_with?("=")
-    end
-
-    def erb_comment?(node)
-      node.attributes["comment"]
-    end
   end
 end

data/lib/phlexing/minifier.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "html_press"
+
+module Phlexing
+  class Minifier
+    def self.call(...)
+      new(...).call
+    end
+
+    def initialize(source)
+      @source = source.to_s.dup
+    end
+
+    def call
+      minify
+      minify_html_entities
+
+      @source
+    end
+
+    private
+
+    def minify
+      @source = HtmlPress.press(@source)
+    rescue StandardError
+      @source
+    end
+
+    def minify_html_entities
+      @source = @source
+                .gsub("& lt;", "<")
+                .gsub("& quot;", """)
+                .gsub("& gt;", ">")
+                .gsub("& #amp;", "&#amp;")
+                .gsub("& #38;", "&")
+                .gsub("& #60;", "<")
+                .gsub("& #62;", ">")
+    end
+  end
+end

data/lib/phlexing/name_suggestor.rb

@@ -2,15 +2,18 @@
 
 module Phlexing
   class NameSuggestor
-    def self.suggest(html)
-      converter = Phlexing::Converter.new(html)
+    using Refinements::StringRefinements
 
-      ivars  = converter.ivars
-      locals = converter.locals
+    def self.call(source)
+      document = Parser.call(source)
+      analyzer = RubyAnalyzer.call(source)
 
-      ids     = extract(converter, :extract_id_from_element)
-      classes = extract(converter, :extract_class_from_element)
-      tags    = extract(converter, :extract_tag_name_from_element)
+      ivars  = analyzer.ivars
+      locals = analyzer.locals
+
+      ids     = extract(document, :extract_id_from_element)
+      classes = extract(document, :extract_class_from_element)
+      tags    = extract(document, :extract_tag_name_from_element)
 
       return wrap(ivars.first) if ivars.one? && locals.none?
       return wrap(locals.first) if locals.one? && ivars.none?
@@ -24,20 +27,20 @@ module Phlexing
     end
 
     def self.wrap(name)
-      "#{name}_component".gsub("-", "_").gsub(" ", "_").camelize
+      "#{name}_component".underscore.camelize
     end
 
-    def self.extract(converter, method)
-      return [] unless converter.parsed
+    def self.extract(document, method)
+      return [] unless document
 
-      converter.parsed.children.map { |element| send(method, element) }.compact
+      document.children.map { |element| send(method, element) }.compact
     end
 
     def self.extract_id_from_element(element)
       return if element.nil?
       return if element.is_a?(Nokogiri::XML::Text)
 
-      id_attribute = element.attributes.try(:[], "id")
+      id_attribute = element.attributes && element.attributes["id"]
       return if id_attribute.nil?
 
       id = id_attribute.value.to_s.strip
@@ -50,7 +53,7 @@ module Phlexing
       return if element.nil?
       return if element.is_a?(Nokogiri::XML::Text)
 
-      class_attribute = element.attributes.try(:[], "class")
+      class_attribute = element.attributes && element.attributes["class"]
 
       return if class_attribute.nil?
 

data/lib/phlexing/options.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Phlexing
+  class Options
+    attr_accessor :component, :component_name, :parent_component, :whitespace
+
+    alias_method :whitespace?, :whitespace
+    alias_method :component?, :component
+
+    def initialize(component: false, component_name: "Component", parent_component: "Phlex::HTML", whitespace: true)
+      @component = component
+      @component_name = safe_constant_name(component_name)
+      @parent_component = safe_constant_name(parent_component)
+      @whitespace = whitespace
+    end
+
+    def safe_constant_name(name)
+      name = name.to_s
+
+      if name[0] == "0" || name[0].to_i != 0
+        "A#{name}"
+      else
+        name
+      end
+    end
+  end
+end

data/lib/phlexing/parser.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Phlexing
+  class Parser
+    def self.call(source)
+      source = ERBTransformer.call(source)
+      source = Minifier.call(source)
+
+      # Credit:
+      # https://github.com/spree/deface/blob/6bf18df76715ee3eb3d0cd1b6eda822817ace91c/lib/deface/parser.rb#L105-L111
+      #
+
+      html_tag = /<html(( .*?(?:(?!>)[\s\S])*>)|>)/i
+      head_tag = /<head(( .*?(?:(?!>)[\s\S])*>)|>)/i
+      body_tag = /<body(( .*?(?:(?!>)[\s\S])*>)|>)/i
+
+      if source =~ html_tag
+        Nokogiri::HTML::Document.parse(source)
+      elsif source =~ head_tag && source =~ body_tag
+        Nokogiri::HTML::Document.parse(source).css("html").first
+      elsif source =~ head_tag
+        Nokogiri::HTML::Document.parse(source).css("head").first
+      elsif source =~ body_tag
+        Nokogiri::HTML::Document.parse(source).css("body").first
+      else
+        Nokogiri::HTML::DocumentFragment.parse(source)
+      end
+    end
+  end
+end

data/lib/phlexing/patches/html_press.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "html_press"
+
+module HtmlPress
+  class Html
+    # We want to preserve HTML comments in the minification step
+    # so we can output them again in the phlex template
+    def process_html_comments(out)
+      out
+    end
+  end
+
+  class Entities
+    # The minification step turned this input
+    # <div data-erb-class="&lt;%= something? ? &quot;class-1&quot; : &quot;class-2&quot; %&gt;">Text</div>
+    #
+    # into this output:
+    # <div data-erb-class="&lt;%= something? ? " class-1"  :" class-2" %& gt;">Text</div>
+    #
+    # which in our wasn't ideal, because nokogiri parsed it as:
+    # <div data-erb-class="<%= something? ? " class-1="  :" class-2="%>">Text</div>
+    #
+    def minify(out)
+      out
+    end
+  end
+end

data/lib/phlexing/refinements/string_refinements.rb

@@ -4,15 +4,41 @@ module Phlexing
   module Refinements
     module StringRefinements
       refine String do
+        # https://github.com/rails/rails/blob/46c45935123e7ae003767900e7d22a6e41995701/activesupport/lib/active_support/core_ext/string/access.rb#L46-L48
+        def from(position)
+          self[position, length]
+        end
+
+        # https://github.com/rails/rails/blob/46c45935123e7ae003767900e7d22a6e41995701/activesupport/lib/active_support/core_ext/string/access.rb#L63-L66        def from(position)
+        def to(position)
+          position += size if position < 0
+          self[0, position + 1] || +""
+        end
+
+        # https://github.com/rails/rails/blob/46c45935123e7ae003767900e7d22a6e41995701/activesupport/lib/active_support/core_ext/string/filters.rb#L13-L15
         def squish
           dup.squish!
         end
 
+        # https://github.com/rails/rails/blob/46c45935123e7ae003767900e7d22a6e41995701/activesupport/lib/active_support/core_ext/string/filters.rb#L21-L25
         def squish!
           gsub!(/[[:space:]]+/, " ")
           strip!
           self
         end
+
+        # https://stackoverflow.com/questions/4072159/classify-a-ruby-string#comment4378937_4072202
+        def camelize
+          split("_").collect(&:capitalize).join
+        end
+
+        def dasherize
+          tr("_", "-").tr(" ", "-")
+        end
+
+        def underscore
+          tr("-", "_").tr(" ", "_")
+        end
       end
     end
   end

data/lib/phlexing/ruby_analyzer.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "syntax_tree"
+
+module Phlexing
+  class RubyAnalyzer
+    attr_accessor :ivars, :locals, :idents, :calls, :consts, :instance_methods, :includes
+
+    def self.call(source)
+      new.analyze(source)
+    end
+
+    def initialize
+      @ivars = Set.new
+      @locals = Set.new
+      @idents = Set.new
+      @calls = Set.new
+      @consts = Set.new
+      @instance_methods = Set.new
+      @includes = Set.new
+      @visitor = Visitor.new(self)
+    end
+
+    def analyze(source)
+      code = extract_ruby_from_erb(source.to_s)
+
+      analyze_ruby(code)
+    end
+
+    def analyze_ruby(code)
+      program = SyntaxTree.parse(code)
+      @visitor.visit(program)
+
+      self
+    rescue SyntaxTree::Parser::ParseError, NoMethodError
+      self
+    end
+
+    private
+
+    def extract_ruby_from_erb(source)
+      document = Parser.call(source)
+      lines = []
+
+      lines << ruby_lines_from_erb_tags(document)
+      lines << ruby_lines_from_erb_attributes(document)
+
+      lines.join("\n")
+    rescue StandardError
+      ""
+    end
+
+    def ruby_lines_from_erb_tags(document)
+      nodes = document.css("erb")
+
+      nodes
+        .map { |node| node.text.to_s.strip }
+        .map { |line| line.delete_prefix("=") }
+        .map { |line| line.delete_prefix("-") }
+        .map { |line| line.delete_suffix("-") }
+    end
+
+    def ruby_lines_from_erb_attributes(document)
+      attributes = document.css("*").map(&:attributes)
+
+      lines = []
+
+      attributes.each do |pair|
+        pair.select! { |name, _| name.start_with?("data-erb-") }
+
+        pair.each do |_, value|
+          Parser
+            .call(value)
+            .children
+            .select { |child| child.is_a?(Nokogiri::XML::Node) }
+            .each   { |child| lines << child.text.strip }
+        end
+      end
+
+      lines
+    end
+  end
+end