rbexy 1.1.0 → 2.0.0.beta5

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.rb

@@ -1,9 +1,11 @@
 module Rbexy
   autoload :Component, "rbexy/component"
+  autoload :CacheComponent, "rbexy/cache_component"
 
   module Rails
     autoload :Engine, "rbexy/rails/engine"
     autoload :ControllerHelper, "rbexy/rails/controller_helper"
     autoload :ComponentTemplateResolver, "rbexy/rails/component_template_resolver"
+    autoload :RbxDependencyTracker, "rbexy/rails/rbx_dependency_tracker"
   end
 end

data/lib/rbexy/rails/component_template_resolver.rb

@@ -1,8 +1,14 @@
-require "action_view"
+require "active_support/digest"
 
 module Rbexy
   module Rails
     class ComponentTemplateResolver < ActionView::FileSystemResolver
+      COMMENT_SYNTAX = {
+        rbx: "# %s",
+        erb: "<%# %s %>",
+        html: "<!-- %s -->"
+      }
+
       # 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)
@@ -14,22 +20,71 @@ module Rbexy
         return [] unless name.is_a? Rbexy::Component::TemplatePath
 
         templates_path = File.join(@path, prefix, name)
+        component_name = prefix.present? ? File.join(prefix, name) : name
+        virtual_path = Rbexy::Component::TemplatePath.new(component_name)
+
         extensions = details[:handlers].join(",")
+        templates = find_rbx_templates(templates_path, extensions, component_name, virtual_path)
+
+        if templates.none?
+          templates = find_call_component_cachebuster_templates(templates_path, component_name, virtual_path)
+        end
+
+        templates
+      end
 
+      def find_rbx_templates(templates_path, extensions, component_name, virtual_path)
         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("/")
+          extension = File.extname(template_path)[1..-1]
+          handler = ActionView::Template.handler_for_extension(extension)
 
           ActionView::Template.new(
-            source,
+            "#{source}#{component_class_cachebuster(component_name, extension)}",
             template_path,
             handler,
+            format: extension.to_sym,
             locals: [],
             virtual_path: virtual_path
           )
         end
       end
+
+      def find_call_component_cachebuster_templates(templates_path, component_name, virtual_path)
+        component_class = find_component_class(component_name)
+        return [] unless component_class && component_class.call_component?
+
+        [
+          ActionView::Template.new(
+            cachebuster_digest_as_comment(component_class.component_file_location, :rbx),
+            "#{templates_path}.rbexycall",
+            ActionView::Template.handler_for_extension(:rbx),
+            format: :rbx,
+            locals: [],
+            virtual_path: virtual_path
+          )
+        ]
+      end
+
+      def component_class_cachebuster(component_name, template_format)
+        component_class = find_component_class(component_name)
+        return unless component_class
+
+        cachebuster_digest_as_comment(component_class.component_file_location, template_format)
+      end
+
+      def find_component_class(component_name)
+        Rbexy::ComponentResolver.try_constantize { component_name.classify.constantize }
+      end
+
+      def cachebuster_digest_as_comment(filename, format)
+        source = File.binread(filename)
+        digest = ActiveSupport::Digest.hexdigest(source)
+
+        comment_template = COMMENT_SYNTAX[format.to_sym] || COMMENT_SYNTAX[:html]
+        comment = comment_template % digest
+        "\n#{comment}"
+      end
     end
   end
 end

data/lib/rbexy/rails/controller_helper.rb

@@ -1,16 +1,10 @@
-require "active_support/concern"
-
 module Rbexy
   module Rails
     module ControllerHelper
       extend ActiveSupport::Concern
       include ComponentContext
 
-      def rbexy_component_provider; end
-
       included do
-        helper ViewContextHelper
-        helper_method :rbexy_component_provider
         helper_method :rbexy_context, :create_context, :use_context
       end
 

data/lib/rbexy/rails/engine.rb

@@ -1,24 +1,20 @@
 require "rbexy/rails"
+require "action_view/dependency_tracker"
 
 module Rbexy
   module Rails
     class Engine < ::Rails::Engine
       initializer "rbexy" do |app|
-        template_handler = proc { |template, source| Rbexy.compile(source) }
+        template_handler = proc { |template, source| Rbexy.compile(Rbexy::Template.new(source, template.identifier)) }
 
         ActionView::Template.register_template_handler(:rbx, template_handler)
+        ActionView::DependencyTracker.register_tracker(:rbx, RbxDependencyTracker)
 
         ActiveSupport.on_load :action_controller_base do
           include ControllerHelper
         end
 
-        if defined?(ViewComponent)
-          ViewComponent::Base.include ViewContextHelper
-        end
-
         Rbexy.configure do |config|
-          require "rbexy/component_providers/rbexy_provider"
-          config.component_provider = ComponentProviders::RbexyProvider.new
           config.template_paths << ::Rails.root.join("app", "components")
           config.enable_context = true
         end

data/lib/rbexy/rails/rbx_dependency_tracker.rb

@@ -0,0 +1,37 @@
+module Rbexy
+  module Rails
+    class RbxDependencyTracker
+      def self.supports_view_paths?
+        true
+      end
+
+      def self.call(name, template, view_paths = nil)
+        new(name, template, view_paths).dependencies
+      end
+
+      def initialize(name, template, view_paths = nil)
+        @name, @template, @view_paths = name, template, view_paths
+      end
+
+      def dependencies
+        rails_render_helper_dependencies + rbexy_dependencies
+      end
+
+      private
+
+      attr_reader :name, :template, :view_paths
+
+      def rails_render_helper_dependencies
+        ActionView::DependencyTracker::ERBTracker.call(name, template, view_paths)
+      end
+
+      def rbexy_dependencies
+        Lexer.new(template, Rbexy.configuration.element_resolver).tokenize
+          .select { |t| t[0] == :TAG_DETAILS && t[1][:type] == :component }
+          .map { |t| t[1][:component_class] }
+          .uniq
+          .map(&:template_path)
+      end
+    end
+  end
+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