rbexy 0.3.1 → 2.0.0.beta1

data/lib/rbexy/nodes/html_element.rb

@@ -0,0 +1,48 @@
+module Rbexy
+  module Nodes
+    class HTMLElement < AbstractElement
+      KNOWN_VOID_ELEMENTS = ActionView::Helpers::TagHelper::TagBuilder::VOID_ELEMENTS.map(&:to_s).to_set
+
+      def precompile
+        nodes = []
+
+        if void? && children.length == 0
+          nodes.concat(precompile_open_tag)
+        else
+          nodes.concat(precompile_open_tag)
+          nodes.concat(children.map(&:precompile).flatten)
+          nodes << Raw.new("</#{name}>")
+        end
+
+        nodes
+      end
+
+      private
+
+      def void?
+        KNOWN_VOID_ELEMENTS.include?(name)
+      end
+
+      def precompile_open_tag
+        nodes = [Raw.new("<#{name}")]
+        nodes.concat(precompile_members)
+        nodes << Raw.new(">")
+        nodes
+      end
+
+      def precompile_members
+        members.map do |node|
+          if node.is_a? ExpressionGroup
+            ExpressionGroup.new(
+              node.members,
+              inner_template: "Rbexy::Runtime.splat_attrs(%s)",
+              outer_template: ExpressionGroup::OUTPUT_SAFE
+            )
+          else
+            node
+          end
+        end.map(&:precompile).flatten
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/newline.rb

@@ -0,0 +1,9 @@
+module Rbexy
+  module Nodes
+    class Newline < AbstractNode
+      def compile
+        "\n"
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/raw.rb

@@ -0,0 +1,23 @@
+module Rbexy
+  module Nodes
+    class Raw < AbstractNode
+      attr_reader :content, :template
+
+      OUTPUT = "@output_buffer.safe_concat('%s'.freeze);"
+      EXPR_STRING = "'%s'.html_safe.freeze"
+
+      def initialize(content, template: OUTPUT)
+        @content = content
+        @template = template
+      end
+
+      def compile
+        template % content
+      end
+
+      def merge(other_raw)
+        content << other_raw.content
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/root.rb

@@ -0,0 +1,19 @@
+module Rbexy
+  module Nodes
+    class Root < AbstractNode
+      attr_accessor :children
+
+      def initialize(children)
+        @children = children
+      end
+
+      def precompile
+        Root.new(compact(children.map(&:precompile).flatten))
+      end
+
+      def compile
+        "#{children.map(&:compile).join}@output_buffer.to_s"
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/text.rb

@@ -0,0 +1,15 @@
+module Rbexy
+  module Nodes
+    class Text < AbstractNode
+      attr_accessor :content
+
+      def initialize(content)
+        @content = content
+      end
+
+      def precompile
+        [Raw.new(Util.escape_string(content))]
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/util.rb

@@ -0,0 +1,9 @@
+module Rbexy
+  module Nodes
+    module Util
+      def self.escape_string(str)
+        str.gsub('"', '\\"').gsub("'", "\\'")
+      end
+    end
+  end
+end

data/lib/rbexy/parser.rb

@@ -12,7 +12,7 @@ module Rbexy
 
     def parse
       validate_tokens!
-      Nodes::Template.new(parse_tokens)
+      Nodes::Root.new(parse_tokens)
     end
 
     def parse_tokens
@@ -26,7 +26,7 @@ module Rbexy
     end
 
     def parse_token
-      parse_text || parse_silent_newline || parse_expression || parse_tag || parse_declaration
+      parse_text || parse_newline || parse_expression || parse_tag || parse_declaration
     end
 
     def parse_text
@@ -37,14 +37,14 @@ module Rbexy
     def parse_expression
       return unless take(:OPEN_EXPRESSION)
 
-      statements = []
+      members = []
 
       eventually!(:CLOSE_EXPRESSION)
       until take(:CLOSE_EXPRESSION)
-        statements << (parse_expression_body || parse_tag)
+        members << (parse_expression_body || parse_tag)
       end
 
-      Nodes::ExpressionGroup.new(statements)
+      Nodes::ExpressionGroup.new(members)
     end
 
     def parse_expression!
@@ -60,26 +60,32 @@ module Rbexy
     def parse_tag
       return unless take(:OPEN_TAG_DEF)
 
-      name = take!(:TAG_NAME)
+      details = take!(:TAG_DETAILS)[1]
+      attr_class = details[:type] == :component ? Nodes::ComponentProp : Nodes::HTMLAttr
+
       members = []
