rbexy 1.1.0 → 2.0.0.beta5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6728982815c307bb37a495c3d11450e9582bf1cd17eef5306c9e940c0c36eea
-  data.tar.gz: 5fdfa1cc3c5fc70b573aa730f827b2f5d38b8031f1adc6344b31926ce520b4af
+  metadata.gz: 5d36622639519d2abe9b9306612de65de836294ad529109d0ed5c1f8f11c0750
+  data.tar.gz: bae1042c6e80c5ec1a4f609162eee4d1efc66f340a6e742bc22d315bf486f597
 SHA512:
-  metadata.gz: 46385e65a3cd976497efd8d6db789eee4a2c73668e085dd6772d8c6a9a835783f6bb80ef923463af97cfec5d5625fffd641229a5a97a1c24e024b75d996969af
-  data.tar.gz: 025e25a41d9cc5e848342c668721cdef046ab13e5cff9737acc69a66eaca6cdd3ac06493bfcbb42b735fcbd6e7ae243e8a65588d648d3442924306944addb714
+  metadata.gz: 749d66a40e869ee18c086d1d1c299936fb8c65ab742492a575a6d1afbc400a8c553df5cb337edf57b43aa200e856ec38b4c2bf6acee3d458a2dcfb86831f4cf7
+  data.tar.gz: 88a13df06a488a65ebf7e6aad95051ae23fad394f628e66e667c2ed1584a4e6c33909209e11ccdb210fbc6f41c089f1ce8cef3b80283e099998290c7608e924e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rbexy (1.1.0)
+    rbexy (2.0.0.beta5)
       actionview (>= 6.0, < 7.0)
       activesupport (>= 6.0, < 7.0)
 
@@ -101,6 +101,7 @@ GEM
       mini_mime (>= 0.1.1)
     marcel (0.3.3)
       mimemagic (~> 0.3.2)
+    memory_profiler (0.9.14)
     method_source (1.0.0)
     mimemagic (0.3.5)
     mini_mime (1.0.2)
@@ -199,6 +200,7 @@ PLATFORMS
 
 DEPENDENCIES
   guard-rspec (~> 4.7, >= 4.7.3)
+  memory_profiler (~> 0.9.14)
   pry-byebug
   rails (>= 6.0, < 7.0)
   rake

data/README.md

@@ -173,6 +173,14 @@ Loops:
 </ul>
 ```
 
+Blocks:
+
+```jsx
+{link_to "/" do
+  <span>Click me</span>
+end}
+```
+
 As an attribute:
 
 ```jsx
@@ -189,6 +197,16 @@ Pass a lambda to a prop, that when called returns a tag:
 </Hero>
 ```
 
+_Note that when using tags inside blocks, the block must evaluate to a single root element. Rbexy behaves similar to JSX in this way. E.g.:_
+
+```
+# Do
+-> { <span><i>Hello</i> World</span> }
+
+# Don't
+-> { <i>Hello</i> World }
+```
+
 ### Tags
 
 You can put standard HTML tags anywhere.
@@ -283,7 +301,7 @@ By default, we'll look for a template file in the same directory as the class an
 <h1>{@title}</h1>
 ```
 
-You can call this component from another `.rbx` template file (`<PageHeader title="Hello" />`)—either one rendered by another component class or a Rails view file like `app/views/products/index.rbx`. Or you can call it from ERB (or any other template language) like `PageHeaderComponent.new(self, title: "Hello").render`.
+You can call this component from another `.rbx` template file (`<PageHeader title="Hello" />`)—either one rendered by another component class or a Rails view file like `app/views/products/index.rbx`. Or you can call it from ERB (or any other template language) like `PageHeaderComponent.new(self, title: "Hello").render_in`.
 
 Your components and their templates run in the same context as traditional Rails views, so you have access to all of the view helpers you're used to as well as any custom helpers you've defined in `app/helpers/`.
 

data/lib/rbexy.rb

@@ -1,15 +1,22 @@
 require "rbexy/version"
+require "active_support/inflector"
+require "active_support/concern"
+require "action_view/helpers/output_safety_helper"
+require "action_view/helpers/capture_helper"
+require "action_view/helpers/tag_helper"
+require "action_view/context"
 
 module Rbexy
   autoload :Lexer, "rbexy/lexer"
   autoload :Parser, "rbexy/parser"
   autoload :Nodes, "rbexy/nodes"
   autoload :Runtime, "rbexy/runtime"
