phlexing 0.2.0 → 0.4.0

data/lib/phlexing/helpers.rb

@@ -1,102 +1,132 @@
 # frozen_string_literal: true
 
+require "phlex"
+require "phlex-rails"
+
 module Phlexing
   module Helpers
-    def indent(level)
-      return "" if level == 1
+    KNOWN_ELEMENTS =
+      Phlex::HTML::VoidElements.registered_elements.values +
+      Phlex::HTML::StandardElements.registered_elements.values
 
-      "  " * 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?("'")
-
-      percent_literal_string(string)
+    def parens(string)
+      "(#{string})"
     end
 
-    def node_name(node)
-      return "template_tag" if node.name == "template"
-      return node.name unless node.name.include?("-")
-
-      name = node.name.gsub("-", "_")
-      @custom_elements << name
+    def braces(string)
+      "{ #{string} }"
+    end
 
-      name
+    def interpolate(string)
+      "\#\{#{string}\}"
     end
 
-    def do_block_start
-      " do\n"
+    def unescape(source)
+      CGI.unescapeHTML(source)
     end
 
-    def do_block_end(level = 0)
-      "#{indent(level)}end\n"
+    def unwrap_erb(source)
+      source
+        .delete_prefix("<%==")
+        .delete_prefix("<%=")
+        .delete_prefix("<%-")
+        .delete_prefix("<%#")
+        .delete_prefix("<% #")
+        .delete_prefix("<%")
+        .delete_suffix("-%>")
+        .delete_suffix("%>")
+        .strip
     end
 
-    def multi_line_block(level)
-      @buffer << " do\n"
-      yield
-      @buffer << ("#{indent(level)}end\n")
+    def tag_name(node)
+      return "template_tag" if node.name == "template-tag"
+
+      name = node.name.tr("-", "_")
+
+      @converter.custom_elements << name unless KNOWN_ELEMENTS.include?(name)
+
+      name
     end
 
-    def single_line_block
-      @buffer << " { "
+    def block
+      out << " {"
       yield
-      @buffer << " }\n"
+      out << " }"
     end
 
-    def erb_node?(node)
-      node.is_a?(Nokogiri::XML::Element) && node.name == "erb"
+    def output(name, string)
+      out << name
+      out << " "
+      out << string.strip
+      out << newline
     end
 
-    def element_node?(node)
-      node.is_a?(Nokogiri::XML::Element)
+    def blocklist
+      [
+        "render"
+      ]
     end
 
-    def text_node?(node)
-      node.is_a?(Nokogiri::XML::Text)
+    def routes_helpers
+      [
+        /\w+_url/,
+        /\w+_path/
+      ]
     end
 
-    def multiple_children?(node)
-      node.children.length > 1
+    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 siblings?(node)
-      multiple_children?(node.parent)
-    end
+    def string_output?(node)
+      word = node.text.strip.scan(/^\w+/)[0]
+
+      return true if word.nil?
 
-    def erb_interpolation?(node)
-      first = node.children.first
+      blocklist_matched = known_rails_helpers.keys.include?(word) || blocklist.include?(word)
+      route_matched = routes_helpers.map { |regex| word.scan(regex).any? }.reduce(:|)
 
-      erb_node?(node) &&
-        node.children.one? &&
-        first.children.none? &&
-        text_node?(first) &&
-        node.attributes["interpolated"]
+      !(blocklist_matched || route_matched)
     end
 
-    def erb_safe_output?(node)
-      erb_interpolation?(node) && node.text.start_with?("=")
+    def children?(node)
+      node.children.length >= 1
     end
 
-    def erb_comment?(node)
-      node.attributes["comment"]
+    def multiple_children?(node)
+      node.children.length > 1
+    end
+
+    def siblings?(node)
+      multiple_children?(node.parent)
     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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Phlexing
+  class NameSuggestor
+    using Refinements::StringRefinements
+
+    def self.call(source)
+      document = Parser.call(source)
+      analyzer = RubyAnalyzer.call(source)
+
+      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?
+      return wrap(ids.first) if ids.any?
+      return wrap(ivars.first) if ivars.any?
+      return wrap(locals.first) if locals.any?
+      return wrap(classes.first) if classes.any?
+      return wrap(tags.first) if tags.any?
+
+      "Component"
+    end
+
+    def self.wrap(name)
+      "#{name}_component".underscore.camelize
+    end
+
+    def self.extract(document, method)
+      return [] unless document
+
+      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 && element.attributes["id"]
+      return if id_attribute.nil?
+
+      id = id_attribute.value.to_s.strip
+      return if id.include?("<erb")
+
+      id
+    end
+
+    def self.extract_class_from_element(element)
+      return if element.nil?
+      return if element.is_a?(Nokogiri::XML::Text)
+
+      class_attribute = element.attributes && element.attributes["class"]
+
+      return if class_attribute.nil?
+
+      classes = class_attribute.value.strip.split
+
+      return if classes.empty?
+
+      classes[0]
+    end
+
+    def self.extract_tag_name_from_element(element)
+      return if element.nil?
+      return if element.is_a?(Nokogiri::XML::Text)
+
+      return if ["div", "span", "p", "erb"].include?(element.name)
+
+      element.name
+    end
+  end
+end

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