-      members.concat(take_all(:SILENT_NEWLINE).map { Nodes::SilentNewline.new })
-      members.concat(parse_attrs)
+      members.concat(take_all(:NEWLINE).map { Nodes::Newline.new })
+      members.concat(parse_attrs(attr_class))
 
       take!(:CLOSE_TAG_DEF)
 
       children = parse_children
 
-      Nodes::XmlNode.new(name[1], members, children)
+      if details[:type] == :component
+        Nodes::ComponentElement.new(details[:component_class], members, children)
+      else
+        Nodes::HTMLElement.new(details[:name], members, children)
+      end
     end
 
-    def parse_attrs
+    def parse_attrs(attr_class)
       return [] unless take(:OPEN_ATTRS)
 
       attrs = []
 
       eventually!(:CLOSE_ATTRS)
       until take(:CLOSE_ATTRS)
-        attrs << (parse_splat_attr || parse_silent_newline || parse_attr)
+        attrs << (parse_splat_attr || parse_newline || parse_attr(attr_class))
       end
 
       attrs
@@ -94,12 +100,12 @@ module Rbexy
       expression
     end
 
-    def parse_silent_newline
-      return unless take(:SILENT_NEWLINE)
-      Nodes::SilentNewline.new
+    def parse_newline
+      return unless take(:NEWLINE)
+      Nodes::Newline.new
     end
 
-    def parse_attr
+    def parse_attr(attr_class)
       name = take!(:ATTR_NAME)[1]
       value = nil
 
@@ -111,7 +117,7 @@ module Rbexy
         value = default_empty_attr_value
       end
 
-      Nodes::XmlAttr.new(name, value)
+      attr_class.new(name, value)
     end
 
     def parse_children

data/lib/rbexy/rails/component_template_resolver.rb

@@ -1,8 +1,8 @@
-require "action_view"
-
 module Rbexy
   module Rails
     class ComponentTemplateResolver < ActionView::FileSystemResolver
+      VIRTUAL_ROOT = "rbexy_component".freeze
+
       # Rails 6 requires us to override `_find_all` in order to hook
       def _find_all(name, prefix, partial, details, key, locals)
         find_templates(name, prefix, partial, details, locals)
@@ -19,7 +19,7 @@ module Rbexy
         Dir["#{templates_path}.*{#{extensions}}"].map do |template_path|
           source = File.binread(template_path)
           handler = ActionView::Template.handler_for_extension(File.extname(template_path)[1..-1])
