phlex 0.1.0 → 0.2.1

data/lib/phlex/component.rb

@@ -1,45 +1,191 @@
 # frozen_string_literal: true
 
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.0")
+  using Overrides::Symbol::Name
+end
+
 module Phlex
   class Component
-    include Node, Context
+    extend HTML
+    include Renderable
 
-    module Initializer
-      def initialize(*args, assigns: [], **kwargs, &block)
-        assigns.each do |k, v|
-          instance_variable_get(k) || instance_variable_set(k, v)
-        end
+    class << self
+      attr_accessor :rendered_at_least_once
+    end
+
+    def call(buffer = +"", view_context: nil, parent: nil, &block)
+      raise "The same component instance shouldn't be rendered twice" if rendered?
+
+      @_rendered = true
+      @_target = buffer
+      @_view_context = view_context
+      @_parent = parent
+      @output_buffer = self
+
+      template(&block)
+
+      self.class.rendered_at_least_once ||= true
+
+      buffer
+    end
+
+    def rendered?
+      @_rendered ||= false
+    end
+
+    HTML::STANDARD_ELEMENTS.each do |element|
+      register_element(element)
+    end
+
+    HTML::VOID_ELEMENTS.each do |element|
+      register_void_element(element)
+    end
+
+    register_element :template_tag, tag: "template"
+
+    def content(&block)
+      return unless block_given?
+
+      original_length = @_target.length
+      output = yield(self) if block_given?
+      unchanged = (original_length == @_target.length)
+
+      text(output) if unchanged && output.is_a?(String)
+      nil
+    end
+
+    def text(content)
+      @_target << CGI.escape_html(content)
+      nil
+    end
+
+    def whitespace
+      @_target << " "
+      nil
+    end
+
+    def doctype
+      @_target << HTML::DOCTYPE
+      nil
+    end
+
+    def raw(content)
+      @_target << content
+      nil
+    end
+
+    def html_safe?
+      true
+    end
+
+    def safe_append=(value)
+      return unless value
 
-        super(*args, **kwargs)
-        template(&block)
+      @_target << case value
+      when String then value
+      when Symbol then value.name
+      else value.to_s
       end
     end
 
-    def initialize(**attributes)
-      attributes.each { |k, v| instance_variable_set("@#{k}", v) }
+    def append=(value)
+      return unless value
+
+      if value.html_safe?
+        self.safe_append = value
+      else
+        @_target << case value
+        when String then CGI.escape_html(value)
+        when Symbol then CGI.escape_html(value.name)
+        else CGI.escape_html(value.to_s)
+        end
+      end
     end
 
-    def self.inherited(child)
-      child.prepend(Initializer)
+    def capture(&block)
+      return unless block_given?
+
+      original_buffer = @_target
+      new_buffer = +""
+      @_target = new_buffer
+
+      yield
+
+      @_target = original_buffer
+      new_buffer.html_safe
     end
 
-    def render_context
-      @_render_context ||= self
+    def classes(*tokens, **conditional_tokens)
+      { class: self.tokens(*tokens, **conditional_tokens) }
     end
 
-    def <<(node)
-      render_context.children << node
+    def tokens(*tokens, **conditional_tokens)
+      conditional_tokens.each do |condition, token|
+        case condition
+        when Symbol then next unless send(condition)
+        when Proc then next unless condition.call
+        else raise ArgumentError,
+          "The class condition must be a Symbol or a Proc."
+        end
+
+        case token
+        when Symbol then tokens << token.name
+        when String then tokens << token
+        when Array then tokens.concat(t)
+        else raise ArgumentError,
+          "Conditional classes must be Symbols, Strings, or Arrays of Symbols or Strings."
+        end
+      end
+
+      tokens.compact.join(" ")
     end
 
-    def render(&block)
-      instance_eval(&block) if block_given?
+    def _attributes(attributes, buffer: +"")
+      if attributes[:href]&.start_with?(/\s*javascript/)
+        attributes[:href] = attributes[:href].sub(/^\s*(javascript:)+/, "")
+      end
+
+      _build_attributes(attributes, buffer: buffer)
+
+      unless self.class.rendered_at_least_once
+        Phlex::ATTRIBUTE_CACHE[attributes.hash] = buffer.freeze
+      end
+
+      buffer
     end
 
