rbexy 0.3.1 → 2.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e21e51ccf4a683d3f4c26ef53af86382de7fd9b26e3db2a0790fdf6d7e3df800
-  data.tar.gz: f956dd52d3e20229df1290269f17fe28a7cd352cfa4b2c5649ede1f38f8bb9dd
+  metadata.gz: c25ae0414d2229676a67b1ec6ee63c6092d00bb699668cd1213c93d50dee2356
+  data.tar.gz: 00d80e6099de62ca467cf6c75b661cf43eeb8641fe15c510163ba6f02a1fcc99
 SHA512:
-  metadata.gz: e792baa90cab354b588425c5a5851c5c23372c7cafcdb34e65d79bdd8a75b7271668dd02867a4987f6687ee704d4f8d63201e5192cb49a9fa27377610968fb07
-  data.tar.gz: 3d022540841d61746e14b909c70e3e7e769c78e6d03bbc5ca87dd6f611043a197309e83ab068a903089a201f88f7941edd5c1effc68497bb156ec203da2814bc
+  metadata.gz: e29d842f6f9d90c2908be38c58e8d86a365496eb60b093dacc15364f19af00238457a8e7d4877f8db9305a88a29db5c5a6682b2684c41abd8c0ffa19b8279cb4
+  data.tar.gz: 8298b8fa13abef5f8a85f0df96d9abda969cc0b98417c5668f34b644ba79a9d0821c372989f0111149b4abc1b9851eb4d69e8aa79b5d69a91f425a931845e24d

data/Gemfile.lock

@@ -1,10 +1,9 @@
 PATH
   remote: .
   specs:
-    rbexy (0.3.1)
-      actionview (>= 5.0, < 7.0)
-      activesupport (>= 5.0, < 7.0)
-      railties (>= 5.0, < 7.0)
+    rbexy (2.0.0.beta1)
+      actionview (>= 6.0, < 7.0)
+      activesupport (>= 6.0, < 7.0)
 
 GEM
   remote: https://rubygems.org/
@@ -102,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)
@@ -200,8 +200,9 @@ PLATFORMS
 
 DEPENDENCIES
   guard-rspec (~> 4.7, >= 4.7.3)
+  memory_profiler (~> 0.9.14)
   pry-byebug
-  rails (>= 5.0, < 7.0)
+  rails (>= 6.0, < 7.0)
   rake
   rbexy!
   rspec (~> 3.9)

data/README.md

@@ -48,6 +48,8 @@ Add it to your Gemfile and `bundle install`:
 gem "rbexy"
 ```
 
+_From 1.0 onward, we only support Rails 6. If you're using Rails 5, use the 0.x releases._
+
 In `config/application.rb`:
 
 ```ruby
@@ -171,6 +173,14 @@ Loops:
 </ul>
 ```
 
+Blocks:
+
+```jsx
+{link_to "/" do
+  <span>Click me</span>
+end}
+```
+
 As an attribute:
 
 ```jsx
@@ -187,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.

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 :OutputBuffer, "rbexy/output_buffer"
-  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/component.rb

@@ -1,8 +1,9 @@
 require "action_view"
-require "active_support/core_ext/class/attribute"
 
 module Rbexy
   class Component < ActionView::Base
+    autoload :BacktraceCleaner, "rbexy/component/backtrace_cleaner"
+
     class TemplatePath < String
       def to_s
         self
@@ -43,21 +44,13 @@ module Rbexy
       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
     end
 
     def content
-      content_block ? view_context.capture(self, &content_block) : ""
-    end
-
-    def create_context(name, value)
-      rbexy_context.last[name] = value
-    end
-
-    def use_context(name)
-      index = rbexy_context.rindex { |c| c.has_key?(name) }
-      index ?
-        rbexy_context[index][name] :
-        raise(ContextNotFound, "no parent context `#{name}`")
+      content_block ? content_block.call : ""
     end
 
     def compiled_method_container
@@ -69,11 +62,12 @@ module Rbexy
     attr_reader :view_context, :content_block
 
     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 clean_template_backtrace(backtrace)
+      return backtrace if Rbexy.configuration.debug
+      BacktraceCleaner.new(backtrace).call
     end
   end
 end

data/lib/rbexy/component/backtrace_cleaner.rb

@@ -0,0 +1,59 @@
+module Rbexy
+  class Component
+    class BacktraceCleaner
+      attr_reader :backtrace
+
+      def initialize(backtrace)
+        @backtrace = backtrace
+        @found_templates = {}
+      end
+
+      def call
+        backtrace
+          .reject(&method(:internal_implementation_detail?))
+          .map(&method(:strip_rbx_internals_block_mention))
+      end
+
+      private
+
+      attr_reader :found_templates
+
+      def internal_implementation_detail?(line)
+        if template = template_name_if_rbx_internals(line)
+          redundant_internal_block?(line, template)
+        else
+          internal_method_call?(line)
+        end
+      end
+
+      def internal_method_call?(line)
+        line =~ /lib\/rbexy\/.*\.rb/ ||
+          line =~ /lib\/action_view\/.*\.rb/ ||
+          line =~ /lib\/active_support\/notifications\.rb/
+      end
+
+      def redundant_internal_block?(line, template)
+        if found_templates[template]
+          true
+        else
+          found_templates[template] = true
+          false
+        end
+      end
+
+      def strip_rbx_internals_block_mention(line)
+        if template_name_if_rbx_internals(line)
+          line.gsub(/block (\(\d+ levels\))? ?in /, "")
+        else
+          line
+        end
+      end
+
+      def template_name_if_rbx_internals(line)
+        if /\/(?<template>[^\/]*)\.rbx:\d+:in `(block |_)/ =~ line
+          template
+        end
+      end
+    end
+  end
+end

data/lib/rbexy/component_context.rb

@@ -0,0 +1,18 @@
+module Rbexy
+  module ComponentContext
+    def rbexy_context
+      @rbexy_context ||= [{}]
+    end
+
+    def create_context(name, value)
+      rbexy_context.last[name] = value
+    end
+
+    def use_context(name)
+      index = rbexy_context.rindex { |c| c.has_key?(name) }
+      index ?
+        rbexy_context[index][name] :
+        raise(ContextNotFound, "no parent context `#{name}`")
+    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
+
+    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)
+      find!(name)
+    rescue NameError => e
+      raise e unless e.message =~ /wrong constant name/ || e.message =~ /uninitialized constant/
+      nil
+    end
+
+    def matching_namespaces(template)
+      component_namespaces.select { |path, ns| template.identifier.start_with?(path) }.values.flatten.uniq
+    end
+
+    def find!(name)
+      ActiveSupport::Inflector.constantize("#{name.gsub(".", "::")}Component")
+    end
+  end
+end

data/lib/rbexy/configuration.rb

@@ -1,11 +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%{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: /[^}{"'<]+/,
@@ -33,19 +33,19 @@ module Rbexy
       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
@@ -237,7 +237,6 @@ module Rbexy
     end
 
     def potential_expression_inner_tag
-      # binding.pry
       if self.curr_expr =~ Patterns.expression_internal_tag_prefixes
         tokens << [:EXPRESSION_BODY, curr_expr]
         self.curr_expr = ""
@@ -287,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