-          virtual_path = ["rbexy_component", prefix, name].join("/")
+          virtual_path = File.join(VIRTUAL_ROOT, prefix, name)
 
           ActionView::Template.new(
             source,

data/lib/rbexy/rails/controller_helper.rb

@@ -1,17 +1,18 @@
-require "active_support/concern"
-
 module Rbexy
   module Rails
     module ControllerHelper
       extend ActiveSupport::Concern
+      include ComponentContext
 
-      def rbexy_component_provider; end
+      included do
+        helper_method :rbexy_context, :create_context, :use_context
+      end
 
       class_methods do
         def inherited(klass)
           super
           Rbexy.configuration.template_paths.each do |path|
-            prepend_view_path(Rbexy::Rails::ComponentTemplateResolver.new(path))
+            prepend_view_path(ComponentTemplateResolver.new(path))
           end
         end
       end

data/lib/rbexy/rails/engine.rb

@@ -4,25 +4,15 @@ module Rbexy
   module Rails
     class Engine < ::Rails::Engine
       initializer "rbexy" do |app|
-        template_handler = ::Rails.version.to_f >= 6.0 ?
-          proc { |template, source| Rbexy.compile(source) } :
-          proc { |template| Rbexy.compile(template.source) }
+        template_handler = proc { |template, source| Rbexy.compile(template) }
 
         ActionView::Template.register_template_handler(:rbx, template_handler)
 
         ActiveSupport.on_load :action_controller_base do
-          helper Rbexy::ViewContextHelper
-          helper_method :rbexy_component_provider
           include ControllerHelper
         end
 
-        if defined?(ViewComponent)
-          ViewComponent::Base.include Rbexy::ViewContextHelper
-        end
-
         Rbexy.configure do |config|
-          require "rbexy/component_providers/rbexy_provider"
-          config.component_provider = Rbexy::ComponentProviders::RbexyProvider.new
           config.template_paths << ::Rails.root.join("app", "components")
           config.enable_context = true
         end

data/lib/rbexy/refinements.rb

@@ -0,0 +1,5 @@
+module Rbexy
+  module Refinements
+    autoload :Array, "rbexy/refinements/array"
+  end
+end

data/lib/rbexy/refinements/array.rb

@@ -0,0 +1,9 @@
+module Rbexy
+  module Refinements
+    module Array
+      autoload :FindMap, "rbexy/refinements/array/find_map"
+      autoload :InsertBetweenTypes, "rbexy/refinements/array/insert_between_types"
+      autoload :MapTypeWhenNeighboringType, "rbexy/refinements/array/map_type_when_neighboring_type"
+    end
+  end
+end

data/lib/rbexy/refinements/array/find_map.rb

@@ -0,0 +1,13 @@
+module Rbexy
+  module Refinements
+    module Array
+      module FindMap
+        refine ::Array do
+          def find_map
+            lazy.map { |i| yield(i) }.reject { |v| !v }.first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbexy/refinements/array/insert_between_types.rb

@@ -0,0 +1,26 @@
+module Rbexy
+  module Refinements
+    module Array
+      module InsertBetweenTypes
+        refine ::Array do
+          def insert_between_types(type1, type2, &block)
+            map.with_index do |curr, i|
+              prev_i = i - 1
+
+              if prev_i >= 0 && InsertBetweenTypes.one_of_each_type?([self[prev_i], curr], [type1, type2])
+                [block.call, curr]
+              else
+                [curr]
+              end
+            end.flatten
+          end
+        end
+
+        def self.one_of_each_type?(items_pair, types_pair)
+          items_pair[0].is_a?(types_pair[0]) && items_pair[1].is_a?(types_pair[1]) ||
+            items_pair[0].is_a?(types_pair[1]) && items_pair[1].is_a?(types_pair[0])
+        end
+      end
+    end
+  end
+end

data/lib/rbexy/refinements/array/map_type_when_neighboring_type.rb

@@ -0,0 +1,26 @@
+module Rbexy
+  module Refinements
+    module Array
+      module MapTypeWhenNeighboringType
+        refine ::Array do
+          def map_type_when_neighboring_type(map_type, neighboring_type, &block)
+            map.with_index do |curr, i|
+              prev_i = i - 1
+              next_i = i + 1
+
+              if !curr.is_a?(map_type)
+                curr
+              elsif prev_i >= 0 && self[prev_i].is_a?(neighboring_type)
+                block.call(curr)
+              elsif next_i < length && self[next_i].is_a?(neighboring_type)
+                block.call(curr)
+              else
+                curr
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbexy/runtime.rb

@@ -1,39 +1,33 @@
-require "active_support/all"
-require "action_view/helpers"
-require "action_view/context"
-require "action_view/buffers"
-
 module Rbexy
   class Runtime
     include ActionView::Context
     include ActionView::Helpers::TagHelper
-    include ViewContextHelper
-
-    DefaultTagBuilder = ActionView::Helpers::TagHelper::TagBuilder
+    include ComponentContext
 
-    def self.create_tag_builder(context, provider = nil)
-      provider = provider ||
-        provider_from_context(context) ||
-        Rbexy.configuration.component_provider
+    def self.tag_builder
+      # TagBuilder requires a view_context arg, but it's only used in #tag_string.
+      # Since all we need is #tag_options, we pass in a nil view_context.
+      @tag_builder ||= TagBuilder.new(nil)
+    end
 
-      if provider
-        ComponentTagBuilder.new(context, provider)
-      else
-        ActionView::Helpers::TagHelper::TagBuilder.new(context)
-      end
+    def self.splat_attrs(attrs_hash)
+      tag_builder.tag_options(attrs_hash).html_safe
     end
 
-    def self.provider_from_context(context)
-      if context.respond_to?(:rbexy_component_provider)
-        context.rbexy_component_provider
-      end
+    def self.expr_out(*value)
+      return if value.length == 0
+      value = value.first
+
+      value = html_safe_array?(value) ? value.join.html_safe : value
+      [nil, false].include?(value) ? "" : value.to_s
     end
 
-    def initialize(component_provider = nil)
-      @rbexy_tag = self.class.create_tag_builder(self, component_provider)
+    def self.html_safe_array?(value)
+      value.is_a?(Array) && value.all? { |v| v.respond_to?(:html_safe?) && v.html_safe? }
     end
 
     def evaluate(code)
+      @output_buffer = ActionView::OutputBuffer.new
       instance_eval(code)
     rescue => e
       e.set_backtrace(e.backtrace.map { |l| l.gsub("(eval)", "(rbx template string)") })