-  autoload :HashMash, "rbexy/hash_mash"
-  autoload :ComponentTagBuilder, "rbexy/component_tag_builder"
-  autoload :ViewContextHelper, "rbexy/view_context_helper"
   autoload :ComponentContext, "rbexy/component_context"
   autoload :Configuration, "rbexy/configuration"
+  autoload :ComponentResolver, "rbexy/component_resolver"
+  autoload :Template, "rbexy/template"
+  autoload :Refinements, "rbexy/refinements"
+  autoload :ASTTransformer, "rbexy/ast_transformer"
 
   ContextNotFound = Class.new(StandardError)
 
@@ -22,14 +29,24 @@ module Rbexy
       @configuration ||= Configuration.new
     end
 
-    def compile(template_string)
-      tokens = Rbexy::Lexer.new(template_string).tokenize
-      template = Rbexy::Parser.new(tokens).parse
-      template.compile
+    def compile(template, context = build_default_compile_context(template))
+      tokens = Lexer.new(template, context.element_resolver).tokenize
+      root = Parser.new(tokens).parse
+      root.inject_compile_context(context)
+      root.transform!
+      root.precompile.compile
     end
 
-    def evaluate(template_string, runtime)
-      runtime.evaluate compile(template_string)
+    def evaluate(template_string, runtime = Rbexy::Runtime.new)
+      runtime.evaluate compile(Template.new(template_string))
+    end
+
+    def build_default_compile_context(template)
+      OpenStruct.new(
+        template: template,
+        element_resolver: configuration.element_resolver,
+        ast_transformer: configuration.transforms
+      )
     end
   end
 end

data/lib/rbexy/ast_transformer.rb

@@ -0,0 +1,21 @@
+module Rbexy
+  class ASTTransformer
+    attr_reader :registry
+
+    def initialize
+      clear!
+    end
+
+    def register(*node_classes, &block)
+      node_classes.each { |k| (registry[k] ||= []) << block }
+    end
+
+    def transform(node, context)
+      registry[node.class]&.each { |t| t.call(node, context) }
+    end
+
+    def clear!
+      @registry = {}
+    end
+  end
+end

data/lib/rbexy/cache_component.rb

@@ -0,0 +1,17 @@
+module Rbexy
+  class CacheComponent < Rbexy::Component
+    def setup(key:)
+      @key = key
+    end
+
+    def call
+      @current_template = view_context.instance_variable_get(:@current_template)
+
+      capture do
+        cache @key, virtual_path: @current_template.virtual_path do
+          @output_buffer << content
+        end
+      end
+    end
+  end
+end

data/lib/rbexy/component.rb

@@ -11,12 +11,22 @@ module Rbexy
       end
     end
 
-    def self.component_name
-      name.underscore
+    class_attribute :component_file_location
+
+    def self.inherited(klass)
+      klass.component_file_location = caller_locations(1, 10).reject { |l| l.label == "inherited" }[0].absolute_path
+    end
+
+    def self.template_path
+      TemplatePath.new(component_name)
     end
 
-    def component_name
-      self.class.component_name
+    def self.call_component?
+      method_defined?(:call)
+    end
+
+    def self.component_name
+      name.underscore
     end
 
     def initialize(view_context, **props)
@@ -28,7 +38,7 @@ module Rbexy
 
       @view_context = view_context
 
-      setup(**props)
+      after_initialize(**props)
     end
 
     # Override in your subclass to handle props, setup your component, etc.
@@ -36,18 +46,9 @@ module Rbexy
     # call super(view_context).
     def setup(**props); end
 
-    def render(&block)
+    def render_in(_context = view_context, &block)
       @content_block = block_given? ? block : nil
-      call
-    end
-
-    def call
-      path = TemplatePath.new(component_name)
-      template = view_context.lookup_context.find(path)
-      template.render(self, {})
-    rescue ActionView::Template::Error => error
-      error.set_backtrace clean_template_backtrace(error.backtrace)
-      raise error
+      self.class.call_component? ? call : _render
     end
 
     def content
@@ -62,17 +63,30 @@ module Rbexy
 
     attr_reader :view_context, :content_block
 
+    def _render
+      path = self.class.template_path
+      template = view_context.lookup_context.find(path)
+      template.render(self, {})
+    rescue ActionView::Template::Error => error
+      error.set_backtrace clean_template_backtrace(error.backtrace)
+      raise error
+    end
+
     def method_missing(meth, *args, &block)
