rbexy 1.0.1 → 2.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 203d3f0d86ddbf38e11477ca082fec2bd1e4bc1e2843b4a74e08ea593f35a276
-  data.tar.gz: b41f015a023954be101bc01339eeee51f13893fc39918906a4e9d62b4bbfca6c
+  metadata.gz: ee91f09f1492ee300b112dcc61edee9fb96f4938e18753ed435091d212b702ee
+  data.tar.gz: a1ee23c58ac112b8596c0451d2b42b19c35be12a8cd43a8512523f76d454f491
 SHA512:
-  metadata.gz: d038e97f116998e004329938a371d510c7c96d034ab16a1bab0755971397d9020eb7c0459e2bf4f5e95acf9d9a6008b0d9cab208a36f9cab6d2fb7db8e953652
-  data.tar.gz: 503b6f70c7e2c7cfaa76e5dc77382cba4c6ecead1b7837d1870a025a71cf638a09bb1f96a5c74a7b8ac8aa7ef9cbcc030d1d109214fb8406d65eb46211c6fb3b
+  metadata.gz: cfb9b92d18a403a5c5e3d4b87f1120101f7dc961b0e480460bab56d6786f68c2cf06743a759174d1637a34c057299ca2f9391e7895979de1e33694c61ae66654
+  data.tar.gz: 66f9e6e960b87e524fa97b768f61117cdfcc151d68a1cb388607532ecf39df31c1a81f379bffe264ffd31f12600c71bf36d637c8aaa6b56b45df973774207d3b

data/Gemfile.lock

@@ -1,10 +1,9 @@
 PATH
   remote: .
   specs:
-    rbexy (1.0.1)
-      actionview (>= 5.0, < 7.0)
-      activesupport (>= 5.0, < 7.0)
-      railties (>= 5.0, < 7.0)
+    rbexy (2.0.0.beta3)
+      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,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.

data/lib/rbexy.rb

@@ -1,14 +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)
 
@@ -21,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,5 +1,4 @@
 require "action_view"
-require "active_support/core_ext/class/attribute"
 
 module Rbexy
   class Component < ActionView::Base
@@ -28,7 +27,7 @@ module Rbexy
 
       @view_context = view_context
 
-      setup(**props)
+      after_initialize(**props)
     end
 
     # Override in your subclass to handle props, setup your component, etc.
@@ -54,17 +53,6 @@ module Rbexy
       content_block ? content_block.call : ""
     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
-
     def compiled_method_container
       Rbexy::Component
     end
@@ -74,16 +62,20 @@ 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 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_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,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%{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

data/lib/rbexy/nodes.rb

@@ -1,139 +1,19 @@
 module Rbexy
   module Nodes
-    module Util
-      def self.safe_string(str)
-        str.gsub('"', '\\"')
-      end
-
-      def self.safe_tag_name(name)
-        name.gsub(".", "__")
-      end
-    end
-
-    class Template
-      attr_reader :children
-
-      def initialize(children)
-        @children = children
-      end
-
-      def compile
-        "#{children.map(&:compile).map { |c| "@output_buffer << rbexy_prep_output(#{c})"}.join(";")};@output_buffer"
-      end
-    end
-
-    class Text
-      attr_reader :content
-
-      def initialize(content)
-        @content = content
-      end
-
-      def compile
-        "\"#{Util.safe_string(content)}\""
-      end
-    end
-
-    class ExpressionGroup
-      attr_reader :statements
-
-      def initialize(statements)
-        @statements = statements
-      end
-
-      def compile
-        statements.map(&:compile).join
-      end
-    end
-
-    class Expression
-      attr_reader :content
-
-      def initialize(content)
-        @content = content
-      end
-
-      def compile
-        content
-      end
-    end
-
-    class XmlNode
-      attr_reader :name, :members, :children
-
-      def initialize(name, members, children)
-        @name = name
-        @members = members || []
-        @children = children
-      end
-
-      def compile
-        base_tag = "rbexy_tag.#{Util.safe_tag_name(name)}(#{compile_members})"
-        tag = if children.length > 0
-          [
-            "#{base_tag} { capture {",
-              children.map(&:compile).map { |c| "@output_buffer << rbexy_prep_output(#{c})" }.join(";"),
-            "} }"
-          ].join
-        else
-          base_tag
-        end + ".html_safe"
-
-        if Rbexy.configuration.enable_context
-          [
-            "(",
-              "rbexy_context.push({});",
-              "#{tag}.tap { rbexy_context.pop }",
-            ")"
-          ].join
-        else
-          tag
-        end
-      end
-
-      def compile_members
-        members.each_with_object("") do |member, result|
-          case member
-          when ExpressionGroup
-            result << "**#{member.compile},"
-          when SilentNewline
-            result << member.compile
-          else
-            result << "#{member.compile},"
-          end
-        end
-      end
-    end
-
-    class XmlAttr
-      attr_reader :name, :value
-
-      def initialize(name, value)
-        @name = name
-        @value = value
-      end
-
-      def compile
-        "\"#{name}\": #{value.compile}"
-      end
-    end
-
-    class SilentNewline
-      def compile
-        "\n"
-      end
-    end
-
-    class Declaration
-      attr_reader :content
-
-      def initialize(content)
-        @content = content
-      end
-
-      def compile
-        "\"#{Util.safe_string(content)}\".html_safe"
-      end
-    end
+    autoload :Util, "rbexy/nodes/util"
+    autoload :AbstractNode, "rbexy/nodes/abstract_node"
+    autoload :Root, "rbexy/nodes/root"
+    autoload :Raw, "rbexy/nodes/raw"
+    autoload :Text, "rbexy/nodes/text"
+    autoload :ExpressionGroup, "rbexy/nodes/expression_group"
+    autoload :Expression, "rbexy/nodes/expression"
+    autoload :AbstractElement, "rbexy/nodes/abstract_element"
+    autoload :HTMLElement, "rbexy/nodes/html_element"
+    autoload :ComponentElement, "rbexy/nodes/component_element"
+    autoload :AbstractAttr, "rbexy/nodes/abstract_attr"
+    autoload :HTMLAttr, "rbexy/nodes/html_attr"
+    autoload :ComponentProp, "rbexy/nodes/component_prop"
+    autoload :Newline, "rbexy/nodes/newline"
+    autoload :Declaration, "rbexy/nodes/declaration"
   end
 end