-    def render_tag(tag, &block)
-      old_render_context = render_context.dup
-      @_render_context = tag
-      instance_eval(&block)
-      @_render_context = old_render_context
+    def _build_attributes(attributes, buffer:)
+      attributes.each do |k, v|
+        next unless v
+
+        name = case k
+        when String
+          k
+        when Symbol
+          k.name.tr("_", "-")
+        else
+          k.to_s
+        end
+
+        if HTML::EVENT_ATTRIBUTES[name] || name.match?(/[<>&"']/)
+          raise ArgumentError, "Unsafe attribute name detected: #{k}."
+        end
+
+        case v
+        when true
+          buffer << " " << name
+        when String
+          buffer << " " << name << '="' << CGI.escape_html(v) << '"'
+        when Symbol
+          buffer << " " << name << '="' << CGI.escape_html(v.name) << '"'
+        when Hash
+          _build_attributes(v.transform_keys { "#{k}-#{_1}" }, buffer: buffer)
+        else
+          buffer << " " << name << '="' << CGI.escape_html(v.to_s) << '"'
+        end
+      end
+
+      buffer
     end
   end
 end

data/lib/phlex/configuration.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Phlex
+  class Configuration
+    # Config coming soon.
+  end
+end

data/lib/phlex/html.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.0")
+  using Overrides::Symbol::Name
+end
+
+module Phlex
+  module HTML
+    DOCTYPE = "<!DOCTYPE html>"
+
+    STANDARD_ELEMENTS = %i[a abbr address article aside b bdi bdo blockquote body button caption cite code colgroup data datalist dd del details dfn dialog div dl dt em fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6 head header html i iframe ins kbd label legend li main map mark menuitem meter nav noscript object ol optgroup option output p path picture pre progress q rp rt ruby s samp script section select slot small span strong style sub summary sup svg table tbody td textarea tfoot th thead time title tr u ul video wbr].freeze
+
+    VOID_ELEMENTS = %i[area embed img input link meta param track col].freeze
+
+    EVENT_ATTRIBUTES = %w[onabort onafterprint onbeforeprint onbeforeunload onblur oncanplay oncanplaythrough onchange onclick oncontextmenu oncopy oncuechange oncut ondblclick ondrag ondragend ondragenter ondragleave ondragover ondragstart ondrop ondurationchange onemptied onended onerror onerror onfocus onhashchange oninput oninvalid onkeydown onkeypress onkeyup onload onloadeddata onloadedmetadata onloadstart onmessage onmousedown onmousemove onmouseout onmouseover onmouseup onmousewheel onoffline ononline onpagehide onpageshow onpaste onpause onplay onplaying onpopstate onprogress onratechange onreset onresize onscroll onsearch onseeked onseeking onselect onstalled onstorage onsubmit onsuspend ontimeupdate ontoggle onunload onvolumechange onwaiting onwheel].to_h { [_1, true] }.freeze
+
+    def register_element(element, tag: element.name.tr("_", "-"))
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        # frozen_string_literal: true
+
+        def #{element}(content = nil, **attributes, &block)
+          if attributes.length > 0
+            if content
+              @_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[attributes.hash] || _attributes(attributes)) << ">" << CGI.escape_html(content) << "</#{tag}>"
+            elsif block_given?
+              @_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[attributes.hash] || _attributes(attributes)) << ">"
+              content(&block)
+              @_target << "</#{tag}>"
+            else
+              @_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[attributes.hash] || _attributes(attributes)) << "></#{tag}>"
+            end
+          else
+            if content
+              @_target << "<#{tag}>" << CGI.escape_html(content) << "</#{tag}>"
+            elsif block_given?
+              @_target << "<#{tag}>"
+              content(&block)
+              @_target << "</#{tag}>"
+            else
+              @_target << "<#{tag}></#{tag}>"
+            end
+          end
+
+          nil
+        end
+      RUBY
+    end
+
+    def register_void_element(element, tag: element.name.tr("_", "-"))
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        # frozen_string_literal: true
+
+        def #{element}(**attributes)
+          if attributes.length > 0
+            @_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[attributes.hash] || _attributes(attributes)) << " />"
+          else
+            @_target << "<#{tag} />"
+          end
+
+          nil
+        end
+      RUBY
+    end
+  end
+end

data/lib/phlex/rails/tag_helpers.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Rails
+    module TagHelpers
+      def form_with(*args, **kwargs, &block)
+        raw @_view_context.form_with(*args, **kwargs) { |form|
+          capture do
+            yield(
+              Phlex::Buffered.new(form, buffer: @_target)
+            )
+          end
+        }
+      end
+
+      def csp_meta_tag
+        if (output = @_view_context.csp_meta_tag)
+          @_target << output
+        end
+      end
+
+      def csrf_meta_tags
+        if (output = @_view_context.csrf_meta_tags)
+          @_target << output
+        end
+      end
+    end
+  end
+end

data/lib/phlex/rails.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Rails
+  end
+end
+
+Phlex::Component.include(Phlex::Rails::TagHelpers)

data/lib/phlex/renderable.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Renderable
+    def render(renderable, *args, **kwargs, &block)
+      if renderable.is_a?(Component)
+        if block_given? && !block.binding.receiver.is_a?(Phlex::Block)
+          block = Phlex::Block.new(self, &block)
+        end
+
+        renderable.call(@_target, view_context: @_view_context, parent: self, &block)
+      elsif renderable.is_a?(Class) && renderable < Component
+        raise ArgumentError, "You tried to render the Phlex component class: #{renderable.name} but you probably meant to render an instance of that class instead."
+      else
+        @_target << @_view_context.render(renderable, *args, **kwargs, &block)
+      end
+
+      nil
+    end
+
+    def render_in(view_context, &block)
+      if block_given?
+        call(view_context: view_context) do |*args, **kwargs|
+          view_context.with_output_buffer(self) { yield(*args, **kwargs) }
+        end.html_safe
+      else
+        call(view_context: view_context).html_safe
+      end
+    end
+
+    def format
+      :html
+    end
+  end
+end

data/lib/phlex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Phlex
-  VERSION = '0.1.0'
+  VERSION = "0.2.1"
 end

data/lib/phlex.rb

@@ -1,20 +1,30 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/string/output_safety"
-
-require_relative "phlex/version"
-require_relative "phlex/callable"
-require_relative "phlex/tag"
-require_relative "phlex/tag/void_element"
-require_relative "phlex/node"
-require_relative "phlex/tag/standard_element"
-require_relative "phlex/tags"
-require_relative "phlex/context"
-require_relative "phlex/component"
-require_relative "phlex/page"
-require_relative "phlex/text"
+require "cgi"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.ignore("#{__dir__}/generators")
+loader.inflector.inflect("html" => "HTML")
+loader.setup
 
 module Phlex
-  class Error < StandardError; end
-  # Your code goes here...
+  Error = Module.new
+  ArgumentError = Class.new(ArgumentError) { include Error }
+
+  extend self
+
+  ATTRIBUTE_CACHE = {}
+
+  def configuration
+    @configuration ||= Configuration.new
+  end
+
+  def configure
+    yield configuration
+  end
+end
+
+if defined?(Rails::Engine)
+  require "rails"
 end