-      if view_context.respond_to?(meth)
-        view_context.send(meth, *args, &block)
-      else
-        super
-      end
+      view_context.send(meth, *args, &block)
+    end
+
+    def respond_to_missing?(method_name, include_all)
+      view_context.respond_to?(method_name, include_all)
     end
 
     def clean_template_backtrace(backtrace)
       return backtrace if Rbexy.configuration.debug
       BacktraceCleaner.new(backtrace).call
     end
+
+    def after_initialize(**props)
+      setup(**props)
+    end
   end
 end

data/lib/rbexy/component_resolver.rb

@@ -0,0 +1,60 @@
+module Rbexy
+  class ComponentResolver
+    using Rbexy::Refinements::Array::FindMap
+
+    KNOWN_HTML_ELEMENTS = %w(
+      a abbr acronym address animate animateMotion animateTransform applet area article aside audio b base basefont
+      bdi bdo bgsound big blink blockquote body br button canvas caption center circle cite clipPath code col colgroup
+      color-profile command content data datalist dd defs del desc details dfn dialog dir discard div dl dt element
+      ellipse em embed feBlend feColorMatrix feComponentTransfer feComposite feConvolveMatrix feDiffuseLighting
+      feDisplacementMap feDistantLight feDropShadow feFlood feFuncA feFuncB feFuncG feFuncR feGaussianBlur feImage
+      feMerge feMergeNode feMorphology feOffset fePointLight feSpecularLighting feSpotLight feTile feTurbulence
+      fieldset figcaption figure filter font footer foreignObject form frame frameset g h1 h2 h3 h4 h5 h6 hatch
+      hatchpath head header hgroup hr html i iframe image img input ins isindex kbd keygen label legend li line
+      linearGradient link listing main map mark marker marquee mask menu menuitem mesh meshgradient meshpatch meshrow
+      meta metadata meter mpath multicol nav nextid nobr noembed noframes noscript object ol optgroup option output p
+      param path pattern picture plaintext polygon polyline pre progress q radialGradient rb rect rp rt rtc ruby s
+      samp script section select set shadow slot small solidcolor source spacer span stop strike strong style sub
+      summary sup svg switch symbol table tbody td template text textarea textPath tfoot th thead time title tr track
+      tspan tt u ul unknown use var video view wbr xmp
+    ).to_set
+
+    def self.try_constantize
+      yield
+    rescue NameError => e
+      raise e unless e.message =~ /wrong constant name/ || e.message =~ /uninitialized constant/
+      nil
+    end
+
+    attr_reader :component_namespaces
+
+    def initialize
+      self.component_namespaces = {}
+    end
+
+    def component_namespaces=(hash)
+      @component_namespaces = hash.transform_keys(&:to_s)
+    end
+
+    def component?(name, template)
+      return false if KNOWN_HTML_ELEMENTS.include?(name)
+      return true if component_class(name, template)
+      false
+    end
+
+    def component_class(name, template)
+      possible_names = matching_namespaces(template).map { |ns| "#{ns}.#{name}" } << name
+      possible_names.find_map(&method(:find))
+    end
+
+    private
+
+    def find(name)
+      self.class.try_constantize { ActiveSupport::Inflector.constantize("#{name.gsub(".", "::")}Component") }
+    end
+
+    def matching_namespaces(template)
+      component_namespaces.select { |path, ns| template.identifier.start_with?(path) }.values.flatten.uniq
+    end
+  end
+end

data/lib/rbexy/configuration.rb

@@ -1,12 +1,29 @@
 module Rbexy
   class Configuration
-    attr_accessor :component_provider
+    attr_accessor :element_resolver
     attr_accessor :template_paths
     attr_accessor :enable_context
     attr_accessor :debug
+    attr_accessor :component_rendering_templates
+    attr_accessor :transforms
 
     def template_paths
       @template_paths ||= []
     end
+
+    def element_resolver
+      @element_resolver ||= ComponentResolver.new
+    end
+
+    def transforms
+      @transforms ||= ASTTransformer.new
+    end
+
+    def component_rendering_templates
+      @component_rendering_templates ||= {
+        children: "{capture{%{children}}}",
+        component: "::%{component_class}.new(%{view_context},%{kwargs}).render_in%{children_block}"
+      }
+    end
   end
 end

data/lib/rbexy/lexer.rb

@@ -10,7 +10,7 @@ module Rbexy
       end
     end
 
-    Patterns = HashMash.new(
+    Patterns = OpenStruct.new(
       open_expression: /{/,
       close_expression: /}/,
       expression_content: /[^}{"'<]+/,
@@ -29,23 +29,23 @@ module Rbexy
       single_quote: /'/,
       double_quoted_text_content: /[^"]+/,
       single_quoted_text_content: /[^']+/,
-      expression_internal_tag_prefixes: /(\s+(&&|\?|:|do|do\s*\|[^\|]+\||{|{\s*\|[^\|]+\|)\s+\z|\A\s*\z)/,
+      expression_internal_tag_prefixes: /(\s+(&&|\|\||\?|:|do|do\s*\|[^\|]+\||{|{\s*\|[^\|]+\|)\s+\z|\A\s*\z)/,
       declaration: /<![^>]*>/
     )
 
-    attr_reader :stack, :tokens, :scanner, :curr_expr_quote_levels
-    attr_accessor :curr_expr_bracket_levels, :curr_expr, :curr_default_text,
+    attr_reader :stack, :tokens, :scanner, :element_resolver, :template
+    attr_accessor :curr_expr, :curr_default_text,
                   :curr_quoted_text
 
-    def initialize(code)
+    def initialize(template, element_resolver)
+      @template = template
+      @scanner = StringScanner.new(template.source)
+      @element_resolver = element_resolver
       @stack = [:default]
-      @curr_expr_bracket_levels = 0
-      @curr_expr_quote_levels = { single: 0, double: 0 }
       @curr_expr = ""
       @curr_default_text = ""
       @curr_quoted_text = ""
       @tokens = []
-      @scanner = StringScanner.new(code)
     end
 
     def tokenize
@@ -59,7 +59,7 @@ module Rbexy
           elsif scanner.scan(Patterns.open_expression)
             open_expression
           elsif scanner.scan(Patterns.comment)
-            tokens << [:SILENT_NEWLINE]
+            tokens << [:NEWLINE]
           elsif scanner.check(Patterns.text_content)
             stack.push(:default_text)
           else
@@ -74,7 +74,7 @@ module Rbexy
           elsif scanner.scan(Patterns.open_expression)
             open_expression
           elsif scanner.scan(Patterns.comment)
-            tokens << [:SILENT_NEWLINE]
+            tokens << [:NEWLINE]
           elsif scanner.check(Patterns.text_content)
             stack.push(:default_text)
           else
@@ -163,9 +163,9 @@ module Rbexy
             tokens << [:CLOSE_TAG_DEF]
             stack.pop
           elsif scanner.scan(Patterns.tag_name)
-            tokens << [:TAG_NAME, scanner.matched]
+            tokens << [:TAG_DETAILS, tag_details(scanner.matched)]
           elsif scanner.scan(Patterns.whitespace)
-            scanner.matched.count("\n").times { tokens << [:SILENT_NEWLINE] }
+            scanner.matched.count("\n").times { tokens << [:NEWLINE] }
             tokens << [:OPEN_ATTRS]
             stack.push(:tag_attrs)
           else
@@ -182,7 +182,7 @@ module Rbexy
           end
         when :tag_attrs
           if scanner.scan(Patterns.whitespace)
-            scanner.matched.count("\n").times { tokens << [:SILENT_NEWLINE] }
+            scanner.matched.count("\n").times { tokens << [:NEWLINE] }
           elsif scanner.check(Patterns.close_tag)
             tokens << [:CLOSE_ATTRS]
             stack.pop
@@ -205,7 +205,7 @@ module Rbexy
             open_expression
           elsif scanner.scan(Patterns.whitespace) || scanner.check(Patterns.close_tag)
             tokens << [:CLOSE_ATTR_VALUE]
-            scanner.matched.count("\n").times { tokens << [:SILENT_NEWLINE] }
+            scanner.matched.count("\n").times { tokens << [:NEWLINE] }
             stack.pop
           else
             raise SyntaxError, self
@@ -286,5 +286,12 @@ module Rbexy
       # etc).
       scanner.scan(Patterns.expression_content) || scanner.scan(Patterns.open_tag_end)
     end
+
+    def tag_details(name)
+      type = element_resolver.component?(name, template) ? :component : :html
+      details = { name: scanner.matched, type: type }
+      details[:component_class] = element_resolver.component_class(name, template) if type == :component
+      details
+    end
   end
 end